Connect Qomon to ChatGPT: Manage Contacts, Donors and Teams

If you want to connect Qomon to ChatGPT so your AI agents can manage contacts, process donor transactions, track mobilization actions, and organize campaign teams, you need a Model Context Protocol (MCP) server. This server acts as a translation layer, taking JSON-RPC tool calls from ChatGPT and securely routing them to Qomon's REST API.

If your team uses Claude, check out our guide on connecting Qomon to Claude or explore our broader architectural overview on connecting Qomon to AI Agents.

Giving a Large Language Model (LLM) read and write access to a mobilization and CRM platform is a serious engineering challenge. You must handle complex relational data payloads, map dynamic custom fields to MCP tool definitions, and deal with strict object replacement rules. Every time Qomon updates an endpoint, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Qomon, connect it natively to ChatGPT, and execute complex field and finance workflows using natural language.

The Engineering Reality of the Qomon API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Qomon's highly specific API is exceptionally painful.

If you decide to build a custom MCP server for Qomon, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Qomon:

Transaction Bundles and Additive Updates

Unlike basic CRMs where a donation or payment is a flat, isolated record, Qomon groups financial interactions into transaction_bundles. A bundle contains one or more transactions, memberships, and donations. When updating a bundle via the API, the updates are additive - items not included in the request remain unchanged. If you want to update a specific transaction within a bundle, you must include its ID in the nested array. If you omit the ID, Qomon assumes you are appending a brand new transaction to the bundle. LLMs notoriously struggle with maintaining state across nested arrays. If your MCP tool schema is not perfectly typed, the AI will routinely overwrite or duplicate transactions inside a bundle.

Advanced Search Condition Trees

To query contacts effectively, standard query parameters do not suffice. Qomon utilizes an advanced_search POST body to filter contacts using condition-based AND/OR logic over personal info, addresses, tags, custom fields, and financial activity. Converting natural language (e.g., "Find all donors in Paris who gave over $500 last year") into this highly specific nested JSON condition tree requires flawless schema definition. Without strict JSON Schema enforcement in your MCP tool definitions, the LLM will hallucinate query syntax and fail to retrieve the right contacts.

Strict PUT Replacements on Interactions

When logging calls, meetings, or emails, Qomon uses the update_a_qomon_contact_interaction_by_id endpoint. This endpoint behaves exactly like a strict HTTP PUT. Any field omitted from the payload - including tags - is immediately cleared out in the database. If an LLM decides to update the date_of_event but forgets to include the existing tags array in the tool call, it will inadvertently wipe the interaction's tags. Your MCP layer must force the LLM to execute a GET first, hold the state, and pass the complete payload back during the update.

Hard Rate Limits and Standardized Headers

Qomon enforces strict API rate limits to maintain platform stability. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Qomon API returns an HTTP 429, Truto acts as a transparent proxy and passes that 429 error directly back to the caller (ChatGPT). Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - in this case, your agentic framework or the ChatGPT interface - is entirely responsible for detecting the 429 and executing its own backoff and retry strategy.

Step 1: Create the Qomon MCP Server

Truto handles tool generation dynamically. Rather than hand-coding JSON-RPC definitions, Truto reads the Qomon integration's API documentation and schemas, and derives the tools on the fly. You can create an MCP server scoped to a specific Qomon workspace via the Truto UI or the API.

Method A: Via the Truto UI

For administrators who want a zero-code setup:

1. Navigate to the Integrated Accounts page in the Truto dashboard.
2. Select your connected Qomon account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., name the server "Qomon Ops", restrict methods to read and write, or filter by tags like contacts).
6. Click Generate and copy the resulting MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method B: Via the API

For developers automating infrastructure provisioning, you can generate an MCP server dynamically. You will need your integrated_account_id and your Truto API token.

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": "ChatGPT Qomon Connector",
    "config": {
      "methods": ["read", "write"],
      "tags": ["contacts", "transactions", "teams"]
    }
  }'

The API returns a securely hashed URL. This single URL contains the cryptographic token required to authenticate and route requests. Treat this URL like a production secret.

