Connect Unthread to Claude: Manage Support Knowledge and Metrics

If you need to connect Unthread to Claude to automate Slack-based support triaging, manage customer knowledge bases, or analyze helpdesk metrics, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Unthread'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 Unthread to ChatGPT or explore our broader architectural overview on connecting Unthread to AI Agents.

Giving a Large Language Model (LLM) read and write access to a conversational support platform like Unthread is an engineering challenge. Unthread heavily relies on Slack-native data structures, asynchronous messaging events, and complex tagging systems. Every time Unthread updates an endpoint or deprecates a field, you have to update your custom server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Unthread, connect it natively to Claude Desktop, and execute complex support workflows using natural language.

The Engineering Reality of the Unthread 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 Unthread's APIs is painful. You are not just integrating a standard CRUD database - you are integrating a highly conversational, stateful ticketing system.

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

Slack-Native Threading and Formatting Unthread conversations are inherently tied to Slack threads. When creating a message, the API expects specific contextual data, and the content can be formatted using Slack blocks or raw markdown. An LLM has no context on how to construct a Slack block array from scratch. If you expose the raw API, Claude will struggle with syntax errors. A managed MCP server abstraction maps query and body parameters correctly, allowing Claude to send standard markdown that translates safely into the expected payload.

Mutable State and Cascading Entity Updates Support tickets in Unthread are not isolated. A conversation belongs to a customer, who belongs to a Slack channel, and can have multiple collaborators and tags. Assigning a tag to a conversation or linking an external task (like a Linear issue) requires mapping internal Unthread IDs correctly. Passing raw endpoints directly to Claude often results in hallucinated UUIDs. Truto's dynamically generated tools explicitly define schemas that force the LLM to retrieve the correct IDs before executing state changes.

Transparent Rate Limit Handling Unthread, like all B2B SaaS platforms, enforces rate limits on high-volume endpoints (especially search and time-series reporting). It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When the Unthread API returns an HTTP 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your MCP client or agent framework is responsible for handling the retry and backoff logic using these normalized headers.

How to Generate an Unthread MCP Server

Truto dynamically generates MCP tools based on the active resources and documentation records defined in your Unthread integration. Tools are not hardcoded; if an endpoint has a documentation record defining its description, query schema, and body schema, Truto automatically exposes it as a JSON-RPC 2.0 tool.

You can generate an MCP server for Unthread in two ways: via the Truto UI or programmatically via the API.

Method 1: Generating via the Truto UI

For ad-hoc agent usage or internal IT administration, the easiest way to spin up an MCP server is through the dashboard.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Unthread account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags like support).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Generating via the Truto API

For production workflows where you are provisioning agents on behalf of your users, you should generate the MCP server programmatically. This endpoint verifies that the integration is AI-ready, generates a cryptographically hashed token stored in Cloudflare KV, and returns the server URL.

Request:

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": "Unthread Support Triage Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "require_api_token_auth": false
    },
    "expires_at": "2025-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp_srv_98765",
  "name": "Unthread Support Triage Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "require_api_token_auth": false
  },
  "expires_at": "2025-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

This URL is fully self-contained. The cryptographic token in the path dictates exactly which Unthread account is being queried and enforces the method filters at the execution layer.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it into any compatible client. Here is how to configure it for Claude.

Method A: Via the Claude UI (Desktop/Web)

If you are using Claude Desktop or Claude for Enterprise, you can add the server directly via the interface:

1. Open Claude and navigate to Settings.
2. Select Integrations (or Connectors depending on your tier).
3. Click Add MCP Server.
4. Give it a name (e.g., "Unthread Support Data").
5. Paste your Truto MCP URL into the endpoint field.
6. Click Add.

Claude will immediately perform a protocol handshake, requesting tools/list to discover all available Unthread operations.

Method B: Via Manual Configuration File (SSE Transport)

If you are running Claude Desktop locally and prefer file-based configuration, or if you are orchestrating custom AI agents using LangChain or LangGraph, you can configure the MCP server using Server-Sent Events (SSE).

Edit your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

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

Restart Claude Desktop. The model now has real-time read and write access to your Unthread workspace based on the permissions granted by the MCP token.

High-Leverage Unthread Tools for Claude

Truto automatically generates descriptive snake_case tool names and flat JSON schemas based on Unthread's documentation records. Here are some of the most powerful hero tools you can use.

unthread_knowledge_base_query

Searches the Unthread knowledge base for articles matching a specific search string. This is critical for agents doing frontline triage, allowing them to pull internal runbooks or customer-facing FAQs before attempting to draft a response.

"A customer is asking how to reset their 2FA token. Query the Unthread knowledge base for '2FA reset' and summarize the steps."

list_all_unthread_conversations

Fetches a paginated list of conversations. Truto normalizes the query schema to include standard limit and next_cursor parameters. You can instruct Claude to filter this list by status (e.g., open tickets) to analyze queue volume.

"List all currently open Unthread conversations. Give me the titles and the customer IDs for the five oldest unresolved tickets."

create_a_unthread_conversation_message

Posts a new message into an existing Unthread conversation (which syncs directly to the underlying Slack thread). The LLM can draft and send replies, using either raw text or markdown.

"Draft a polite response to conversation ID 'conv_xyz987' apologizing for the downtime and explaining that our engineers are investigating. Send the message."

unthread_conversations_create_external_task

