---
title: "Connect CMiC to Claude: Automate RFIs, Change Orders & Field Data"
slug: connect-cmic-to-claude-automate-rfis-change-orders-field-data
date: 2026-10-10
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server for CMiC to give Claude secure access to your construction ERP. Automate RFIs, Change Orders, and Daily Journals."
tldr: "Connect CMiC to Claude using Truto's managed MCP server. This guide covers overcoming CMiC's complex data hierarchy, generating dynamic MCP tools, and orchestrating multi-step workflows like RFI generation and PO change orders."
canonical: https://truto.one/blog/connect-cmic-to-claude-automate-rfis-change-orders-field-data/
---

# Connect CMiC to Claude: Automate RFIs, Change Orders & Field Data


If your team uses ChatGPT, check out our guide on [/connect-cmic-to-chatgpt-manage-construction-projects-financials/](https://truto.one/connect-cmic-to-chatgpt-manage-construction-projects-financials/) or explore our broader architectural overview on [/connect-cmic-to-ai-agents-orchestrate-procurement-payroll-tasks/](https://truto.one/connect-cmic-to-ai-agents-orchestrate-procurement-payroll-tasks/).

If you need to connect CMiC to Claude to automate Requests for Information (RFIs), process purchase change orders, or parse unstructured field data into Daily Journals, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's LLM function calls and CMiC's complex REST APIs.

You can either build and maintain this infrastructure yourself—handling the dense CMiC data model, OAuth lifecycles, and pagination schemas—or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

Giving a Large Language Model (LLM) read and write access to a sprawling construction ERP like CMiC is a serious engineering challenge. CMiC's architecture is deeply relational. An LLM cannot just "create a change order." It must navigate company codes, job codes, phase codes, and master-detail record hierarchies. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for CMiC, connect it natively to Claude Desktop, and execute complex construction workflows using natural language.

> Want to give your AI agents secure, authenticated access to CMiC and 100+ other B2B APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the CMiC API

A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools over JSON-RPC, the reality of implementing it against a highly specialized ERP API is painful. CMiC is built for heavy civil, commercial, and specialty contractors. Its API reflects the rigidity and complexity of construction accounting.

If you decide to [build a custom CMiC MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), here are the specific integration challenges your engineering team will face:

**Master-Detail Hierarchies and Posting Routines**
CMiC heavily utilizes a master-detail data model. For example, creating a Purchase Order (PO) Change Order requires creating a header record (`po_change_order_master`) and then associating multiple detail lines (`po_change_order_lines`). An LLM has no inherent concept of transactional integrity. If the detail lines fail, you are left with an orphaned header. Furthermore, financial records in CMiC often sit in an "unposted" state. A successful POST request doesn't mean the data is live in the ledger; it often requires a secondary API call to a specific posting endpoint (e.g., `postvoucher` or `po_change_order_post`) to commit the transaction.

**The Universal `CompCode` and `JobCode` Dependency**
Almost every resource in the CMiC API requires context parameters that LLMs struggle to infer. You cannot simply query for an invoice or an RFI by an ID alone. You frequently need to pass the `CompCode` (Company Code) and `JobCode` (Job/Project Code). Your MCP tools must be engineered to explicitly require these fields in their JSON schemas, forcing the LLM to either ask the user for them or retrieve them via a prerequisite tool call.

**VUUIDs vs. Functional Identifiers**
CMiC operates with dual identifiers. Many objects have a functional, human-readable identifier (like a Vendor Code or Job Name) and a backend Virtual UUID (VUUID). When updating or deleting records via the API, the VUUID is almost always required. Your MCP tools must map the human-readable string the user provides to the internal VUUID via a search tool before attempting a PUT or PATCH request.

By using Truto, the MCP server is generated dynamically from documented API schemas. The tools presented to Claude already contain the exact JSON schema requirements—including required fields like `CompCode`—drastically reducing LLM hallucination rates.

## Generating the CMiC MCP Server

Truto creates MCP servers by dynamically deriving tool definitions from the integration's documented API resources. The server is scoped entirely to a single integrated CMiC account. The resulting URL contains a cryptographic token that securely identifies the tenant and their specific configuration.

You can create this MCP server in two ways: through the Truto dashboard, or programmatically via the API.

### Method 1: Via the Truto UI

For internal tooling and rapid prototyping, generating the URL via the dashboard takes seconds.

1. Log into Truto and navigate to the **Integrated Accounts** page.
2. Select your connected CMiC account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restricting access to `read` only, or filtering by specific functional tags like `project_management`).
6. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/abc123def456...`).

### Method 2: Via the Truto API

For production deployments where you are spinning up agents for your end-users dynamically, you will use the API. 

Make an authenticated POST request to the `/integrated-account/:id/mcp` endpoint:

```bash
curl -X POST https://api.truto.one/integrated-account/<your_cmic_account_id>/mcp \
  -H "Authorization: Bearer <your_truto_api_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CMiC Project Manager Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The response returns the secure URL you will provide to your AI agent framework:

