Connect Dixa to ChatGPT: Manage and Explore Custom Attribute Schemas

If your team uses Claude, check out our guide on connecting Dixa to Claude or explore connecting Dixa to AI Agents for broader autonomous workflows. In this guide, we will focus exclusively on connecting Dixa to ChatGPT to inspect and manage Custom Attribute schemas via the Model Context Protocol (MCP).

Customer service platforms like Dixa rely on highly structured metadata. To automate routing rules, ticket triaging, or CRM syncs, an LLM first needs to understand exactly how your specific Dixa instance is configured. By connecting Dixa to ChatGPT using Truto's SuperAI MCP Server, you give the LLM dynamic, read-only access to your custom attribute definitions, enabling it to write integration scripts, audit schemas, and analyze routing logic without hallucinating missing fields.

The Engineering Reality of the Dixa API

When exposing Dixa to LLMs, you must account for specific architectural quirks in how Dixa handles metadata and API limits.

• Complex inputDefinition Typing: In Dixa, a custom attribute is never just a plain string. The API returns an inputDefinition object that strictly defines the data type (e.g., boolean, dropdown, multi-select). If your agent needs to write an update payload for a conversation later, it must respect this exact schema. Failing to pass a predefined dropdown option will result in a 400 Bad Request.
• Entity Type Segmentation: Custom attributes are split by entityType (e.g., Conversation, User). Tools interacting with this API must filter down to the correct entity type to avoid cross-contamination in LLM context windows.
• Strict Rate Limiting with No Hand-Holding: Dixa enforces rate limits strictly. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Dixa API returns an HTTP 429, Truto passes that error directly back to the ChatGPT client. However, Truto does normalize the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) according to the IETF specification. Your client architecture is entirely responsible for detecting the 429 and applying retry logic.

Step 1: Create the Dixa MCP Server

Truto automatically generates MCP tools based on documentation and integration definitions. Because Truto handles the underlying API authentication, you only need to create a secure MCP server endpoint pointing to your connected Dixa instance.

You can create this server in two ways.

Approach A: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts section.
2. Select your connected Dixa account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Give it a descriptive name (e.g., "Dixa Schema Explorer").
6. Optional: Restrict the server to read methods only, ensuring ChatGPT cannot inadvertently modify configurations.
7. Click Save and copy the generated MCP URL (https://api.truto.one/mcp/...).

Approach B: Via the API

For platform engineers building automated provisioning pipelines, you can dynamically spin up an MCP server by making an authenticated POST request to the Truto API.

curl -X POST https://api.truto.one/integrated-account/{dixa_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Dixa Attribute Audit",
    "config": {
      "methods": ["read"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response will return an id and the required url for your MCP client.

Step 2: Connect the MCP Server to ChatGPT

With the URL in hand, configuring ChatGPT takes seconds.

Option A: ChatGPT UI Connector Flow

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle on Developer mode (MCP support requires this flag to be active).
3. Under the MCP servers section, click to add a new custom connector.
4. Name: Enter a recognizable label like "Dixa Custom Attributes".
5. Server URL: Paste the Truto MCP URL generated in Step 1.
6. Click Save. ChatGPT will immediately perform a protocol handshake and list the available Dixa tools.

Option B: Manual Config File Approach

If you are using Claude Desktop or an open-source agent UI that relies on standardized MCP JSON configuration, you can add the Truto endpoint like this:

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

Note: Browser-based clients or custom agents can also post JSON-RPC 2.0 payloads directly to the URL, as Truto includes the /mcp path in its CORS allowlist.

Dixa Custom Attribute Tool Inventory

Truto curates and transforms Dixa endpoints into LLM-friendly schemas. Here is how those tools are exposed to ChatGPT.

Hero Tools

These are the primary operations your LLM will use to inspect Dixa's schema structure.

1. List All Custom Attributes

Tool Name: list_all_dixa_custom_attributes

This tool retrieves the full directory of custom attributes defined in the Dixa account. It returns an array containing id, entityType, identifier, label, inputDefinition, description, createdAt, updatedAt, isRequired, isArchived, and isDeactivated fields.

Usage Note: The inputDefinition field is the most critical component returned here. LLMs should scan this to understand what predefined options exist for dropdowns or list variables.

Example Prompt:

"Use the Dixa tools to list all custom attributes. Filter the results and tell me which attributes are marked as isRequired for the Conversation entity type."

2. Get Single Custom Attribute by ID

Tool Name: get_single_dixa_custom_attribute_by_id

Retrieves the complete schema for a specific custom attribute using its unique identifier.

Usage Note: When dealing with complex schemas or building mapping code for an integration, ChatGPT should use this tool to fetch the exact, unpaginated detail of a specific field to avoid missing nested constraints.

Example Prompt:

"Fetch the custom attribute with ID 'attr_123456' and write a JSON schema definition that I can use in my application to validate payloads before sending them to Dixa."

For the complete tool inventory and full schema details, visit the Dixa integration page.

Workflows in Action

Once connected, ChatGPT shifts from a generic assistant to an active systems architect. Here are real-world examples of how you can use these tools.

Scenario 1: Auditing Support Ticket Requirements

A Customer Success Operations manager needs to know what fields agents are forced to fill out before closing a ticket.

"Audit our Dixa setup. List all custom attributes, isolate those where entityType is 'Conversation' and isRequired is true, and format them into a markdown table including the attribute label and description."

Step-by-step Execution:

1. ChatGPT calls list_all_dixa_custom_attributes.
2. It parses the JSON response, filtering objects where entityType === 'Conversation' and isRequired === true.
3. It maps the label and description fields and outputs a formatted markdown table to the user.

Result: The manager receives an immediate, accurate report of required fields without needing to click through the Dixa admin UI.

Scenario 2: Preparing a CRM Sync Script

An Integration Engineer needs to write a TypeScript function that syncs Salesforce data to Dixa user profiles.

"I need to map Salesforce contact data to Dixa. Find all custom attributes for the 'User' entity type. Then, examine the inputDefinition for the 'Customer Tier' attribute and write a TypeScript interface that perfectly matches the allowed values for that Dixa field."

Step-by-step Execution:

1. ChatGPT calls list_all_dixa_custom_attributes to find the ID of the "Customer Tier" attribute under the User entity.
2. ChatGPT calls get_single_dixa_custom_attribute_by_id passing the retrieved ID.
3. It inspects the inputDefinition (which reveals it is a dropdown with allowed values: "Bronze", "Silver", "Gold", "Platinum").
4. It generates a strict TypeScript type or enum validating those exact strings, preventing future 400 Bad Request errors.

Result: The engineer gets production-ready code that matches the actual, real-time configuration of their Dixa workspace.

Security and Access Control

Exposing API access to an LLM requires strict boundary setting. Truto's MCP architecture enforces security natively:

• Method Filtering: Configure the MCP token to only allow read operations (e.g., get, list). This physically prevents ChatGPT from issuing destructive delete or update commands, regardless of the prompt.
• Tag Filtering: Restrict tool visibility by specific business domains. If Dixa tools are tagged with support, you can limit the MCP server to only expose support-related endpoints.
• Secondary Authentication (require_api_token_auth): For sensitive enterprise setups, toggle this flag to require the client to pass a valid Truto API token in addition to the URL token. This prevents unauthorized execution if the MCP URL is accidentally leaked in a log file.
• Automated Expiration (expires_at): Set a TTL on the server. If you only need ChatGPT to audit your schemas today, generate a URL that automatically expires in 24 hours. The Truto Durable Object alarm will automatically clean up the underlying KV records.