Creates an external task (such as a Jira issue or Linear ticket) and links it directly to the Unthread conversation. This bridges the gap between customer support and engineering.

"Create an external Linear task for conversation ID 'conv_abc123' titled 'API Rate Limit Bug'. Include the initial message text in the description."

unthread_tags_link_conversations

Assigns a specific tag to an array of conversation IDs. This is highly useful for bulk-updating tickets after an incident or categorizing feedback for product teams.

"Link the tag ID 'tag_incident_404' to the three conversations we just identified as being related to the login outage."

unthread_reporting_time_series

Retrieves time-series conversation metrics grouped by date and optional dimensions. This allows Claude to act as a data analyst, pulling resolution times, response times, and SLA breaches.

"Pull the time-series reporting metrics for our average response time over the last 7 days. Summarize the daily trend and identify the slowest day."

For a complete list of all available operations, schemas, and required parameters, review the Unthread integration page.

Workflows in Action

Giving Claude individual tools is helpful, but the real power of MCP emerges when models chain these tools together to execute multi-step workflows. Because Truto flattens the query and body schemas into a single namespace during the tools/call JSON-RPC request, the LLM can easily pass arguments from one tool directly into the next.

Scenario 1: Auto-Triage and Escalate to Engineering

An IT admin wants Claude to monitor the support queue, answer basic questions using the knowledge base, and escalate bugs to engineering.

"Check our open Unthread conversations. For any ticket asking about 'SSO configuration', query the knowledge base and reply to the thread with the instructions. If the ticket mentions the word 'bug' or 'error', create an external task for it and tag the conversation with the 'Escalated' tag."

How Claude executes this:

1. Calls list_all_unthread_conversations filtering for open statuses.
2. Analyzes the initialMessage text of each conversation.
3. For SSO questions, calls unthread_knowledge_base_query with the query string "SSO configuration".
4. Calls create_a_unthread_conversation_message to post the retrieved instructions.
5. For bug reports, calls unthread_conversations_create_external_task passing the conversation ID and a generated title.
6. Calls unthread_tags_link_conversations to apply the escalation tag ID.

sequenceDiagram
    participant User as User / Agent
    participant Claude as Claude (MCP Client)
    participant Truto as Truto MCP Router
    participant Unthread as Unthread API

    User->>Claude: "Check open tickets, reply to SSO questions, escalate bugs."
    Claude->>Truto: call list_all_unthread_conversations
    Truto->>Unthread: GET /conversations?status=open
    Unthread-->>Truto: Return array of conversations
    Truto-->>Claude: JSON response
    Claude->>Truto: call unthread_knowledge_base_query (query: "SSO")
    Truto->>Unthread: GET /knowledge_base?query=SSO
    Unthread-->>Truto: Return article content
    Truto-->>Claude: JSON response
    Claude->>Truto: call create_a_unthread_conversation_message (conv_id, text)
    Truto->>Unthread: POST /conversations/{id}/messages
    Unthread-->>Truto: 201 Created
    Truto-->>Claude: Success
    Claude->>Truto: call unthread_conversations_create_external_task
    Truto->>Unthread: POST /conversations/{id}/external_tasks
    Unthread-->>Truto: 201 Created
    Truto-->>Claude: Success

Scenario 2: Support Ops - SLA Metric Analysis

A Customer Success manager needs a quick diagnostic on team performance without logging into a BI dashboard.

"Pull our time-series metrics for resolution times over the past month. Compare that against the volume of total incoming conversations. Tell me if there is a correlation between high volume days and SLA breaches."

How Claude executes this:

1. Calls unthread_reporting_time_series with metric: "resolution_time", specifying the start and end dates.
2. Calls unthread_reporting_time_series again with metric: "volume" or parses the total counts from the initial lookup.
3. The LLM analyzes the JSON arrays returned by Truto, matches the dates, performs the correlation logic in its context window, and outputs a formatted markdown summary for the user.

Security and Access Control

Exposing an enterprise support desk to an AI agent carries inherent risk. You do not want a rogue prompt accidentally deleting customer records or modifying ticket schemas. Truto's MCP server architecture provides strict access controls enforced at the router level:

• Method Filtering: When generating the server via the API or UI, you can pass config.methods: ["read"]. The MCP router will completely strip out all create, update, and delete tools during the tools/list handshake. Claude will not even know those operations exist.
• Tag Filtering: You can restrict the MCP server to specific functional domains. Setting config.tags: ["reporting"] ensures the LLM only has access to analytics tools, preventing it from touching active conversations.
• Double Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, clients must also pass a valid Truto API token in the Authorization header, preventing lateral movement if the URL is leaked in logs.
• Auto-Expiration (expires_at): You can set a strict TTL on the MCP server. Cloudflare KV handles the immediate expiration, and a Durable Object alarm ensures the underlying credentials and configurations are hard-deleted from the database.

Moving Beyond Basic Chat Interfaces

Connecting Unthread to Claude transforms your support stack from a passive system of record into an active, agentic participant. Instead of forcing support engineers to manually query knowledge bases, write repetitive Slack replies, and copy-paste contexts into Jira, an LLM equipped with Truto's MCP tools can orchestrate the entire lifecycle.

By leveraging a managed MCP server, engineering teams avoid the massive overhead of maintaining custom tool definitions, handling OAuth lifecycles, and managing pagination logic for the Unthread API. You define the precise security boundaries, generate the server URL, and let the model handle the reasoning.