Connect Arcadia to Claude: Sync Meter Data and Statements

If you need to connect Arcadia to Claude to sync utility meter intervals, process energy statements, or automate sustainability reporting, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Arcadia's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Arcadia to ChatGPT or explore our broader architectural overview on connecting Arcadia to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise utility data platform like Arcadia is an engineering challenge. You have to handle credential lifecycles, map massive JSON schemas for interval data to MCP tool definitions, and deal with Arcadia's highly specific async job patterns. Every time Arcadia updates an endpoint or deprecates a field, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Arcadia, connect it natively to Claude, and execute complex workflows using natural language.

The Engineering Reality of the Arcadia API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Arcadia's APIs is painful. You are not just integrating a standard CRUD API - you are integrating a complex utility data pipeline that bridges physical grid infrastructure with digital records.

If you decide to build a custom MCP server for Arcadia, you own the entire API lifecycle. Here are the specific challenges you will face:

Two-Step Asynchronous Downloads Arcadia rarely serves massive datasets like meter intervals or bulk statement summaries synchronously. Instead, it uses a two-step process. First, you POST a request containing up to 500 meter IDs. Arcadia returns a 202 Accepted with a URL or webhook ID. You then have to poll a secondary endpoint to stream the file. LLMs struggle immensely with unguided polling. If you just expose the raw endpoints, Claude will either invent a webhook ID or hallucinate the CSV contents. Truto's doc-driven schemas explicitly instruct Claude on how to parse the initial token, wait, and use it in the subsequent polling tool.

Complex Hierarchical Data Models Arcadia's data model is deeply nested: Organizations have Sites, Sites have Accounts, Accounts have Meters and Statements, and Meters have Intervals. When an LLM wants to pull interval data for a building, it first needs to navigate this hierarchy. Truto exposes this via flat proxy operations with clear query parameters, allowing the LLM to traverse the utility topology without needing to understand the underlying graph structure.

Strict Rate Limits and 429 Passthrough Arcadia enforces strict API quotas, especially on heavy endpoints like interval data extraction. If Claude gets stuck in a loop trying to iterate over 10,000 meters, it will hit a wall. Truto does not retry, throttle, or apply backoff on rate limit errors. Instead, when Arcadia returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This explicit passthrough is critical for AI agents - Claude needs to receive the 429 directly so it can implement its own reasoning to pause, wait for the reset window, and retry the operation.

How to Generate an Arcadia MCP Server with Truto

Truto dynamically generates MCP tools based on Arcadia's API resources and documentation. When you connect an Arcadia account for a specific tenant (creating an "Integrated Account"), you can spin up an MCP server scoped entirely to that tenant. Truto reads the available API endpoints, pulls the query and body schemas, injects necessary pagination logic, and serves them over a JSON-RPC 2.0 endpoint.

You can generate the MCP server using either the Truto UI or the API.

Method 1: Via the Truto UI

This is the fastest method for manual setup or testing.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select the connected Arcadia account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server. You can optionally restrict it to specific operations (e.g., read only) or specific tags (e.g., meters, statements).
5. Click Create and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method 2: Via the Truto API

For teams building multi-tenant AI products, you should automate server creation. Make a POST request to the Truto API using your environment token.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Arcadia Meter Analyzer",
    "config": {
      "methods": ["read", "list"],
      "tags": ["meters", "intervals", "statements"]
    }
  }'

The API validates that the Arcadia integration has documented tools available, securely hashes the token, and returns a ready-to-use URL:

{
  "id": "mcp_srv_89101112",
  "name": "Arcadia Meter Analyzer",
  "config": {
    "methods": ["read", "list"],
    "tags": ["meters", "intervals", "statements"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}

This URL is fully self-contained. It encodes the tenant routing and handles the OAuth lifecycle automatically.

How to Connect Arcadia to Claude

Once you have your Truto MCP server URL, you must connect it to your Claude environment. You can do this through the Claude Desktop UI or via configuration files for custom agent setups.

Method A: Via the Claude Desktop UI

If you are using Claude Desktop for local workflows:

1. Open Claude Desktop.
2. Go to Settings -> Integrations -> Add MCP Server.
3. Paste the Truto MCP URL into the connection field.
4. Click Add.

Claude will immediately execute an initialize handshake and call tools/list. The model will now have native access to the Arcadia tools.

(Note: If your team uses ChatGPT Enterprise, you can follow a similar path: Settings -> Apps -> Advanced settings -> enable Developer mode, and add the server URL under Custom Connectors).

Method B: Via Manual Config File (SSE Transport)

If you are deploying Claude via a programmatic setup, CLI, or an environment like Cursor, you connect via Server-Sent Events (SSE) using the official @modelcontextprotocol/server-sse package.

Modify your claude_desktop_config.json (or equivalent framework config) to point to the Truto URL:

{
  "mcpServers": {
    "arcadia_utility_sync": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
      ]
    }
  }
}

Restart your client. The agent will fetch the tools and make them available for function calling.

Hero Tools for Arcadia

Arcadia has a massive API surface area. Truto exposes dozens of endpoints, but these are the high-leverage "hero" operations that AI agents use most frequently when dealing with utility data.

List All Accounts Details

