---
title: "Connect Thena to Claude: Resolve Tickets and Track Support Quality"
slug: connect-thena-to-claude-resolve-tickets-and-track-support-quality
date: 2026-08-04
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect Thena to Claude using Truto's managed MCP server. Execute complex ticket triage, resolve support requests, and automate quality audits."
tldr: "Connect Thena to Claude Desktop seamlessly using Truto's managed MCP server. This guide shows how to generate tools, configure access, and execute AI support workflows."
canonical: https://truto.one/blog/connect-thena-to-claude-resolve-tickets-and-track-support-quality/
---

# Connect Thena to Claude: Resolve Tickets and Track Support Quality


If you need to connect Thena to Claude to automate ticket resolution, analyze customer sentiment, or track support quality, 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 Thena's REST API. 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 Thena to ChatGPT](https://truto.one/connect-thena-to-chatgpt-manage-accounts-and-internal-workflows/) or explore our broader architectural overview on [connecting Thena to AI Agents](https://truto.one/connect-thena-to-ai-agents-sync-tasks-and-automate-customer-data/).

Giving a Large Language Model (LLM) read and write access to a [conversational support platform like Thena](https://truto.one/connect-thena-to-chatgpt-manage-accounts-and-internal-workflows/) is an engineering challenge. You have to handle API token lifecycles, map complex Slack-native nested thread schemas to MCP tool definitions, and deal with strict pagination limits. Every time Thena 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 Thena, connect it natively to Claude, and execute complex support workflows using natural language.

## The Engineering Reality of the Thena API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into HTTP requests. 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, the reality of implementing it against vendor APIs requires constant maintenance. You are not just integrating a generic database - you are integrating Thena's specific data model, which bridges conversational chat platforms (Slack/Teams) with traditional ticketing (similar to [Zendesk](https://truto.one/connect-zendesk-to-claude-manage-help-center-content-knowledge/)).

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

**Slack-Native Identity Mapping**
Thena is deeply integrated with Slack and Microsoft Teams. As a result, its data model heavily references conversational origins. When querying tickets, you will encounter multiple identity paradigms: `id` (the internal database ID), `ticketId` (the human-readable sequential ID), and `ticketIdentifier` (the Slack thread timestamp or external ID). Exposing these raw, overlapping identifiers to Claude often causes the model to hallucinate which ID to use when making subsequent update calls. A managed MCP server explicitly maps these schemas, providing the LLM with clear descriptions of which identifier is required for specific operations.

**Threaded Comment Pagination**
Customer support conversations are rarely flat. Thena structures ticket replies as nested threads. If you want Claude to summarize a ticket, the LLM needs access to the entire conversation history. Thena's comment endpoints require careful traversal of pagination cursors. If you expose raw pagination parameters to Claude, the model will frequently attempt to guess the next cursor or fail to paginate entirely. Truto normalizes pagination across all endpoints into a standard `limit` and `next_cursor` schema, explicitly instructing the LLM to pass cursor values back unchanged.

**Handling Rate Limits and 429 Errors**
Thena enforces strict rate limits to ensure platform stability. If an AI agent attempts to run a federated search across thousands of historical tickets, it will hit an HTTP 429 Too Many Requests error. **It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors.** When Thena returns a 429, Truto passes that error directly to the caller. However, Truto does normalize upstream rate limit information into standardized HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The LLM framework or the calling agent is strictly responsible for interpreting these headers and executing exponential backoff.

Instead of building this infrastructure from scratch, you can use Truto to generate a production-ready MCP server that normalizes these quirks out of the box.

## How to Generate a Thena MCP Server with Truto

Truto dynamically generates MCP tools from an integration's existing resource definitions and documentation. This means the tools are always up-to-date with the underlying API. You can create a Thena MCP server using either the Truto UI or the REST API.

### Method 1: Via the Truto UI

This is the fastest method for internal testing or administrative setup.

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Thena account.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., allow read and write methods, filter by specific tags like "tickets" or "accounts").
6. Click Save and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For production use cases - such as generating temporary MCP servers for automated workflows or deploying multi-tenant AI agents - you should provision the server programmatically. 

Make a POST request to `/integrated-account/:id/mcp` using your Truto API key:

```bash
curl -X POST "https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp" \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Thena Support Triage MCP",
    "config": {
      "methods": ["read", "write"],
      "tags": ["tickets", "comments", "accounts"]
    }
  }'
```

Truto validates that the integration has available tools, generates a secure cryptographic token, stores the hashed representation in edge KV storage for low-latency routing, and returns the server details:

```json
{
  "id": "mcp_8f7d6e5c",
  "name": "Thena Support Triage MCP",
  "config": {
    "methods": ["read", "write"],
    "tags": ["tickets", "comments", "accounts"],
    "require_api_token_auth": false
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

The `url` provided in the response is a fully self-contained JSON-RPC 2.0 endpoint. It handles authentication, schema validation, and tool execution.

## How to Connect the MCP Server to Claude

Once you have your Thena MCP server URL, you need to register it with your Claude client. You can do this through the Claude application UI or by modifying the underlying configuration file.

### Method A: Via the Claude UI

If you are using the Claude desktop app or web interface with custom connector support:

1. Open Claude and navigate to **Settings**.
2. Select **Integrations** or **Connectors** (depending on your plan tier).
3. Click **Add MCP Server** or **Add custom connector**.
4. Name your connection (e.g., "Thena Support").
5. Paste the Truto MCP URL into the Server URL field.
6. Click **Add**.

Claude will immediately ping the endpoint, execute the `initialize` handshake, and request the `tools/list`. The tools will now be available in your chat interface.

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

For developers running Claude Desktop locally, you can directly edit the MCP configuration file. This is useful for version-controlling your local development environments.

1. Open your Claude Desktop configuration file:
   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
2. Add your Truto MCP URL using the SSE (Server-Sent Events) transport command structure. Because Truto MCP servers operate over standard HTTP POST requests, you use the `@modelcontextprotocol/server-sse` proxy package to bridge the connection.

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

Save the file and restart Claude Desktop. The application will read the configuration and securely bind the Thena tools to your local instance.

## Thena Hero Tools for Claude

When the MCP server initializes, Truto dynamically builds tool definitions from the Thena integration's documentation records. The server provides dozens of tools covering custom fields, emojis, CSAT rules, and routing configurations. 

Here are 7 high-leverage hero tools your AI agents can use to resolve tickets and track quality.

### list_all_thena_tickets

This tool retrieves a paginated list of Thena tickets. It is the foundational read operation for triage agents, allowing Claude to filter tickets by team ID, date ranges, and status arrays.

**Contextual Usage:** Claude uses this tool to scan the queue for open tickets or find historical context on a specific issue. The schema requires the agent to handle `limit` and `next_cursor` strictly if traversing large queues.

> "Claude, check Thena for any unresolved tickets assigned to the 'Enterprise Support' team created in the last 24 hours. Summarize the descriptions of the three oldest open tickets."

### get_single_thena_ticket_by_id

This tool fetches the complete payload for a specific ticket, including its `ticketIdentifier`, status, priority, assigned agent, and team metadata.

**Contextual Usage:** When an agent needs deep context on a single issue, this tool provides the full object. It is often chained with comment retrieval to build a complete context window before drafting a reply.

> "Fetch the full details for Thena ticket ID 'TKT-8492'. I need to know the current status, the assigned agent's email, and the priority level."

### update_a_thena_ticket_by_id

This write tool allows the LLM to mutate ticket state. It accepts partial payloads to update the ticket's title, description, status, priority, team assignment, or agent assignment.

**Contextual Usage:** After analyzing a customer request, Claude uses this tool to escalate priorities, reassign the ticket to a specialized sub-team, or mark the issue as resolved.

> "Update ticket 'TKT-8492'. Change its priority to 'High' and assign it to the 'Security Escalations' team based on the customer's mention of a data breach."

### thena_tickets_comment

This tool posts a new comment or reply to an existing ticket. Thena supports markdown formatting and internal vs. external visibility flags.

**Contextual Usage:** This is the primary mechanism for AI-generated customer responses. Agents can draft technical explanations, format them properly, and inject them directly into the Thena/Slack thread.

> "Draft a polite response to the customer on ticket 'TKT-8492' explaining that our engineering team has identified the SSO bug and will deploy a hotfix in two hours. Post it as a public comment."

### get_single_thena_account_by_id

This tool retrieves account-level intelligence, returning data on the customer's domain, health score, tier classification, industry, and assigned account owner.

**Contextual Usage:** Before replying to a ticket, an agent should always check account context. A "churn risk" account requires a different tone and SLA than a healthy, free-tier account.

> "Get the account details for account ID 'ACC-1102'. Tell me their current health score and who the primary Account Executive is."

### thena_csat_get_settings

This tool fetches the Customer Satisfaction (CSAT) survey rules and configurations for a specific team, including cooldown periods and trigger conditions.

**Contextual Usage:** Quality assurance agents use this tool to verify that feedback loops are properly configured after tickets are closed, ensuring teams aren't over-surveying customers.

> "Retrieve the CSAT settings for the 'Tier 1 Support' team. What is the current cooldown period in days before a user can receive another survey?"

### thena_search_federated_search

This powerful tool executes cross-collection searches across tickets, comments, accounts, and help center articles in a single POST request.

**Contextual Usage:** This is ideal for RAG (Retrieval-Augmented Generation) workflows. Claude can query historical tickets and knowledge base articles simultaneously to find precedent for a complex technical issue.

> "Run a federated search across all tickets and comments for the error string 'ERR_OAUTH_TIMEOUT'. Summarize how our team resolved this issue in the past."

To view the complete inventory of available tools, query schemas, and response types, visit the [Thena integration page](https://truto.one/integrations/detail/thena).

## Workflows in Action

When connected to a capable model like Claude 3.5 Sonnet, the Thena MCP server enables complex, multi-step reasoning. Here are two real-world workflows demonstrating how Claude orchestrates these tools.

### Workflow 1: VIP Triage and Escalation

Support teams struggle to identify high-value customers buried in massive ticket queues. An AI agent can automatically triage inbound tickets based on account health and priority.

> "Analyze the 5 most recent open tickets. For each ticket, check the associated account. If the account health is 'At Risk' or the classification is 'Enterprise', immediately escalate the ticket priority to High and reassign it to the Escalation Team."

**Step-by-Step Execution:**
1. Claude calls `list_all_thena_tickets` with a status filter for open tickets and a limit of 5.
2. For each ticket returned, Claude extracts the `accountId`.
3. Claude iterates through the IDs, calling `get_single_thena_account_by_id` for each to inspect the `health` and `classification` fields.
4. Identifying one ticket from an "At Risk" account, Claude calls `update_a_thena_ticket_by_id` on that specific ticket, passing `{"priority": "High", "teamId": "TEAM_ESCALATION_ID"}` in the body schema.

**Outcome:** The LLM successfully filters noise, cross-references CRM data, and executes an operational state change without human intervention.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant Thena as Thena API

    User->>Claude: "Triage recent tickets..."
    Claude->>Truto: tools/call (list_all_thena_tickets)
    Truto->>Thena: GET /v1/tickets?status=open&limit=5
    Thena-->>Truto: Returns ticket array
    Truto-->>Claude: JSON response
    
    loop For each ticket
        Claude->>Truto: tools/call (get_single_thena_account_by_id)
        Truto->>Thena: GET /v1/accounts/{id}
        Thena-->>Truto: Returns account health
        Truto-->>Claude: JSON response
    end
    
    Claude->>Truto: tools/call (update_a_thena_ticket_by_id)
    Truto->>Thena: PATCH /v1/tickets/{id}
    Thena-->>Truto: 200 OK
    Truto-->>Claude: Success confirmation
    Claude-->>User: "Triage complete. Escalated 1 VIP ticket."
```