```json
{
  "id": "mcp_01hq...",
  "name": "CMiC Project Manager Agent",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123def456..."
}
```

## Connecting the MCP Server to Claude

Once you have the URL, you need to register the server with your LLM client. MCP operates over a JSON-RPC 2.0 protocol using HTTP POST. Because Truto's MCP servers support Server-Sent Events (SSE), integration is entirely configuration-driven.

### Method A: Via the Claude UI (or ChatGPT)

If you are using the Claude web interface or ChatGPT with custom GPTs/Connectors:

1. In Claude, navigate to **Settings** → **Integrations** → **Add MCP Server** (In ChatGPT, this is Settings → Apps → Advanced settings → Add custom connector).
2. Name the integration "CMiC ERP".
3. Paste the Truto MCP Server URL.
4. Click **Add**. Claude will immediately perform a handshake (`initialize`) and discover the available CMiC tools.

### Method B: Via Manual Configuration File (Claude Desktop)

For local development and testing with Claude Desktop, you must modify the `claude_desktop_config.json` file. Truto provides an official NPM package (`@modelcontextprotocol/server-sse`) that bridges Claude's standard stdio requirements with Truto's remote SSE endpoints.

Update your config file (located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "cmic_erp": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/abc123def456..."
      ]
    }
  }
}
```

Restart Claude Desktop. The "hammer" icon will appear, indicating that the CMiC tools are loaded and ready to use.

## CMiC Hero Tools for Claude

Truto exposes hundreds of endpoints across CMiC's financial, project management, and equipment modules. Here are the highest-leverage "hero" tools for automating construction operations with Claude.

### `create_a_c_mi_c_pmrfi`
**Description:** Creates a Project Management Request for Information (RFI). 
**Usage Notes:** This tool requires specific relation codes: `PmrfiCompCode`, `PmrfiProjCode`, and the `PmrfiFromContactCode`. It is heavily used to automate field-to-office communication based on site notes.

> "I need you to create a new RFI for project 'HQ-Build' (Code: 9001). The subject is 'Mismatched HVAC ducting on floor 3'. Assign the 'From' contact as C-889. Explain that the specs call for 12-inch ducts but 14-inch arrived on site."

### `create_a_c_mi_c_po_change_order`
**Description:** Creates a Purchase Change Order header and automatically generates associated summary lines from its parent purchase order.
**Usage Notes:** Financial tools in CMiC require precision. This tool expects the company code (`pocsCompCode`), the original PO number (`pocsPoNum`), and the specific line items being modified. 

> "Create a PO change order for Company 01, PO Number PO-2023-445. We need to add $5,000 to the total for expedited lumber delivery on release number 2."

### `list_all_c_mi_c_pmdailyjournal`
**Description:** Retrieves PM Daily Journals. 
**Usage Notes:** Daily journals consolidate weather, labor (`pmdailyjourlab`), equipment (`pmdailyjouroeqp`), and field notes. This tool is excellent for querying past conditions to defend against delay claims.

> "Pull the daily journals for Job 8055 from last week. Summarize all weather delays and list the subcontractors who reported being on site during the rain event on Wednesday."

### `list_all_c_mi_c_jcjobcostcodes`
**Description:** Retrieves Job Costing (JC) Phase Codes.
**Usage Notes:** Cost codes are the fundamental tracking mechanism in CMiC. AI agents need this tool to accurately map raw text descriptions (e.g., "concrete pouring") to the exact billing code for a specific job.

> "List the job cost codes for Job 4040. Find the code that corresponds to 'structural steel erection' so we can correctly categorize the latest invoice."

### `create_a_c_mi_c_pmsubmittal`
**Description:** Creates a PM Submittal.
**Usage Notes:** Submittals track materials and shop drawings requiring architect approval. This tool requires the `PmsmCompCode`, `PmsmProjCode`, and `PmsmRequiredEndDate`.

> "Create a new submittal for the lighting fixtures on Project 550. Set the required end date to two weeks from today, and flag it as a procurement item."

### `list_all_c_mi_c_jcjob`
**Description:** Retrieves JC Jobs (Projects).
**Usage Notes:** This is typically the first tool an agent must call. It allows Claude to map a user's natural language request ("the downtown highrise") to the exact `JobCode` required by all downstream endpoints.

> "Search our active jobs for anything matching 'Downtown Tower' and return the Company Code, Job Code, and the primary project manager's contact code."

*This is just a small sample of the available tools. Truto auto-generates schema-compliant tools for AP Vouchers, AR Invoices, Equipment Timesheets, and more. For the complete API inventory, visit the [Truto CMiC Integration Page](https://truto.one/integrations/detail/cmic).* 

## Workflows in Action

Once the MCP server is connected, Claude operates as an autonomous agent, chaining these tools together to execute complex construction workflows. Here is what that looks like in practice.

### Scenario 1: Field Data to PM (Creating an RFI from a Daily Log)

Field superintendents often drop rough notes into daily journals. Project managers need to identify issues and formalize them into RFIs for architects.

> "Analyze yesterday's daily journals for Job 1001. If there are any noted material delays or discrepancies, draft and create an RFI addressing the issue."

**Agent Execution Steps:**
1. **`list_all_c_mi_c_pmdailyjournal`**: Claude queries the daily journals for the specific `JobCode` (1001) for yesterday's date.
2. **Analysis:** The LLM processes the returned JSON payload and identifies a note: "Electrical contractor flagged that panel B doesn't fit in the framed closet space."
3. **`create_a_c_mi_c_pmrfi`**: Claude dynamically constructs the RFI payload, setting the subject to "Electrical Panel B clearance issue", filling in the `CompCode` and `ProjCode`, and executing the POST request.

**Outcome:** The user receives confirmation that the daily log was reviewed and a formal RFI was successfully logged in CMiC, saving the PM an hour of cross-referencing.

```mermaid
sequenceDiagram
    participant User
    participant Claude
    participant Truto as Truto MCP Server
    participant CMiC as CMiC API

    User->>Claude: "Review yesterday's journals for Job 1001 and create RFIs for delays."
    Claude->>Truto: Call list_all_c_mi_c_pmdailyjournal(JobCode=1001, Date=Yesterday)
    Truto->>CMiC: GET /pmdailyjournal?job=1001
    CMiC-->>Truto: JSON (Daily Journals)
    Truto-->>Claude: Tool Result (Journals)
    Claude->>Claude: Analyze text for delays/issues
    Claude->>Truto: Call create_a_c_mi_c_pmrfi(Subject="Panel B Clearance", ...)
    Truto->>CMiC: POST /pmrfi
    CMiC-->>Truto: 201 Created (RFI ID)
    Truto-->>Claude: Tool Result (Success)
    Claude-->>User: "RFI for Electrical Panel B has been created."
