---
title: "Connect BMC Helix to ChatGPT: Manage ITSM Incidents and Change Requests"
slug: connect-bmc-helix-to-chatgpt-manage-itsm-incidents-and-change-requests
date: 2026-11-07
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect BMC Helix to ChatGPT using a managed MCP server. This guide covers bypassing ITSM API quirks, creating incidents, and executing workflows."
tldr: "Connect BMC Helix to ChatGPT via Truto's managed MCP server. Execute ITSM workflows, bypass AR form API complexities, and orchestrate incident lifecycles securely using natural language."
canonical: https://truto.one/blog/connect-bmc-helix-to-chatgpt-manage-itsm-incidents-and-change-requests/
---

# 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](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). 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](https://truto.one/connect-bmc-helix-to-claude-sync-service-requests-and-support-teams/) or explore our broader architectural overview on [connecting BMC Helix to AI Agents](https://truto.one/connect-bmc-helix-to-ai-agents-orchestrate-itsm-workflows-and-tasks/).

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](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## 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](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/) 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](https://truto.one/blog/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), 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.

```bash
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:

```json
{
  "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](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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](https://truto.one/integrations/detail/bmchelix).* 

## 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.

```mermaid
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.