---
title: "Connect DoiT to Claude: View Cloud Diagrams and Support Tickets"
slug: connect-doit-to-claude-view-cloud-diagrams-and-support-tickets
date: 2026-07-16
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect DoiT to Claude using a managed MCP server to automate FinOps analysis, query cloud diagrams, and manage support tickets."
tldr: "Connecting DoiT to Claude enables AI agents to query FinOps data, extract cloud diagrams, and triage support tickets. This guide shows how to generate a secure MCP server with Truto and configure Claude Desktop for automated DoiT workflows."
canonical: https://truto.one/blog/connect-doit-to-claude-view-cloud-diagrams-and-support-tickets/
---

# Connect DoiT to Claude: View Cloud Diagrams and Support Tickets


If you need to connect DoiT to Claude to automate FinOps reporting, view cloud infrastructure diagrams, or triage support tickets, 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 tool calls and DoiT'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 DoiT to ChatGPT](https://truto.one/connect-doit-to-chatgpt-analyze-cloud-analytics-and-alerts/) or explore our broader architectural overview on [connecting DoiT to AI Agents](https://truto.one/connect-doit-to-ai-agents-automate-cloudflows-and-finops/).

Giving a Large Language Model (LLM) read and write access to a complex cloud management ecosystem like DoiT is an engineering challenge. You have to handle API token lifecycles, map complex cloud analytics schemas to MCP tool definitions, and deal with DoiT's specific data structures. Every time DoiT updates an endpoint or deprecates a reporting metric, 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for DoiT, connect it natively to Claude, and execute complex FinOps and DevOps workflows using natural language.

## The Engineering Reality of the DoiT 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 DoiT's API is painful. You are not just integrating a standard CRM - you are integrating a massive FinOps engine with complex reporting dimensions, graph-based architecture diagrams, and streaming capabilities.

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

**Complex Nested Analytics Queries**
DoiT's Cloud Analytics API does not rely on simple CRUD endpoints. Querying cost data or retrieving report configurations requires passing deeply nested JSON objects defining dimensions, metrics, filters, and time bounds. Exposing raw, unstructured endpoints to Claude often results in hallucinated query parameters or malformed JSON payloads. A managed MCP server exposes strict JSON schemas derived directly from DoiT's API documentation, forcing Claude to structure its analytics queries correctly before the request is ever sent.

**Graph-Based Diagram Extraction**
DoiT's Cloud Diagrams feature (Scheme) relies on complex layer structures and node-edge relationships. When fetching a diagram via the API, you receive massive payloads detailing every projected component, sub-component, and security group. Building an MCP tool that allows an LLM to reliably parse and traverse this graph structure requires meticulous schema definition. Truto normalizes these complex endpoints into predictable tools, allowing Claude to target specific status sheets or layers without drowning in malformed graph data.

**Handling Rate Limits and Backoff**
DoiT enforces rate limits on API requests to protect their infrastructure. If your AI agent gets stuck in a loop trying to iterate through thousands of billing allocations or analytics annotations, the DoiT API will return an HTTP `429 Too Many Requests` error. 

*Note on rate limit handling:* Truto does not absorb, retry, or apply backoff to these errors. Instead, Truto passes the `429` error directly to the caller (Claude) and normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). This ensures your AI agent has accurate context to execute its own backoff and retry strategy without failing silently.

## How to Generate a DoiT MCP Server with Truto

Truto [dynamically generates MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) based on DoiT's API documentation and your environment configurations. Because the MCP server is scoped to a specific authenticated DoiT account, the URL contains a cryptographic token that handles all underlying authentication. 

You can generate this server URL in two ways: via the Truto UI for manual setup, or via the Truto API for programmatic deployment.

### Method 1: Via the Truto UI

If you are setting this up for your own internal team, the UI is the fastest path:

1. Log into Truto and navigate to the **Integrated Accounts** page for your DoiT connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., restrict to `read` methods, filter by `analytics` tags, set an expiration date).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

