Connect Linq to ChatGPT: Manage iMessage Chats & Group Workflows

If you need to connect Linq to ChatGPT to manage iMessage group chats, trigger RCS messaging sequences, or automate business texting workflows, you need a Model Context Protocol (MCP) server. If your team relies on Claude instead, check out our guide on connecting Linq to Claude or explore our broader architectural overview on connecting Linq to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex messaging infrastructure like Linq is an engineering challenge. Linq orchestrates iMessage, RCS, and SMS delivery across complex network rules. You have to handle asynchronous webhooks for group metadata, strict time limits on message edits, and multi-step attachment uploads. Every time the Linq API changes, 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 Linq, connect it natively to ChatGPT, and execute complex messaging workflows using natural language.

The Engineering Reality of the Linq API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Linq's API is painful.

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

Asynchronous Group Chat Management When you update a Linq chat's display name or group icon, the API does not immediately return the updated object. Instead, it returns a 202 Accepted status. The actual update happens asynchronously across the iMessage/RCS network. To confirm success, your system must listen for chat.group_name_updated or chat.group_icon_updated webhooks. If your custom MCP server blocks waiting for a synchronous response, the LLM will timeout and fail.

Strict Message Immutability Windows Unlike a database record, a sent iMessage cannot be freely updated. Linq enforces strict edit rules: you can only update a message part a maximum of 5 times, and only within a 15-minute window after sending. If your AI agent attempts to edit a message outside this window, the API throws an error. Your MCP server must handle this state accurately so the LLM understands why a tool call was rejected.

Multi-Step Attachment Ceremonies Sending an image or document via Linq is not a single API call. You must first call the attachments endpoint with the filename and size to obtain a presigned URL and a permanent attachment_id. You then upload the file binary directly to that presigned URL, and finally pass the attachment_id into the message payload. If your MCP server does not abstract this multi-step dance, the LLM will hallucinate direct file uploads and fail.

Complex Rate Limit Handling Messaging APIs are heavily rate-limited to prevent spam. When building your integration, it is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Linq API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - your LLM agent framework - is entirely responsible for implementing its own retry and exponential backoff logic.

The Managed MCP Approach

Instead of forcing your engineering team to build and maintain a custom Node.js or Python server to handle Linq's idiosyncrasies, you can use Truto.

Truto dynamically generates MCP tools based directly on the integration's API documentation and resource schemas. A tool only appears in the MCP server if it has a corresponding documentation entry - acting as a quality gate. There is no hardcoded tool logic to maintain; as Linq's API evolves, the tools update dynamically.

How to Create the Linq MCP Server

Each MCP server is scoped to a single connected instance of Linq for a specific tenant. The server URL contains a cryptographic token that securely encodes which account to use and what tools to expose.

You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For quick prototyping or manual setup, you can generate the MCP server directly from your dashboard:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Linq account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read-only methods, filter by specific tags, or set an expiration date).
5. Copy the generated MCP server URL. It will look like this: https://api.truto.one/mcp/a1b2c3d4e5f6...

Method 2: Via the Truto API

For production workflows, you should provision MCP servers programmatically. Make a POST request to /integrated-account/:id/mcp with your desired configuration.

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": "Linq Support Ops Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["messaging", "groups"],
      "require_api_token_auth": false
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API validates that the Linq integration has available tools matching your filters, generates a secure hashed token stored at the edge, and returns a ready-to-use URL.

How to Connect the Linq MCP Server to ChatGPT

Once you have your Truto MCP server URL, connecting it to ChatGPT takes seconds. The URL is fully self-contained - it handles authentication and routing automatically.

Method 1: Via the ChatGPT UI

If you are using ChatGPT Plus, Team, or Enterprise, you can add the server directly through the interface:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle on Developer mode.
3. Under MCP servers / Custom connectors, click Add new server.
4. Enter a name (e.g., "Linq Messaging Ops").
5. Paste the Truto MCP server URL into the Server URL field.
6. Click Save.

ChatGPT will immediately perform a handshake with the Truto MCP router, request the list of available Linq tools, and populate them in your workspace.

Method 2: Via Manual Configuration File

If you are running a local instance of Claude Desktop, Cursor, or a custom LangChain agent, you can connect using a standard JSON configuration file and the MCP SSE transport.

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

Hero Tools for Linq

Truto exposes Linq's capabilities as distinct, highly documented JSON-RPC 2.0 tools. Here are the highest-leverage tools available for your AI agents.

Create a Linq Chat

Tool name: create_a_linq_chat

Creates a new Linq chat with specified participants. This tool requires a from number, a to participant handle, and an initial message. Note a specific Linq platform rule: the first outbound message cannot contain a link or URL to prevent automated spam filtering.

"Start a new iMessage chat from our primary support line to +15550198372. Send an initial message saying 'Hi, this is the priority support team. We received your alert.' Do not include any links."

Add Participant to Group Chat

Tool name: create_a_linq_chat_participant

Adds a new participant to an existing Linq group chat. This is crucial for escalation workflows. The new participant must support the same messaging service (e.g., iMessage) as the rest of the group.

"Add the on-call engineer at +15550187463 to the group chat with ID chat_987abc. Confirm once they are added."

List All Message Threads

Tool name: list_all_linq_message_threads

Given any single message ID within a thread, this tool returns the originator message and all subsequent replies in chronological order. This gives the LLM full conversational context before drafting a response.

"Retrieve the full message thread for message ID msg_456def. Summarize the customer's main complaint and draft a polite response addressing their concerns."

Edit an Existing Message

