Connect DevRev to Claude: Sync Knowledge Articles and User Groups

If you need to connect DevRev to Claude to automate support tickets, track development issues, or sync knowledge base articles, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and DevRev'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 DevRev to ChatGPT or explore our broader architectural overview on connecting DevRev to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex DevCRM like DevRev is an engineering challenge. You have to handle OAuth token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with DevRev's specific object graph. Every time DevRev 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 DevRev, connect it natively to Claude, and execute complex workflows using natural language.

The Engineering Reality of the DevRev 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 over JSON-RPC 2.0, the reality of implementing it against DevRev's APIs is painful. You are not just integrating a standard ticketing system (like connecting Jira to Claude) - you are integrating a platform that aggressively links product development (Parts) with customer support (Works and Accounts).

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

The Relational Object Graph In DevRev, almost nothing exists in isolation. To create a simple support ticket (a "Work" item), you cannot just pass a title and description. You must know the ID of the "Part" (the product component) it applies to, and the ID of the "Account" (the customer). If an LLM tries to create an issue without these internal identifiers, the API will reject the payload. Your MCP tools must be meticulously designed to allow the model to search for Parts and Accounts first, extract the IDs, and chain them into the subsequent creation request.

Unified but Strictly Typed "Works" DevRev unifies issues, tickets, and tasks under a single works endpoint. However, the schema validation for a ticket differs significantly from an issue. If you expose a generic "Create Work" tool to Claude without strict JSON Schema definitions enforcing the type parameter and conditional required fields, the LLM will constantly hallucinate payloads that fail server-side validation.

Fragmented Timeline Entries Adding a comment or an internal note to a ticket is not a simple string update on the Work object. It requires creating a distinct timeline_entry object, specifying the type as timeline_comment, and linking it to the parent object's ID. Teaching an LLM this abstraction requires highly specific tool descriptions.

Handling Rate Limits and 429s DevRev enforces rate limits to protect its infrastructure. A common mistake when building custom MCP servers is failing to handle these limits appropriately. It is important to note how Truto manages this: Truto normalizes upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. When DevRev returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto does not retry, throttle, or apply backoff on rate limit errors - the caller (your AI agent framework) is responsible for implementing retry and backoff logic. This ensures your agent is always aware of the true state of the integration.

How to Generate a DevRev MCP Server with Truto

Truto dynamically generates MCP tools based on the active API documentation and resource schemas defined for the DevRev integration. There is no hand-coding required. When a customer connects their DevRev workspace, Truto can instantiate a fully authenticated MCP server scoped entirely to that specific tenant.

You can create this server in two ways.

Method 1: Via the Truto UI

For internal workflows or testing, the Truto dashboard provides a one-click deployment.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected DevRev account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., name, read-only permissions, or specific tags).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the API

For production usage where you need to programmatically provision MCP servers for your end-users, you can call the Truto API. This validates that the integration has tools available, generates a secure token stored in edge infrastructure, and returns a ready-to-use URL.

Make a POST request to /integrated-account/:id/mcp:

const response = await fetch('https://api.truto.one/integrated-account/<DEVREV_ACCOUNT_ID>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_TRUTO_API_TOKEN>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "DevRev Customer Support Agent",
    config: {
      methods: ["read", "write"] // Restrict the LLM to specific operation types if needed
    }
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); // Pass this URL to your Claude client

Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude is incredibly straightforward. Because Truto bakes the authentication directly into the cryptographic token in the URL, there are no additional headers or OAuth handshakes required by the client.

Method A: Via the Claude UI

If you are using Claude Desktop:

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

Claude will immediately ping the server's /initialize endpoint, perform the JSON-RPC handshake, and populate its context window with the available DevRev tools.

Method B: Via Manual Config File

For developers managing their environments via configuration files or integrating with custom MCP clients, you can update your claude_desktop_config.json. Truto provides an SSE (Server-Sent Events) transport layer over HTTP.

Add the following to your configuration:

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

Restart Claude Desktop, and the tools will be instantly available.

DevRev Hero Tools for Claude

Truto exposes the entirety of the DevRev API via MCP, but certain endpoints are particularly critical for AI agents. Truto automatically formats the JSON Schemas for these endpoints, injecting instructions that teach the LLM how to use cursor-based pagination and how to format payloads correctly.

Here are the most powerful tools available to Claude:

list_all_dev_rev_works

Retrieves a list of work items (issues or tickets). The tool schema instructs the LLM on how to filter by type, applies_to_part, or owned_by. This is the primary tool for triage and issue discovery.

"Claude, pull the 10 most recent DevRev tickets that are currently in the 'triage' stage. Filter the list to only show tickets related to the 'API Gateway' part, and summarize the reported problems."

create_a_dev_rev_work

Allows the LLM to create new issues or tickets. Truto's dynamically generated schema enforces the required fields (type, applies_to_part, owned_by, and title), preventing the LLM from making malformed requests.

"Based on the customer complaint about the login timeout, create a new high-priority issue in DevRev. Title it 'Auth Service Timeout Spike' and assign it to the backend services part."

list_all_dev_rev_articles

Fetches knowledge base articles from DevRev. This turns Claude into a highly effective support agent, allowing it to retrieve official documentation to draft customer responses before escalating a ticket.