If you are dynamically provisioning AI agents for your customers, you can generate MCP servers programmatically. This endpoint validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "DoiT FinOps Agent",
    "config": {
      "methods": ["read", "custom"],
      "tags": ["analytics", "diagrams", "support"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API responds with the server ID and the cryptographic URL:

```json
{
  "id": "mcp_9a8b7c6d",
  "name": "DoiT FinOps Agent",
  "config": {
    "methods": ["read", "custom"],
    "tags": ["analytics", "diagrams", "support"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with Claude. The URL acts as a fully self-contained JSON-RPC 2.0 endpoint. 

### Method A: Via the Claude UI

For users on Claude Desktop or web (Pro/Team/Enterprise):
1. Open **Settings**.
2. Navigate to **Integrations** or **Connectors**.
3. Click **Add MCP Server** or **Add custom connector**.
4. Paste the Truto MCP URL and click **Add**.
Claude will immediately ping the endpoint, execute the handshake, and discover the available DoiT tools.

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

If you prefer managing configurations as code, you can update Claude Desktop's config file directly. Truto MCP servers use Server-Sent Events (SSE) for transport.

Edit your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):

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

Save the file and restart Claude Desktop. The tools will now be available in your prompts.

## Hero Tools for DoiT

Truto automatically derives tool schemas from DoiT's documentation. When Claude queries the `tools/list` endpoint, it receives highly structured definitions detailing exact required fields and expected responses. 

Here are some of the highest-leverage operations you can expose to Claude.

### List All Cloud Anomalies

`list_all_doi_t_anomalies`
Retrieves a list of detected cost anomalies in your DoiT account. This is critical for agents acting as automated FinOps monitors. It returns the anomaly attribution, affected billing account, cost impact, and severity level.

> "Check DoiT for any new cost anomalies over the last 48 hours. Group them by severity level and list the total cost impact for each billing account."

### Get Single Analytics Report

`get_single_doi_t_analytics_report_by_id`
Fetches the specific results of a saved Cloud Analytics report. Because report results return a complex, content-type-specific object, exposing this to Claude allows the LLM to parse raw FinOps data tables and summarize spending trends without manual data exports.

> "Pull the results for the Cloud Analytics report ID 'rpt-aws-q3-spend'. Summarize the top three highest-spending AWS regions from the dataset."

### Search Cloud Diagrams

`create_a_doi_t_scheme_search`
Searches across your DoiT cloud diagrams and components using a JSON query. This is incredibly powerful for DevOps agents tracking down unattached storage volumes, verifying network topologies, or identifying specific EC2 instances across massive architectures.

> "Search our DoiT cloud diagrams for any RDS instances located in us-east-1 that are not associated with a production security group."

### List All Support Tickets

`list_all_doi_t_support_tickets`
Retrieves support tickets across your DoiT organization. The tool supports filtering and time bounds, allowing Claude to act as a triage assistant for cloud infrastructure issues.

> "List all open DoiT support tickets created in the last 7 days that have a severity of 'High' or 'Critical'."

### Ask Ava (Synchronous)

`create_a_doi_t_ava_ask_sync`
Sends a natural language question directly to Ava (DoiT's AI assistant) and receives a synchronous response. This allows Claude to leverage DoiT's native, highly-specialized FinOps knowledge base for complex cloud architecture queries.

> "Ask DoiT's Ava what the most cost-effective Google Cloud compute family is for high-memory batch processing workloads."

### Trigger a CloudFlow

`create_a_doi_t_cloudflow_trigger`
Triggers a published DoiT CloudFlow. CloudFlows allow you to automate cloud operations and governance rules. By giving Claude access to this tool, the agent can execute predefined infrastructure remediations directly.

> "Trigger the DoiT CloudFlow 'cf-terminate-idle-resources'. Confirm when the execution link has been generated."

To view the complete inventory of available endpoints, input schemas, and resource definitions, visit the [DoiT integration page](https://truto.one/integrations/detail/doit).

## Workflows in Action

By chaining these tools together, Claude can execute multi-step FinOps and DevOps investigations that would typically require an engineer to manually cross-reference multiple DoiT dashboards.

### Workflow 1: Cost Anomaly Triage and Escalation

In this scenario, an AI agent is tasked with monitoring the infrastructure for unexpected spending spikes, investigating the root cause, and logging a support ticket if human intervention is required.

> "Review DoiT for any new critical cost anomalies. If you find any anomaly costing more than $500, ask Ava for the best practice on mitigating that specific issue, and then draft a DoiT support ticket with the details."

1. **`list_all_doi_t_anomalies`**: Claude fetches the recent list of anomalies, parsing the JSON response to filter for `severityLevel: "Critical"` and `costOfAnomaly > 500`.
2. **`create_a_doi_t_ava_ask_sync`**: Claude sends the specific details of the anomaly (e.g., a massive spike in BigQuery slot usage) to Ava, retrieving DoiT's recommended mitigation steps.
3. **`create_a_doi_t_support_ticket`**: Claude executes a write operation, creating a new support ticket in DoiT detailing the anomaly, the affected billing account, and the preliminary investigation details.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as MCP Server (Truto)
    participant DoiT as DoiT API

    User->>Claude: "Investigate critical cost anomalies..."
    Claude->>MCP: Call list_all_doi_t_anomalies
    MCP->>DoiT: GET /anomalies
    DoiT-->>MCP: [Anomaly Data]
    MCP-->>Claude: JSON response
    Claude->>MCP: Call create_a_doi_t_ava_ask_sync
    MCP->>DoiT: POST /ava/ask
    DoiT-->>MCP: [Ava Mitigation Advice]
    MCP-->>Claude: JSON response
    Claude->>MCP: Call create_a_doi_t_support_ticket
    MCP->>DoiT: POST /support/tickets
    DoiT-->>MCP: 201 Created
    MCP-->>Claude: Ticket ID
    Claude-->>User: "Ticket #1042 created with anomaly details."
```

### Workflow 2: Infrastructure Diagram Auditing

A DevOps engineer needs to map a specific cloud resource ID back to its visual topology and cross-reference it against active Cloud Analytics allocations.

> "Search our DoiT cloud diagrams for the resource ID 'vol-0a1b2c3d'. If found, get the associated diagram components, and then list all current analytics allocations to see who owns that environment."

1. **`create_a_doi_t_scheme_search`**: Claude submits a JSON payload to query the specific EBS volume ID across all DoiT diagrams.
2. **`create_a_doi_t_scheme_get`**: Claude uses the diagram ID returned in the previous step to pull the full layer data, identifying the parent EC2 instance and VPC.
3. **`list_all_doi_t_analytics_allocations`**: Claude fetches the organization's cloud allocations, matching the identified environment to a specific owner or engineering team.

```mermaid
flowchart TD
    A["User Prompt:<br>Find resource 'vol-0a1b2c3d'"] --> B["Claude executes<br>create_a_doi_t_scheme_search"]
    B --> C["MCP translates to<br>DoiT Scheme API"]
    C --> D["Claude parses<br>diagram layer ID"]
    D --> E["Claude executes<br>list_all_doi_t_analytics_allocations"]
    E --> F["Claude cross-references<br>owner data and reports"]
```

## Security and Access Control

Giving an LLM access to FinOps and infrastructure data requires strict security boundaries. Truto provides four mechanisms to lock down your DoiT MCP servers at the token level:

*   **Method Filtering (`config.methods`)**: Restrict the MCP server to specific operations. Setting this to `["read"]` ensures the LLM can query analytics and diagrams, but cannot create tickets, alter budgets, or trigger CloudFlows.
*   **Tag Filtering (`config.tags`)**: Scope the available tools to specific functional domains. You can limit a server to only expose tools tagged for `analytics`, keeping support and IAM tools hidden from the model.
*   **Secondary Authentication (`require_api_token_auth`)**: When enabled, possessing the MCP URL is not enough. The client must also pass a valid Truto API token in the `Authorization` header, ensuring only authenticated team members can execute tool calls.
*   **Time-to-Live (`expires_at`)**: Ideal for temporary audits or third-party contractors. You can set an ISO timestamp, after which Truto automatically destroys the token and underlying key-value records, instantly revoking the LLM's access to DoiT.

## Wrapping Up

Building a custom integration to map DoiT's massive API surface into MCP tools is a massive distraction for your engineering team. By utilizing Truto, you bypass the boilerplate of OAuth flows, complex FinOps schema mapping, and pagination normalization. You get a secure, dynamic MCP server that translates Claude's natural language into exact DoiT API executions.

Whether you are building internal AI agents to automate cost anomaly triage, or embedding FinOps intelligence directly into your product, managed MCP servers provide the fastest path to production.

> Stop writing boilerplate integration code. Use Truto to generate secure, enterprise-ready MCP servers for DoiT and 200+ other SaaS platforms in minutes.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)