Tool name: update_a_linq_message_by_id

Edits a specific message part in Linq. The LLM must respect Linq's constraints: edits are only allowed up to 5 times and must occur within 15 minutes of the original send time.

"I noticed a typo in my last message (ID msg_789ghi). Edit it to say 'Your server deployment is complete' instead of 'Your server deportment is complete'."

Upload a File Attachment

Tool name: create_a_linq_attachment

Handles the first stage of the Linq media flow. It pre-uploads a file to obtain a presigned URL and a permanent attachment_id. The LLM can then pass this ID into subsequent message creation tools.

"Initialize an attachment upload for a file named 'contract_v2.pdf' with a size of 45000 bytes and content type 'application/pdf'. Give me the attachment_id so I can send it to the client."

Request Live Location

Tool name: create_a_linq_location_request

Sends a location sharing request to a contact. This only works in 1:1 iMessage chats; attempting to use this in a group, SMS, or RCS chat will return a 409 Conflict error.

"Send a location sharing request in chat ID chat_123xyz so we can verify the field technician's arrival at the site."

This is just a subset of the available operations. For the complete tool inventory, detailed JSON schemas, and required parameters, visit the Linq integration page.

Workflows in Action

Connecting Linq to ChatGPT transforms static messaging into intelligent, agentic workflows. Here is exactly how an LLM orchestrates multi-step processes using Truto's MCP tools.

Scenario 1: Incident Response Assembly

When a critical alert fires, an IT admin asks ChatGPT to spin up a crisis communication channel, loop in the right people, and brief them automatically.

"We have a Sev 1 database outage. Create a new group chat from our operations line to the lead DBA (+15550191111). Say 'Sev 1 DB outage detected. Assembling response team.' Then add the network engineer (+15550192222) to the group."

Tool Execution Flow:

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant Linq as Linq API

    User->>ChatGPT: "Create Sev 1 chat with DBA, send message, add Network Eng"
    ChatGPT->>TrutoMCP: Call create_a_linq_chat(from, to, message)
    TrutoMCP->>Linq: POST /v3/chats
    Linq-->>TrutoMCP: Returns chat_id (e.g., chat_999)
    TrutoMCP-->>ChatGPT: Returns chat object
    ChatGPT->>TrutoMCP: Call create_a_linq_chat_participant(chat_id, handle)
    TrutoMCP->>Linq: POST /v3/chats/chat_999/participants
    Linq-->>TrutoMCP: Returns 204 Success
    TrutoMCP-->>ChatGPT: Returns success status
    ChatGPT-->>User: "Group chat created and response team assembled."

The LLM handles the sequential dependency, waiting for the create_a_linq_chat tool to return the new chat_id before invoking the create_a_linq_chat_participant tool.

Scenario 2: Secure Document Distribution

An account manager needs to send an updated contract via iMessage and ensure all parties have the context.

"Upload 'Q4_Agreement.pdf' (1.2MB) as an attachment. Once you have the attachment ID, send it in the active group chat ID chat_777 along with the message 'Here is the revised Q4 agreement for your review.'"

Tool Execution Flow:

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant Linq as Linq API

    User->>ChatGPT: "Upload Q4_Agreement.pdf and send to chat_777"
    ChatGPT->>TrutoMCP: Call create_a_linq_attachment(filename, size_bytes)
    TrutoMCP->>Linq: POST /v3/attachments
    Linq-->>TrutoMCP: Returns attachment_id and upload_url
    TrutoMCP-->>ChatGPT: Returns attachment payload
    ChatGPT->>TrutoMCP: Call create_a_linq_chat_message(chat_id, message_with_attachment)
    TrutoMCP->>Linq: POST /v3/chats/chat_777/messages
    Linq-->>TrutoMCP: Returns 200 OK
    TrutoMCP-->>ChatGPT: Returns delivery status
    ChatGPT-->>User: "Document uploaded and sent to the group."

The LLM correctly sequences the attachment pre-upload ceremony, extracts the resulting attachment_id, and maps it into the subsequent message creation tool payload.

Security and Access Control

Giving an AI agent access to corporate messaging requires strict governance. Truto MCP servers provide built-in access controls:

• Method Filtering: You can restrict a server to specific operations. For example, setting methods: ["read"] ensures the LLM can only query chat history and contact cards, physically preventing it from sending outbound messages.
• Tag Filtering: Limit the LLM's scope by functional area. Applying tags: ["support"] ensures the agent only sees tools related to customer service inquiries, isolating it from internal IT alerting tools.
• Time-to-Live (TTL): The expires_at parameter allows you to create ephemeral servers. If you need a contractor to audit message history for a weekend, you can generate a URL that automatically destructs on Monday, leaving no stale access behind.
• Secondary Authentication: By default, the cryptographically hashed MCP URL acts as the authentication vector. For zero-trust environments, enabling require_api_token_auth forces the MCP client to also pass a valid Truto API token via a Bearer header. If the URL is leaked in a CI/CD log, it remains useless without the secondary credential.

Moving Fast with Managed Infrastructure

Building AI agents that interact with complex messaging protocols like iMessage and RCS used to require months of custom engineering. Dealing with async webhooks, strict edit windows, rate limit backoffs, and multi-step media uploads drains engineering velocity.

By leveraging a managed infrastructure layer, you eliminate the boilerplate. Truto's dynamic tool generation ensures your AI agents always have accurate, up-to-date access to Linq's capabilities, strictly governed by your security configurations. You stop writing custom JSON schemas and start shipping agentic workflows.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} Let's build your AI integration strategy together. :::