Retrieves detailed information across the Arcadia system for the tenant, including status, meter counts, provider metadata, and gap summaries.

"Fetch a list of all active Arcadia accounts and filter for accounts that have a gap summary indicating missing statements. Return their account numbers and provider names."

List All Arcadia Plug Meters

Lists all meters retrieved from utility providers. This is the starting point for any usage or interval analysis.

"Find all electric meters associated with site ID 'site_889900'. I need the meter numbers, their current status, and the service type."

Prepare Intervals CSV Download

Initiates the first step of Arcadia's async 2-step process for retrieving meter interval data. It takes up to 500 meter IDs and returns a URL token.

"I need the 15-minute interval usage data for the following three meter IDs: 'm_111', 'm_222', and 'm_333'. Initiate the interval download request and give me the tracking ID."

Stream Download Sources

Executes the second step of the async download. You pass the token generated from the interval or statement prep tools, and it polls for the finished CSV stream.

"Check the status of the download request webhook ID 'wh_888999'. If it returns a 200 OK, parse the CSV and summarize the peak usage times."

List Detailed Statements

Retrieves granular statement metadata across the account, including statement dates, total charges, outstanding balances, and due dates.

"Pull the detailed statements for account 'acc_555' over the last 6 months. Calculate the total amount billed and highlight any outstanding balances."

Download Statement Source File

Retrieves the actual binary PDF file stream for a specific utility statement, which can then be processed by Claude's vision or document parsing capabilities.

"Download the source PDF for statement ID 'stmt_12345' and extract the line-item charges for transmission and distribution."

For the complete tool inventory, including webhook management, organization custom data updates, and credential lifecycle tools, see the Arcadia integration page.

Workflows in Action

MCP servers don't just execute single endpoints; they allow Claude to orchestrate complex, multi-step processes across the Arcadia ecosystem autonomously. Here is what that looks like in practice.

Scenario 1: Demand Response Modeling

An energy analyst needs to identify the peak load hours for a commercial building to evaluate it for a demand response program.

"Find all electric meters for the 'Downtown Office' site. Pull their interval data for the month of July. Analyze the CSV and tell me which 4-hour window consistently hits the highest kW demand."

How Claude executes this:

1. Calls list_all_arcadia_plug_sites with a search filter for "Downtown Office" to retrieve the site ID.
2. Calls list_all_arcadia_plug_meters filtering by the discovered site ID and service type (electric) to gather an array of meter IDs.
3. Calls create_a_arcadia_downloads_interval with the meter IDs to trigger the backend data extraction, receiving a webhook ID.
4. Enters a polling loop calling list_all_arcadia_download_sources with the webhook ID. If it hits a 202 Pending, it waits. Once it gets a 200 OK, it parses the returned CSV stream.
5. Analyzes the normalized interval values and summarizes the peak load periods.

Scenario 2: Automated Statement Reconciliation

A finance operator needs to reconcile outstanding utility balances against raw vendor invoices.

"Find any statements with an outstanding balance greater than $500. For each one, download the source PDF, read the line items, and verify if there are any unexpected late fees or adjustments."

How Claude executes this:

1. Calls list_all_arcadia_statements_details to retrieve recent statement metadata.
2. Filters the JSON array internally to isolate records where outstandingBalance is > 500.
3. For each matching record, extracts the statement_id.
4. Calls arcadia_sources_list_4 with the statement_id to download the raw utility bill PDF.
5. Reads the PDF content, extracts the line items, and compares the raw invoice data against the expected charges.

Security and Access Control

When connecting powerful AI agents to production utility data, security is paramount. Truto's MCP architecture provides strict controls to ensure agents only access what they need.

• Tenant Isolation: Every MCP server URL is cryptographically tied to a single integrated Arcadia account. Cross-tenant data leakage is structurally impossible at the API layer.
• Method Filtering: You can configure the MCP token (via config.methods) to allow only read operations. If you pass ["read"] during creation, endpoints that create, update, or delete Arcadia resources will be completely stripped from the schema before Claude even sees them.
• Tag Filtering: You can limit the server to specific resource domains. Passing config.tags = ["meters", "statements"] ensures the LLM cannot access or modify credentials or webhook configurations.
• Time-to-Live (TTL): By setting an expires_at timestamp when creating the MCP server, you can generate temporary access credentials. Once expired, the server automatically self-destructs and the token is flushed from edge KV storage.
• Require API Token Auth: For internal enterprise deployments, you can set require_api_token_auth: true. This forces the client to pass a valid Truto session token or API key in addition to the URL token, providing defense in depth.

Moving Past Manual Utility Pipelines

Connecting Claude to Arcadia via MCP changes how organizations interact with utility data. Instead of building rigid ETL pipelines that dump flat files into a data warehouse, you give reasoning engines direct access to the source of truth. They can traverse the grid topology, trigger asynchronous interval jobs, parse complex PDF statements, and gracefully back off when they hit the vendor's rate limits.

By using Truto to generate your MCP servers, you bypass the boilerplate. You don't have to write custom polling wrappers, handle OAuth token refreshes, or maintain brittle OpenAPI specifications. You generate a secure URL, hand it to Claude, and let the agent do the work.