Connect FlowMate to ChatGPT: Manage and monitor automation flows

If you need to connect FlowMate to ChatGPT to automate workflow debugging, audit system logs, or manipulate flow execution graphs directly from a conversational interface, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calling capabilities and FlowMate's REST APIs. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds.

If your team uses Claude, check out our guide on connecting FlowMate to Claude. If you are building custom autonomous systems instead of using consumer chat apps, read our architectural breakdown on connecting FlowMate to AI Agents.

Giving a Large Language Model (LLM) read and write access to an automation engine like FlowMate is a high-stakes engineering challenge. You are giving an AI the ability to start and stop business processes, modify logic gates, and read tenant-scoped execution logs. You must handle complex nested JSON structures, strict multi-tenant data isolation, and rigid validation logic. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for FlowMate, connect it natively to ChatGPT, and execute complex operations using natural language.

The Engineering Reality of the FlowMate 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, implementing it against vendor-specific endpoints requires constant maintenance. If you decide to build a custom MCP server for FlowMate, you own the entire API lifecycle.

FlowMate is an automation platform, which means its API introduces specific integration challenges that break standard CRUD assumptions.

Graph Payload Complexity

When you interact with a FlowMate flow via the API, you are not just updating a string or a boolean. A FlowMate flow relies on a graph object - a deeply nested JSON structure representing nodes, edges, validation rules, and async triggers. An LLM cannot simply hallucinate a valid Directed Acyclic Graph (DAG). If your MCP server does not strictly provide the underlying JSON schemas to the model before it executes an update, the LLM will pass an invalid graph structure, breaking the automation entirely.

Strict Tenant-Scoped Isolation

FlowMate relies heavily on tenant isolation. You cannot simply ask the API for "all logs." Endpoints like the system logs require a specific tenant parameter to route the query to the correct isolated execution environment. If your custom server fails to instruct the LLM that tenant is a mandatory parameter for log retrieval, every log query will fail with a 400 Bad Request.

Asynchronous Execution States

Starting a flow via the API triggers an asynchronous background process. The API returns an immediate success response indicating the flow has started, but it does not wait for the flow to finish. To verify success, an LLM must be explicitly instructed to wait and query the execution logs using the specific flow ID. Managing this async polling loop requires highly specific prompting and tool design.

Rate Limits and 429 Handling

Like any enterprise system, FlowMate enforces rate limits. When integrating via Truto, it is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the FlowMate API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit info into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset), but the caller - in this case, ChatGPT - is entirely responsible for executing retry and backoff logic. Your agent prompts must be designed to handle failure gracefully.

The Managed MCP Architecture

Instead of forcing your engineering team to build a custom proxy server that translates JSON-RPC to REST, Truto dynamically derives an MCP server from your connected FlowMate account.

Truto's approach is entirely documentation-driven. It looks at the existing integration definitions and their corresponding JSON schemas, and automatically generates a flat list of MCP tools. If a FlowMate API endpoint has a documentation record detailing its query parameters and request body, it becomes an AI tool. The LLM receives exact instructions on which parameters are required, what type of data is expected, and how to format complex payloads like FlowMate graphs.

This managed architecture runs on a globally distributed edge network. The server URL contains a cryptographically signed token that authenticates the request, loads the specific FlowMate account context, and routes the tool call through the proxy API layer without caching the underlying payload data.

Step 1: Create the FlowMate MCP Server

You must generate a unique MCP server URL tied to your specific FlowMate instance. You can do this visually through the Truto dashboard or programmatically via the API.

Method 1: Via the Truto UI

1. Log into your Truto account and navigate to the integrated account page for your FlowMate connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server name. You can optionally apply method filters (e.g., restricting the server to read-only operations) or tag filters.
5. Click Save and copy the generated MCP server URL. It will look like https://api.truto.one/mcp/abc123def456...

Method 2: Via the Truto API

