Connect BMC Helix to ChatGPT: Manage ITSM Incidents and Change Requests

If you need to connect BMC Helix to ChatGPT to automate IT service management (ITSM), manage incident lifecycles, or orchestrate change requests, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calling capabilities and BMC Helix's complex Action Request (AR) System APIs.

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

Giving a Large Language Model (LLM) read and write access to an enterprise ITSM platform like BMC Helix is an engineering challenge. The Helix API does not behave like a standard REST API. It relies heavily on interface forms, internal action triggers, and proprietary query languages. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into Helix's highly specific payload structures, or you use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

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

The Engineering Reality of the BMC Helix API

Building a custom MCP server means you own the entire API lifecycle. While the open MCP standard provides a predictable way for models to discover tools, implementing it against BMC Helix is exceptionally painful due to its legacy architecture.

Here are the specific integration challenges that break standard CRUD assumptions when working with the Helix API:

Interface Forms and the z1D_Action Pattern

Unlike modern SaaS platforms with direct endpoints for entities (e.g., POST /api/incidents), BMC Helix requires you to interact with specific AR forms. To create an incident, you don't post to the incident table - you post to an interface form like HPD:IncidentInterface_Create. Furthermore, Helix controls backend workflow execution using a virtual field called z1D_Action. To successfully create a record, your payload must include "z1D_Action": "CREATE". To update, you must pass "z1D_Action": "MODIFY" to the modification interface. Teaching an LLM to reliably inject these arbitrary system flags into payloads requires complex JSON Schema definitions in your MCP tools.

AR Qualifications for Querying

Pagination and filtering in Helix do not use standard OData or URL query parameters. Instead, they require AR System qualifications passed via the q parameter. A query looks like 'Status'="Assigned" AND 'Impact'="1-Extensive/Widespread". If an LLM needs to filter incidents, your MCP server must parse the LLM's intent and format it into a flawless AR qualification string. Escaping quotes and matching exact enum string values across hundreds of custom ITSM deployments often leads to hallucinated or invalid API requests.

Managing Rate Limits

When executing high-volume polling or bulk incident updates via AI agents, you will hit rate limits. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream BMC Helix 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 (or the orchestration layer driving the AI agent) is strictly responsible for implementing its own retry and exponential backoff logic.

Step 1: Generate a BMC Helix MCP Server

Before connecting to ChatGPT, you need to generate an MCP server endpoint scoped to a specific BMC Helix environment. Truto allows you to do this either via the web dashboard or programmatically via the API.

Method A: Via the Truto UI

1. Navigate to the Integrated Accounts section in your Truto dashboard.
2. Click on your connected BMC Helix account.
3. Navigate to the MCP Servers tab.
4. Click Create MCP Server.
5. Configure your server by selecting allowed methods (e.g., read, write) and tags (e.g., incidents, changes).
6. Click Save and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>). Treat this URL as a secret.

Method B: Via the API

You can dynamically provision MCP servers for different tenants or agents using the Truto API. This requires the integrated_account_id of your connected Helix instance.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Helix ITSM for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["incidents", "changes", "worklogs"]
    }
  }'

The API validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL. The token in the URL encodes the authentication and configuration filters.

Step 2: Connect the MCP Server to ChatGPT

Once you have the Truto MCP server URL, you can expose the Helix tools to your LLM.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the connector directly in the UI using Developer Mode.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers / Custom connectors section, click Add new server.
4. Set the Name to something descriptive (e.g., "BMC Helix ITSM").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save. ChatGPT will immediately perform a handshake, call the tools/list endpoint, and discover the BMC Helix operations.

Method B: Via Manual Config (Local Agents)

If you are building a custom agent wrapper or testing locally before deploying, you can run the server using an SSE transport configuration. Create an mcp.json file:

{
  "mcpServers": {
    "bmc_helix": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<YOUR_TOKEN>"
      ]
    }
  }
}

Your agent framework (like LangChain or a custom Claude Desktop setup) will use this configuration to route JSON-RPC 2.0 messages to the Truto endpoint.

BMC Helix Hero Tools for ChatGPT

Truto automatically generates LLM-ready tool schemas from the underlying API documentation. Here are the highest-leverage tools available for BMC Helix.

List All Incidents

Tool: list_all_bmc_helix_incident Queries the HPD:Help Desk form. This tool accepts an AR qualification in the q parameter to filter results. It handles pagination automatically via offset and limit.

"Find all open incidents assigned to the Database Admin group that have a critical urgency level."

Create an Incident

Tool: create_a_bmc_helix_incident Routes data through the HPD:IncidentInterface_Create form. It automatically handles the z1D_Action field requirement.

"Create a new high-impact incident for the user John Doe. The database server DB-04 is completely unresponsive and affecting all European users. Route it to Tier 3 Support."

Create an Incident Work Log

Tool: create_a_bmc_helix_worklog Adds work info notes to an existing incident in the HPD:WorkLog form. This is critical for agents acting as Level 1 support who need to document their troubleshooting steps.

"Add a work log to Incident INC0000012345. Note that I restarted the application pool, but the memory leak issue persists. Set the work log type to 'Working Log'."