### Workflow 2: Automated Quality Assurance Audits

Support managers need to track response quality across thousands of threads. Instead of manual spot-checks, an agent can audit historical interactions for tone, accuracy, and process adherence.

> "Find all tickets closed yesterday by agent ID 'USR-559'. Read the full comment threads on those tickets. Evaluate the agent's responses for empathy and technical accuracy. Generate a markdown report summarizing your findings."

**Step-by-Step Execution:**
1. Claude calls `list_all_thena_tickets` filtering by the specific agent ID and a date range mapping to yesterday.
2. For each closed ticket, Claude calls `thena_tickets_list_comments` to pull the complete conversational history.
3. The model ingests the comment arrays into context, evaluating the text against its internal system prompts for empathy and accuracy.
4. Claude processes the data locally and generates a markdown report in the chat interface.

**Outcome:** The manager receives an instant, objective QA audit covering 100% of the agent's daily output, powered entirely by MCP data retrieval.

## Security and Access Control

Exposing an enterprise support platform to an autonomous AI requires strict access controls. Truto MCP servers provide multiple layers of security to prevent unauthorized operations or prompt-injection attacks:

*   **Method Filtering:** When creating the server via `/integrated-account/:id/mcp`, you can pass `"methods": ["read"]` to generate a read-only server. This completely removes write tools (like `update_a_thena_ticket_by_id` or `delete_a_thena_account_by_id`) from the Claude interface, preventing accidental data deletion.
*   **Tag Filtering:** You can restrict the server to specific resource tags. Passing `"tags": ["tickets"]` ensures the LLM can only view ticket data, blocking it from accessing sensitive user directories or organizational metadata.
*   **API Token Authentication:** By setting `"require_api_token_auth": true`, possession of the MCP URL is no longer sufficient. The Claude client must also pass a valid Truto API token via an `Authorization: Bearer` header, enforcing identity verification at the tool-call layer.
*   **Automatic Expiration:** You can set an `expires_at` ISO datetime when generating the server. Once the TTL is reached, Truto automatically deletes the server configuration and purges the token from KV edge storage, making it ideal for temporary contractor access or ephemeral CI/CD agents.

## Rethinking Support Operations with AI

Connecting Thena to Claude via a managed MCP server eliminates the boilerplate of REST API integration. You don't have to parse Slack thread IDs, manage recursive pagination loops, or write custom retry middleware when Thena's rate limits kick in. 

By normalizing Thena's endpoints into well-documented JSON-RPC tools, Truto allows your engineering team to focus on agent orchestration and prompt engineering rather than maintaining fragile API connectors.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} 
Want to generate production-ready MCP servers for Thena and 150+ other SaaS applications? Partner with Truto to scale your AI agent integrations today.
:::