Connect Ivanti ITSM to ChatGPT: Manage Tickets and Service Requests
Learn how to connect Ivanti ITSM to chatgpt using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows.
If you need to connect Ivanti ITSM to ChatGPT to automate service desk triage, 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 JSON-RPC tool calls and Ivanti's complex OData REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.
If your team uses Claude, check out our guide on connecting Ivanti ITSM to Claude or explore our broader architectural overview on connecting Ivanti ITSM to AI Agents.
Giving a Large Language Model (LLM) read and write access to an enterprise IT Service Management platform is an engineering challenge. You have to handle unusual primary key architectures, specific OData filtering syntaxes, and strict validation rules for relational list fields. Every time a developer adds a custom business object or alters an incident schema, 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 Ivanti ITSM, connect it natively to ChatGPT, and execute complex service desk workflows using natural language.
The Engineering Reality of the Ivanti ITSM 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 Ivanti's highly specific API is exceptionally painful.
If you decide to build a custom MCP server for Ivanti ITSM, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Ivanti:
The RecId Dependency
Unlike modern SaaS platforms that use human-readable identifiers or simple integers for primary keys, Ivanti ITSM relies entirely on a 32-character internal identifier known as a RecId. When users refer to "Incident 10452", the API does not recognize 10452 for update or delete operations. Your MCP server must first list incidents, filter by the IncidentNumber using OData syntax to retrieve the payload, extract the 32-character RecId, and then pass that RecId into subsequent PATCH or DELETE requests. If you expose raw endpoints to an LLM without clear schema descriptions mapping this behavior, the model will hallucinate operations using the incident number and fail continuously.
Validated List Fields and Shadow RecIds
When updating or creating records, Ivanti enforces strict validation on list fields (like Status, Owner, or OwnerTeam). You cannot simply pass a string; the API requires an exact, case-sensitive display value. More complex implementations require passing the display value alongside a shadow property containing the exact RecId of that validated list item (e.g., passing Owner and Owner_Valid). If your MCP server does not expose these schema requirements correctly, ChatGPT will attempt to write standard ITIL statuses that the specific Ivanti tenant rejects with 400 Bad Request errors.
OData vs Rest API V2 Filtering Constraints
Ivanti ITSM uses an OData implementation for list retrieval, but standard OData endpoints (/api/odata/businessobject/{business_object}) do not support complex nested filter groups with brackets. If an LLM needs to construct a query like FirstName eq 'Allen' and (LastName eq 'Davis' or LastName eq 'Cope'), the standard endpoint will fail. To support this, your server must conditionally route advanced queries to the Rest API V2 endpoint (/api/odatav2/businessobject/{business_object}). Forcing an LLM to distinguish between these two routing layers requires extensive custom prompting and tool definitions.
Generating the Ivanti ITSM MCP Server
Rather than hand-coding a custom proxy to handle RecIds, pagination, and OData routing, you can use Truto to dynamically generate a managed MCP server. Truto derives tool definitions directly from the integration's documented API schema. When ChatGPT requests available tools, Truto constructs the definitions on the fly, injecting necessary pagination instructions and schema rules.
You can generate the server using either the Truto Dashboard or the API.
Method 1: Via the Truto UI
For teams manually configuring their AI environments, the UI provides the fastest path to a usable MCP server.
- Log into your Truto environment and navigate to the integrated account page for your connected Ivanti ITSM instance.
- Click the MCP Servers tab.
- Click Create MCP Server.
- Select your desired configuration. You can filter by methods (e.g., allowing only
readoperations) or tags (e.g., scoping the server strictly toincidentsandtasks). - Copy the generated MCP server URL. This single URL contains an encrypted token that handles all downstream routing and authentication to the specific Ivanti tenant.
Method 2: Via the Truto API
For automated deployments or multi-tenant agentic architectures, you can generate the MCP server programmatically. Truto scopes each MCP server to a single integrated account, ensuring complete data isolation.
Issue a POST request to the /integrated-account/:id/mcp endpoint, filtering the tools you want to expose:
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": "Ivanti Service Desk Agent",
"config": {
"methods": ["read", "write"],
"tags": ["incidents", "service_requests", "tasks"]
}
}'The response returns the configuration along with the connection URL:
{
"id": "mcp_token_xyz123",
"name": "Ivanti Service Desk Agent",
"config": {
"methods": ["read", "write"],
"tags": ["incidents", "service_requests", "tasks"]
},
"expires_at": null,
"url": "https://api.truto.one/mcp/t_8a7b6c5d4e3f2a1b"
}Keep this url secure. It acts as the transport layer and authentication bridge for your AI agent.
Connecting the MCP Server to ChatGPT
Once the server is generated, you can connect it to ChatGPT. Communication happens over HTTP POST with JSON-RPC 2.0 messages.
Method A: Via the ChatGPT UI
If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add custom connectors directly in the interface.
- In ChatGPT, click your profile and navigate to Settings -> Apps -> Advanced settings.
- Enable Developer mode.
- Under MCP servers / Custom connectors, click to add a new server.
- Enter a descriptive name (e.g., "Ivanti ITSM (Truto)").
- Paste the Truto MCP URL into the Server URL field.
- Click Save.
ChatGPT will immediately ping the endpoint, perform the initialization handshake, and list the available Ivanti tools.
Method B: Via Manual Config File
If you are running a local agentic framework, CLI agent, or Claude Desktop alongside your ChatGPT testing, you can use the official @modelcontextprotocol/server-sse wrapper to pipe the SSE stream into standard input/output.
Create or update your MCP configuration JSON file:
{
"mcpServers": {
"ivanti_itsm": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sse",
"https://api.truto.one/mcp/t_8a7b6c5d4e3f2a1b"
]
}
}
}This configuration instructs the local MCP client to spin up a process that relays local JSON-RPC messages over HTTP to the remote Truto server.
Hero Tools for Ivanti ITSM Workflows
When ChatGPT connects, Truto dynamically generates tool definitions based on the integration's underlying schema. The LLM receives a flat input namespace for arguments, which the MCP router safely splits into the required query parameters and JSON body payloads.
Here are the highest-leverage tools available for Ivanti ITSM automation.
1. List All Incidents
Fetches incident records from /api/odata/businessobject/incidents. This tool supports OData filtering and sorting, and pages results using $top and $skip parameters. The newest modified records are returned first. Crucially, this tool is used to search for an incident by its human-readable number to extract its 32-character RecId.
"Find the incident with IncidentNumber '109432' and return its RecId, subject, and current status."
2. Get Single Incident by ID
Retrieves the complete schema for a single incident record. This operation strictly requires the 32-character RecId. The proxy API handles the authorization and formatting of the response.
"Get the full details for the incident with RecId '4F34A9E8B2C1D4E5F6A7B8C9D0E1F2A3'. Identify the Owner and the exact Impact and Urgency levels."
3. Create an Incident
Creates a new incident record in the ITSM system. The tool accepts a JSON payload of fields. You must supply case-sensitive, exact display values for validated list fields such as Status, Category, Impact, Urgency, and OwnerTeam.
"Log a new incident with the subject 'VPN Access Failure'. Set the Category to 'Network', the OwnerTeam to 'Help Desk', and the Status to 'Logged'."
4. Update an Incident by ID
Executes an HTTP PATCH against an existing incident. Only the fields provided in the payload are updated. This requires the RecId of the incident. It is primarily used for triage, status updates, or reassigning tickets between teams.
"Update the incident with RecId '4F34A9E8B2C1D4E5F6A7B8C9D0E1F2A3'. Change the Status to 'Active' and assign the OwnerTeam to 'Network Engineering'."
5. Create a Service Request
Creates a ServiceReq record directly in the system. Note that this bypasses the standard Service Catalog form parameters. If you need to submit a full catalog request with parameter validation, you would use the service_request_submissions tools instead.
"Create a new service request for a hardware upgrade. Assign it to the 'Desktop Support' OwnerTeam and set the status to 'Submitted'."
6. Create a Change Record
Logs a new change request. Requires precise field mapping, typically including Subject, Description, Category, TypeOfChange (e.g., 'Minor', 'Major'), and Status.
"Log a minor change request to reboot the primary database server. Set the TypeOfChange to 'Minor', Category to 'Infrastructure', and Status to 'Logged'."
7. List All Tasks
Retrieves assignment task records (Task#Assignment). Tasks in Ivanti are often created as children of incidents or changes. This tool supports OData filtering, allowing the agent to find tasks assigned to specific teams or users.
"List all open tasks assigned to the 'Database Admin' team. Return the task details and the parent record IDs they belong to."
For the complete tool inventory, including business object metadata extraction, journal notes, full-text search, and related business object mapping, review the Ivanti ITSM integration page.
Workflows in Action
By chaining these tools together, ChatGPT can autonomously execute complex IT Service Management workflows.
Scenario 1: Autonomous Incident Triage and Reassignment
A Level 1 support technician needs to escalate an issue based on specific symptoms. They ask ChatGPT to handle the reassignment.
"Look up incident number 45091. If the symptom mentions database timeouts, update the incident by changing the OwnerTeam to 'DBA' and the Urgency to 'High'."
Execution Steps:
- ChatGPT calls
list_all_ivanti_itsm_incidentswith an OData filterIncidentNumber eq '45091'. - The server returns the record, including the 32-character
RecIdand theSymptomdescription. - ChatGPT analyzes the
Symptomfield and confirms it mentions database timeouts. - ChatGPT calls
update_a_ivanti_itsm_incident_by_id, passing the extractedRecId, and a JSON body containing{"OwnerTeam": "DBA", "Urgency": "High"}.
The technician gets a confirmation that the ticket was successfully triaged and rerouted without touching the Ivanti UI.
Scenario 2: Orchestrating a Standard Change Request
An infrastructure engineer wants to log a standard change for a routine patch cycle.
"Log a standard change request for the monthly Linux server patching. Assign the OwnerTeam to 'SysOps'. Once created, look up any tasks automatically generated for this change."
Execution Steps:
- ChatGPT calls
create_a_ivanti_itsm_changewithSubject: "Monthly Linux Patching",TypeOfChange: "Standard", andOwnerTeam: "SysOps". - The server executes the creation and returns the new change record, including its
RecId. - ChatGPT calls
list_all_ivanti_itsm_tasks, passing an OData filter to find tasks where theParentLink_RecIDmatches the newly created changeRecId.
The engineer receives the change ID along with a list of the operational tasks that the Ivanti workflow engine automatically spawned.
sequenceDiagram
participant User as User
participant ChatGPT as ChatGPT
participant Truto as Truto MCP Server
participant Ivanti as Ivanti ITSM API
User->>ChatGPT: Log a standard change request for patching...
ChatGPT->>Truto: call tool: create_a_ivanti_itsm_change<br>(Subject, TypeOfChange, OwnerTeam)
Truto->>Ivanti: POST /api/odata/businessobject/changes
Ivanti-->>Truto: 201 Created (RecId: 8A7B...)
Truto-->>ChatGPT: Result: Change created with RecId 8A7B...
ChatGPT->>Truto: call tool: list_all_ivanti_itsm_tasks<br>($filter=ParentLink_RecID eq '8A7B...')
Truto->>Ivanti: GET /api/odata/businessobject/tasks
Ivanti-->>Truto: 200 OK (Array of Tasks)
Truto-->>ChatGPT: Result: 3 Tasks found
ChatGPT-->>User: Change created. 3 automated tasks have been queued.Handling Rate Limits
When exposing SaaS APIs to autonomous agents, API rate limits are a critical consideration. If your agent executes a loop that burns through the Ivanti tenant's quota, the API will reject requests.
Truto does not absorb, retry, or apply exponential backoff to rate limit errors. When the upstream Ivanti API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. However, Truto normalizes the rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The MCP client or the underlying agent framework is entirely responsible for reading these headers and executing its own backoff strategy before retrying the tool call.
Security and Access Control
Exposing an ITSM database to an LLM requires strict boundary controls. Truto applies security at the token level, ensuring the MCP server operates with least-privilege access:
- Method Filtering: You can restrict the MCP token configuration to specific HTTP methods. Passing
methods: ["read"]ensures the LLM can only query data and is physically blocked from executing POST, PATCH, or DELETE operations. - Tag Filtering: By passing
tags: ["incidents", "tasks"], you filter out all other business objects. The LLM will not even be aware that tools for employees, changes, or journal notes exist. - Secondary API Authentication: By enabling
require_api_token_auth: true, possession of the MCP URL is no longer enough to execute tools. The connecting client must also pass a valid Truto API token in theAuthorizationheader, adding a required secondary layer of authentication. - Automatic Cleanup: You can set an
expires_atISO datetime when generating the server. Once the timestamp is reached, a distributed scheduling process automatically destroys the server routing configuration and cleans up the associated key-value metadata, ensuring temporary access is reliably revoked.
By leveraging dynamic documentation-driven tool generation, you can eliminate the boilerplate code required to map JSON-RPC payloads into Ivanti OData requests. Instead of spending weeks building proxy infrastructure, you can generate a secure MCP server in seconds and get back to building agentic workflows.