For automated deployments, you can provision the server by making a POST request to the Truto API. This is ideal if you are dynamically spinning up agent workspaces for individual tenants.

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": "FlowMate Ops Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'

The API validates that the FlowMate integration is AI-ready, hashes the authentication token, stores it securely, and returns the ready-to-use URL in the response object.

Step 2: Connect the MCP Server to ChatGPT

With the MCP server URL generated, you can connect it directly to ChatGPT. ChatGPT acts as the JSON-RPC client, discovering the available FlowMate tools and executing them based on user prompts.

Method A: Via the ChatGPT UI

1. Open ChatGPT and click your profile picture to access Settings.
2. Navigate to Apps and open Advanced settings.
3. Enable Developer mode (custom MCP support requires this flag to be toggled on).
4. Under the MCP servers or Custom connectors section, click to add a new server.
5. Enter a recognizable name like "FlowMate Ops" and paste the Truto MCP URL into the Server URL field.
6. Save the configuration. ChatGPT will immediately perform a handshake with Truto to list the available FlowMate tools.

Method B: Via Manual Config File

If you are using a desktop client or an automated agent framework that accepts standard MCP JSON configurations, you can wire up the server using the standard SSE (Server-Sent Events) transport command.

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

Hero Tools for FlowMate

Once connected, Truto exposes FlowMate's API surface as discrete, well-documented tools. The AI agent uses these tools to interact with your automation infrastructure. Here are the highest-leverage operations available.

List all flows

The list_all_flow_mate_flow tool retrieves all automation flows currently defined in the system. It returns core metadata including the ID, name, type, and current status of each flow. This is the primary discovery tool an LLM uses to find the exact flow it needs to manage.

"Get a list of all current flows in FlowMate. Show me their names, IDs, and current execution statuses in a markdown table."

Get a single flow by ID

The get_single_flow_mate_flow_by_id tool fetches the complete, detailed record of a specific flow. Critically, this returns the full graph JSON object. An LLM must call this tool to read the current graph state before attempting to update it.

"Fetch the full configuration for the flow ID 'flw_987654'. I need to see the complete graph structure and how the trigger nodes are configured."

Update a flow

The update_a_flow_mate_flow_by_id tool modifies an existing flow. It requires the id, name, graph, and type parameters. Because the graph structure is complex, the LLM relies on the schema definitions provided by Truto during the MCP handshake to format the payload correctly.

"Update the flow ID 'flw_987654'. Keep the name and type the same, but modify the graph payload to increase the timeout value on the final webhook step from 30 seconds to 60 seconds."

Start a flow execution

The flow_mate_flow_start tool triggers a flow to run asynchronously. It requires the flow_id. The response returns the initial transition status. Because execution is async, the LLM will need to query logs afterward to verify success.

"Trigger a manual start for the 'Nightly Data Sync' flow (ID: flw_112233). Once it starts, let me know the execution transition status."

List system logs

The list_all_flow_mate_log tool fetches execution logs for a specific tenant. This is the primary diagnostic tool. It requires the tenant parameter and supports filtering by flow, step, or error-only mode.

"Pull the execution logs for the tenant 'acme-corp'. Filter for errors only, and tell me why the reporting flow failed during its last run."

Fetch execution reporting

The list_all_flow_mate_reporting tool retrieves aggregated execution metrics over a specific time frame. It returns grouped execution counts, allowing you to monitor system health and tenant usage at a macro level.

"Generate an execution report for the last 7 days. Group the results by tenant and highlight any tenant that has zero successful flow executions."

For the complete inventory of available operations, required parameters, and strict JSON schemas, refer to the FlowMate integration page.

Workflows in Action

By chaining these tools together, ChatGPT can act as a fully autonomous Level 1 support engineer for your automation infrastructure. Here are two concrete scenarios showing how the LLM routes operations.

Scenario 1: Flow Failure Investigation and Remediation