{
  "id": "mcp_12345abcde",
  "name": "ChatGPT Qomon Connector",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Step 2: Connect the Server to ChatGPT

Once you have your Truto MCP server URL, you must register it with ChatGPT. The MCP standard enables the LLM to query the server via the tools/list protocol method, discover all available Qomon endpoints, and understand exactly what JSON schemas to send.

Method A: Via the ChatGPT UI

If you are a ChatGPT Pro, Plus, Business, Enterprise, or Education user:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable the Developer mode toggle (MCP support is restricted to developer mode).
3. Under MCP servers / Custom connectors, click Add a new server.
4. Enter a recognizable name (e.g., "Qomon Production").
5. Paste the Truto MCP URL into the Server URL field.
6. Save the configuration.

ChatGPT will immediately ping the server, execute an MCP handshake, and populate its internal context with the Qomon tools.

Method B: Via Manual Config File (SSE Transport)

If you are orchestrating agents programmatically or using a local dev setup, you can connect to the Truto MCP server using the official MCP Server SSE package. Truto exposes the JSON-RPC endpoints over Server-Sent Events (SSE) for seamless remote execution.

Create an mcp_config.json file:

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

When your agent boots up, it will execute the command, connect to the remote Truto proxy, and automatically pull in the Qomon schemas.

High-Leverage Qomon Hero Tools

Truto auto-generates dozens of tools for Qomon based on its complete API surface. Exposing the entire API to an LLM can sometimes overwhelm its context window. By filtering the tools (using the methods or tags configuration), you can scope the agent's capabilities. Here are six high-leverage hero tools that unlock powerful workflows.

1. list_all_qomon_search_contacts

This tool allows the AI to search Qomon contacts using condition-based AND/OR filters over personal info, addresses, tags, custom fields, and financial activity. It replaces basic string matching with deeply granular database queries.

Contextual usage notes: The LLM must construct the data.advanced_search query body. Because the JSON schema defines the exact structure of this nested object, the LLM knows how to properly construct the boolean logic.

"Find all contacts in Qomon who live in New York and have the tag 'major_donor'. Return their names and email addresses."

2. create_a_qomon_contacts_upsert

Upsert a contact asynchronously: match an existing contact by ID, external ID, email, or name/address, and create a new one if no match is found.

Contextual usage notes: This tool returns an empty 202 response. The LLM needs to know that the creation happens asynchronously on Qomon's background queues. It will not get the new contact ID back in the immediate response payload.

"I have a list of attendees from last night's fundraiser. Upsert Jane Doe (jane.doe@example.com) into Qomon. If she exists, update her address to 123 Main St."

3. create_a_qomon_transaction_bundle

Create a transaction bundle grouping one or more transactions with optional memberships and donations. This is the core endpoint for logging financial data.

Contextual usage notes: The payload requires at least one transaction in the data.transactions array. The LLM must correctly nest the amount, currency, and contact reference.

"Log a new $500 donation from contact ID 8492. Assign it to the 'Q4-Drive' campaign code and mark the payment method as credit card."

4. list_all_qomon_actions

List mobilization actions with offset pagination. Returns detailed records combining the action metadata (start/end times, addresses, assigned teams) with visit aggregates.

Contextual usage notes: Truto automatically injects pagination variables (limit and next_cursor) into the schema instructions, forcing the LLM to pass cursors back unchanged to iterate through large lists of field actions.

"Pull the list of all mobilization actions scheduled for this weekend. Summarize the number of expected visits for each action."

5. create_a_qomon_contact_interaction

Log a new interaction (call, letter, meeting, SMS, email, or donation) directly onto a Qomon contact record.

Contextual usage notes: Requires contact_id and date_of_event. This is critical for agents acting as automated SDRs or outreach coordinators that need to leave an audit trail of their communications.

"Log a phone call interaction for contact ID 9932 for today. Add a note saying 'Discussed volunteer opportunities for next month's rally.'"

6. list_all_qomon_teams

List all Qomon teams the caller has access to, including the team ID, name, address, leaders, and users.

Contextual usage notes: Used primarily as a discovery endpoint so the LLM can map natural language team names (e.g., "The Downtown Canvassers") to their numeric IDs for subsequent routing tasks.

"List all the active teams in Qomon. I need to know the team ID for the 'Downtown Field Operations' group."

(For the complete tool inventory and detailed JSON schemas for Qomon, view the Qomon integration page.)

Workflows in Action

AI agents excel when they chain multiple API calls together to accomplish a unified goal. Because Truto manages the routing and parsing, the LLM can execute stateful operations against Qomon without needing custom glue code.

sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT (Agent)
    participant Truto as Truto MCP Server
    participant Upstream as "Upstream API (Qomon)"

    User->>ChatGPT: "Log a $100 donation from John Smith (john@test.com)"
    ChatGPT->>Truto: tools/call (list_all_qomon_search_contacts)
    Truto->>Upstream: POST /api/v1/contacts/search
    Upstream-->>Truto: 200 OK (Returns Contact ID 451)
    Truto-->>ChatGPT: JSON-RPC Result (ID 451)
    ChatGPT->>Truto: tools/call (create_a_qomon_transaction_bundle)
    Truto->>Upstream: POST /api/v1/transaction_bundles
    Upstream-->>Truto: 201 Created (Bundle ID 99)
    Truto-->>ChatGPT: JSON-RPC Result (Success)
    ChatGPT-->>User: "Donation logged successfully."

Scenario 1: Financial Processing and Donor Management

A finance operations manager needs to process offline donations quickly and ensure the contact record is accurate.

"Search Qomon for a contact named 'Sarah Jenkins' with the email 'sarah.j@example.com'. If you find her, log a new transaction bundle for a $250 donation to the 'Summer2026' campaign. Then log an interaction on her profile thanking her for the gift."

Execution Steps:

1. The agent calls list_all_qomon_search_contacts with an advanced_search payload targeting the email address to extract her id.
2. Using the retrieved ID, the agent calls create_a_qomon_transaction_bundle, structuring the nested array with the $250 amount and the campaign code.
3. The agent calls create_a_qomon_contact_interaction using the contact ID, logging an email interaction with the thank-you note context.
4. The user receives confirmation that the donation and the interaction trail are safely recorded in Qomon.

Scenario 2: Mobilization Action Syncing

A field director wants an overview of volunteer deployments and needs to update team rosters based on activity.

"List all the mobilization actions in Qomon. Find the action titled 'Weekend Canvas'. Then get the team ID assigned to that action and list all the users currently in that team."

Execution Steps:

1. The agent calls list_all_qomon_actions to pull the active mobilization events.
2. It parses the response to isolate the 'Weekend Canvas' action and extracts its associated team_id.
3. The agent calls get_single_qomon_team_by_id using that ID.
4. The user receives a clean, formatted list of the volunteers assigned to that specific field action, derived across two relational endpoints.

Security and Access Control

Giving an LLM access to your CRM and financial data requires stringent security. Truto's MCP servers provide multiple layers of access control, entirely configured at the infrastructure level.

• Method Filtering: Limit the server to read, write, or specific exact methods. If you only want an agent to analyze data, create a server with config.methods: ["read"]. The LLM physically cannot execute a POST, PUT, or DELETE.
• Tag Filtering: Group tools by functional area using config.tags. If you configure an MCP server with the transactions tag, the AI will only see financial endpoints and cannot touch team management or user provisioning.
• Secondary Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting require_api_token_auth: true, the calling client must also pass a valid Truto API token in the headers. This ensures that even if the URL leaks in a log file, it remains unusable without the secondary credential.
• TTL and Expiration (expires_at): For temporary contractor workflows or ephemeral testing, you can assign an ISO datetime to expires_at. The underlying storage engines automatically drop the token at the exact timestamp, instantly terminating the server.

Strategic Wrap-Up

Integrating AI with a domain-specific platform like Qomon requires mastering nested financial payloads, complex advanced search objects, and stringent update rules. Hand-coding an MCP server forces your engineering team to take on the burden of schema maintenance, authentication refreshes, and API drift.

By routing ChatGPT through a managed Truto MCP server, you offload the entire integration lifecycle. Truto dynamically maps the Qomon API to precise JSON-RPC tool definitions, handles the OAuth token refreshes, normalizes standard pagination instructions, and enforces your strict read/write boundaries. You get the velocity of autonomous AI agents without sacrificing the safety and architecture of enterprise integration.