Create a Change Request

Tool: create_a_bmc_helix_change Interfaces with CHG:ChangeInterface_Create to provision infrastructure changes. LLMs can draft the initial change request based on anomalous system logs or Slack conversations.

"Draft a new emergency change request to upgrade the Redis cluster to version 7.2. Set the impact to widespread and urgency to critical."

List People Records

Tool: list_all_bmc_helix_people Queries the CTM:People form to find user directory information, support groups, and profile statuses.

"Look up the contact details and support group assignment for Sarah Jenkins in the ITSM directory."

Update a Task

Tool: update_a_bmc_helix_task_interface_by_id Modifies an existing task via the TMS:TaskInterface form. This is heavily used by AI agents to close out automated remediation tasks.

"Update task TAS000009876. Change the status to 'Closed' and add a note that the firewall rule has been successfully deployed."

To view the complete inventory of available tools and their schema definitions, visit the BMC Helix integration page.

Workflows in Action

Once connected, ChatGPT can orchestrate multi-step ITSM processes that would normally require a human to navigate multiple slow AR system forms.

Workflow 1: Triage and Escalate High-Priority Incidents

When a major outage occurs, support engineers waste time gathering context. ChatGPT can ingest a raw Slack alert and fully scaffold the incident in Helix.

"An alert just fired: 'Payment gateway API timeouts exceeding 50%'. Check for similar recent incidents. If none exist, create a critical incident, assign it to the Payments team, and log a work note that I am beginning investigation."

Execution Steps:

1. ChatGPT calls list_all_bmc_helix_incident with a q parameter searching for recent incidents containing "Payment gateway".
2. Seeing no active incidents, it calls create_a_bmc_helix_incident passing the required fields (First_Name, Last_Name, Description, Impact, Urgency, Status, Service_Type).
3. It extracts the new Incident Number from the response.
4. It calls create_a_bmc_helix_worklog passing the Incident Number and the initial troubleshooting notes.

sequenceDiagram
  participant User as ChatGPT User
  participant Agent as ChatGPT (MCP Client)
  participant Truto as Truto MCP Server
  participant Helix as "BMC Helix API"

  User->>Agent: "Check for payment incidents, then create one if missing."
  Agent->>Truto: Call tool `list_all_bmc_helix_incident`
  Truto->>Helix: GET /api/arsys/v1/entry/HPD:Help Desk?q=...
  Helix-->>Truto: { "entries": [] }
  Truto-->>Agent: JSON Result (No incidents found)
  
  Agent->>Truto: Call tool `create_a_bmc_helix_incident`
  Truto->>Helix: POST /api/arsys/v1/entry/HPD:IncidentInterface_Create<br>(z1D_Action: CREATE)
  Helix-->>Truto: 201 Created (INC000102030)
  Truto-->>Agent: JSON Result (INC000102030)
  
  Agent->>Truto: Call tool `create_a_bmc_helix_worklog`
  Truto->>Helix: POST /api/arsys/v1/entry/HPD:WorkLog
  Helix-->>Truto: 201 Created
  Truto-->>Agent: JSON Result (Success)
  Agent-->>User: "Incident INC000102030 created and work log attached."

Workflow 2: Orchestrating an Emergency Infrastructure Change

AI agents can assist DevOps teams by drafting the tedious documentation required for emergency changes.

"We need to immediately roll back the frontend deployment due to a critical bug. Draft an emergency change request, then look up the on-call deployment manager in the people directory so I know who to ping for approval."

Execution Steps:

1. ChatGPT calls create_a_bmc_helix_change to generate the CRQ record through the CHG:ChangeInterface_Create form, mapping the description to the rollback requirement.
2. It captures the returned Infrastructure Change ID.
3. It calls list_all_bmc_helix_people using a query to find the deployment manager for the affected service.
4. ChatGPT formats a final summary for the user containing the CRQ number and the manager's contact details.

Security and Access Control

Handing an LLM full access to an enterprise ITSM platform is dangerous. Truto MCP servers enforce strict boundaries at the infrastructure level, entirely removed from the LLM's prompt context.

• Method Filtering: Limit the MCP server to specific HTTP verbs. Setting methods: ["read"] ensures the LLM can only execute get and list operations, physically preventing it from creating or deleting incidents regardless of the prompt.
• Tag Filtering: Restrict access to specific functional domains. Setting tags: ["incidents", "worklogs"] guarantees the LLM cannot access or mutate HR data in the CTM:People forms.
• Secondary Authentication: Enable require_api_token_auth to force the MCP client to pass a valid Truto API token in the headers. This ensures that even if the MCP URL leaks, it cannot be used without valid secondary credentials.
• Ephemeral Servers: Set an expires_at timestamp when generating the server. Once the timestamp passes, the routing infrastructure automatically terminates the token, immediately severing the LLM's access to BMC Helix.

Building dynamic integrations for legacy ITSM platforms consumes massive engineering resources. By using auto-generated MCP servers, you eliminate the need to write custom parsers for AR qualifications, manage authentication refreshes, or manually map complex JSON payloads to interface forms, allowing you to focus purely on agent logic.