When a critical automation fails, a DevOps engineer needs to identify the failure point, fix the logic, and restart the process.

"Check the error logs for the 'Data Ingestion' flow under the tenant 'globex-inc'. Find the node that caused the failure, update the flow graph to correct the misconfigured edge, and restart the flow."

1. list_all_flow_mate_log: The agent queries the logs using tenant: "globex-inc" and filtering for errors to isolate the exact step failure.
2. get_single_flow_mate_flow_by_id: The agent fetches the flow to analyze the current graph structure surrounding the failing node.
3. update_a_flow_mate_flow_by_id: The agent formulates a new graph object fixing the broken logic and pushes the update.
4. flow_mate_flow_start: Finally, the agent triggers a new execution to ensure the fix resolves the issue.

sequenceDiagram
    participant User as User
    participant ChatGPT as "ChatGPT (MCP Client)"
    participant Truto as "Truto MCP Server"
    participant FlowMate as "FlowMate API"
    
    User->>ChatGPT: "Fix the failed Globex flow"
    ChatGPT->>Truto: Call list_all_flow_mate_log
    Truto->>FlowMate: GET /logs?tenant=globex-inc&errors=true
    FlowMate-->>Truto: JSON log payload
    Truto-->>ChatGPT: Parsed failure context
    ChatGPT->>Truto: Call get_single_flow_mate_flow_by_id
    Truto->>FlowMate: GET /flows/{id}
    FlowMate-->>Truto: Full graph object
    Truto-->>ChatGPT: Graph schema mapped
    ChatGPT->>Truto: Call update_a_flow_mate_flow_by_id
    Truto->>FlowMate: PUT /flows/{id} (Updated graph)
    FlowMate-->>Truto: Success
    Truto-->>ChatGPT: Success confirmation
    ChatGPT->>Truto: Call flow_mate_flow_start
    Truto->>FlowMate: POST /flows/{id}/start
    FlowMate-->>Truto: Execution queued
    Truto-->>ChatGPT: Async status
    ChatGPT-->>User: "Graph fixed and flow restarted."

Scenario 2: Tenant-Wide Execution Audit

An IT admin needs a high-level overview of system health to ensure automation infrastructure is functioning correctly for all customers.

"Pull the execution reporting for the last 48 hours grouped by tenant. Identify any tenant whose total execution count dropped by more than 50% compared to yesterday, and check their specific logs for widespread errors."

1. list_all_flow_mate_reporting: The agent fetches the aggregated execution counts, passing a 48-hour time window and setting the groupby parameter to tenant.
2. list_all_flow_mate_log: If the agent spots a steep drop-off for a specific tenant, it executes a follow-up query against that specific tenant's error logs to diagnose systemic issues.
3. The agent summarizes the findings in a clear markdown report for the IT admin.

Security and Access Control

Giving an LLM access to your automation engine requires strict boundaries. Truto provides several mechanisms to lock down the MCP server payload before you ever expose it to ChatGPT.

• Method Filtering: You can configure the server to only allow read methods. This permits the LLM to query list_all_flow_mate_log and list_all_flow_mate_flow to debug issues, but completely blocks tools like update_a_flow_mate_flow_by_id or delete_a_flow_mate_flow_by_id at the protocol generation layer.
• Tag Filtering: If your integration configuration assigns specific tags to certain FlowMate resources (e.g., tagging logs and reporting as audit), you can restrict the MCP server to only expose tools containing those tags.
• Require API Token Auth: For high-security environments, you can enable require_api_token_auth. This forces ChatGPT (or any MCP client) to pass a valid Truto API token in the Authorization header, ensuring that possession of the MCP URL alone is not enough to execute FlowMate commands.
• Ephemeral Servers: You can attach an expires_at timestamp to the MCP server. Truto's scheduled eviction tasks will automatically purge the authentication token and disable the server once the TTL is reached, making it ideal for temporary debugging sessions.