```

### Scenario 2: Financial Change Order Automation

Change orders require pulling contextual data before executing the final financial transaction.

> "Find PO #9021 for Vendor V-450. We need to create a change order adding a new line item for $2,500 due to expedited freight."

**Agent Execution Steps:**
1. **`list_all_c_mi_c_purchase_order_lines`**: Claude queries the existing PO to retrieve the `CompCode`, `ReleaseNum`, and current line items.
2. **`create_a_c_mi_c_po_change_order`**: Claude creates the master header for the change order associated with PO #9021.
3. **`create_a_c_mi_c_po_change_order_line`**: Claude creates the specific summary detail line, setting the cost to $2,500 and the description to "Expedited Freight".

**Outcome:** The LLM successfully navigates CMiC's strict header/detail line hierarchy. The user receives the new Change Order number ready for review and posting.

## Security and Access Control

Giving an AI agent access to core ERP financials and project data requires strict guardrails. Truto’s MCP architecture includes several built-in security features:

*   **Method Filtering:** When generating the server via `/integrated-account/:id/mcp`, pass `"methods": ["read"]` in the configuration. This ensures the MCP server strictly generates `GET` and `LIST` tools. If Claude hallucinates a `POST` request, the tool simply does not exist on the server to be called.
*   **Tag Filtering:** Limit the server's scope by functional area. By passing `"tags": ["project_management"]`, you prevent the agent from accessing financial (`apvoucher`, `gljournal`) or HR tools.
*   **Authentication Chaining (`require_api_token_auth`):** For sensitive deployments, enabling this flag requires the MCP client to pass a valid Truto API token in the `Authorization` header, ensuring the URL cannot be abused if leaked.
*   **Ephemeral Servers (`expires_at`):** You can generate temporary MCP servers for contractors or specific agent tasks. Once the `expires_at` timestamp is reached, Truto's distributed edge scheduler permanently purges the token from the key-value store.

**A Factual Note on Rate Limits:** The CMiC API imposes strict quotas. Truto acts as a transparent proxy and does *not* intercept, retry, or apply exponential backoff to rate limit errors. If CMiC returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit data into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your [agent framework](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) (e.g., LangGraph, CrewAI) is responsible for detecting the 429 error and managing the retry/backoff logic.

## Moving Forward

Connecting Claude to CMiC via a managed MCP server removes the heavy lifting of maintaining ERP API integrations. You no longer have to parse complex WSDLs, manage VUUID lookups, or build custom logic to handle CMiC's master-detail relationships. Truto handles the schema normalization and protocol translation, letting your engineering team focus on building the actual AI agent workflows that save project managers hours of manual data entry.

> Ready to connect your AI agents to CMiC, Procore, NetSuite, and 100+ other enterprise APIs? Let's discuss your architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)