"Search our DevRev articles for 'SAML configuration SSO' and use the extracted content to draft a reply to the customer explaining how to rotate their identity provider certificates."

list_all_dev_rev_parts

Lists the product components (Parts) defined in your DevRev instance. Because almost all work items in DevRev must be linked to a Part, the LLM will frequently call this tool first to resolve a natural language component name into a DevRev Part ID.

"Before you create that bug ticket, list the DevRev parts and find the exact ID for the component named 'Billing Dashboard'."

list_all_dev_rev_accounts

Retrieves customer account data. This provides the LLM with vital CRM context, including domain names, tier levels, and external references, which is essential when deciding how to prioritize a newly reported issue.

"Look up the DevRev account for 'Acme Corp'. Check what tier they are on and who the designated owner is, so we can route their ticket appropriately."

list_all_dev_rev_timeline_entries

Fetches the chronological timeline for any object (like a ticket). This includes comments, state changes, and automated system logs. It gives Claude the full context of a conversation.

"Get the timeline entries for ticket ID 'TKT-492'. Read the back-and-forth between the support agent and the customer, and summarize the steps we have already asked them to try."

create_a_dev_rev_timeline_entry

Allows Claude to append a comment or note to a work item's timeline. The schema enforces type: 'timeline_comment' and requires the parent object ID, ensuring the LLM correctly links its response.

"Add a timeline entry to issue 'ISS-991' with an internal note that says: 'Claude automated triage: Logs indicate a database deadlock. Escalating to the DBA team.'"

This is just a subset of the capabilities. To see the complete inventory of available DevRev endpoints, schemas, and required parameters, view the Truto DevRev integration page.

Workflows in Action

When you connect DevRev to Claude via Truto, you move beyond simple Q&A. You can execute multi-step, stateful workflows that combine CRM context, product taxonomy, and ticket management. Here are two real-world examples.

Workflow 1: Support Triage and Automated KB Replies

Imagine a scenario where a tier-1 support inbox is overflowing. You want Claude to read new tickets, look up the customer tier, search the knowledge base, and draft a response directly on the ticket timeline.

"Claude, fetch the 5 most recent DevRev tickets. For each one, check the Account tier. If they are an Enterprise customer, search our DevRev articles for a solution to their problem. If you find a match, create a timeline entry on the ticket with a polite draft response referencing the article."

How Claude executes this:

1. Calls list_all_dev_rev_works sorting by creation date to get the 5 latest tickets.
2. Iterates through the tickets, calling list_all_dev_rev_accounts or get_single_dev_rev_account_by_id to verify the tier.
3. If Enterprise, calls list_all_dev_rev_articles filtering by keywords derived from the ticket's body.
4. Reads the extracted_content from the matching article.
5. Calls create_a_dev_rev_timeline_entry on the ticket, injecting the drafted response as a timeline_comment.

Claude handles the data mapping and orchestration entirely autonomously, relying on the schemas provided by the Truto MCP server.

Workflow 2: Part-Specific Bug Escalation

A customer reports a reproducible crash in a specific feature. Claude needs to translate this complaint into a properly formatted engineering issue attached to the correct product component.

"A user reported that the 'Data Export CSV' feature crashes when exporting more than 10,000 rows. Find the correct Part for this feature in DevRev, then create a high-priority Dev issue linked to that Part, and include the reproduction steps in the body."

How Claude executes this:

1. Calls list_all_dev_rev_parts to search for components matching "Data Export" or "CSV".
2. Identifies the specific Part ID (e.g., PRT-843).
3. Calls create_a_dev_rev_work with type: "issue", priority: "p1", and applies_to_part: ["PRT-843"], structuring the body with clear reproduction steps.
4. Returns a summary to the user confirming the exact issue ID that was generated.

Security and Access Control

Exposing a sprawling CRM and ticketing system to an autonomous agent requires strict security boundaries. Truto provides several mechanisms to lock down your DevRev MCP server at the time of creation:

• Method Filtering (methods): You can restrict an MCP server to only allow read operations. If an agent goes rogue or receives a malicious prompt injection, it physically cannot invoke create, update, or delete tools. The API simply won't expose them.
• Tag Filtering (tags): Truto allows you to scope access to specific resource groupings. You can generate an MCP server that only has access to the support tag (works, timeline entries) but completely hide the admin tag (user groups, system webhooks).
• Dual-Layer Auth (require_api_token_auth): By default, possessing the MCP URL grants access. By setting require_api_token_auth: true, the caller must also pass a valid Truto API token in the Authorization header. This ensures that even if the URL leaks in a log file, unauthorized users cannot execute tools.
• Ephemeral Servers (expires_at): You can set an exact ISO datetime for the server to self-destruct. This is ideal for CI/CD pipelines or temporary contractor access, ensuring no stale integration connections remain active.

Moving Fast Without Breaking APIs

Connecting DevRev to Claude fundamentally changes how your teams interact with product and customer data. Instead of forcing engineers and support agents to navigate complex UIs to link accounts, parts, and issues, they can simply ask Claude to orchestrate the backend operations.

Building this MCP infrastructure in-house requires constant maintenance, schema updates, and robust pagination logic. Truto handles this entirely, giving you a dynamic, self-healing translation layer between Anthropic's models and DevRev's REST API. You get all the power of agentic workflows with none of the integration debt.