Connect Ivanti ITSM to Claude: Sync Incidents and Business Objects
A technical guide to building a managed MCP server for Ivanti ITSM. Learn how to connect Claude to your IT service desk to automate incident triage, metadata discovery, and business object updates.
If you need to connect Ivanti ITSM to Claude to automate incident resolution, provision service requests, or query custom business objects, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and Ivanti's complex REST and OData 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 ChatGPT, check out our guide on /connect-ivanti-itsm-to-chatgpt-manage-tickets-and-service-requests/ or explore our broader architectural overview on /connect-ivanti-itsm-to-ai-agents-automate-service-desk-workflows/.
Giving a Large Language Model read and write access to a sprawling enterprise service management platform like Ivanti is an engineering challenge. You have to handle opaque 32-character record IDs, map EDMX XML schemas to MCP tool definitions, and deal with Ivanti's specific OData query constraints. Every time your IT department adds a custom business object or a new validated list field, your integration logic has to adapt.
This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Ivanti ITSM, connect it natively to Claude, 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, the reality of implementing it against specialized enterprise B2B APIs is painful. Ivanti ITSM is built on a highly customizable object model. Its API reflects that complexity.
If you decide to build a custom Ivanti ITSM MCP server, here are the specific integration challenges you will face:
The RecId Resolution Problem
Ivanti ITSM relies exclusively on 32-character hexadecimal identifiers called RecIds for almost all API operations. If an LLM reads a user prompt saying "Close incident 10543", it cannot simply send an API request to PATCH /api/odata/businessobject/incidents/10543. It must first run a search query against the Incidents object to find the RecId associated with Incident Number 10543, and then use that RecId in the subsequent update request. Your MCP tool schemas must explicitly instruct the LLM on this two-step process.
Validated List Fields and the _Valid Suffix
When updating or creating business objects, Ivanti enforces strict relational integrity on validated list fields (like Owner, OwnerTeam, or Status). Frequently, sending just the display name (e.g., Owner: "John Doe") is insufficient or leads to ambiguous data states. The API often requires sending both the display value and the corresponding 32-character ID in a companion field, typically suffixed with _Valid (e.g., Owner_Valid: "5F9B..."). Building an MCP server means you have to expose the employee or team lookup endpoints so the LLM can resolve these _Valid IDs dynamically before attempting a write operation.
OData Syntax and Metadata Discovery
Ivanti exposes its objects primarily through OData endpoints (V1 and V2). This requires passing complex $filter expressions, utilizing $top and $skip for pagination, and sometimes relying on OData EDMX metadata to understand available custom fields. Because Truto dynamically derives MCP tools from documentation records mapped to these endpoints, the LLM is given explicit instructions on how to construct these OData filters without you needing to hand-code translation layers for every custom business object.
A Strict Note on Rate Limits
When making high-frequency OData queries or batch updates, you will encounter Ivanti's rate limits. It is a critical architectural fact that Truto does not retry, throttle, or apply backoff on rate limit errors. When the Ivanti upstream API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (your agent or MCP client) is entirely responsible for reading these headers and implementing its own retry or backoff logic.
How to Create the Truto MCP Server for Ivanti ITSM
Truto's architecture uses a concept called dynamic and documentation-driven tool generation. Instead of hand-coding tool logic for every Ivanti endpoint, Truto generates MCP tools directly from the integration's resource definitions and JSON schemas.
Each MCP server is scoped to a single integrated account (a specific tenant's connected Ivanti instance). The server URL contains a cryptographically hashed token that authenticates the request and scopes the available tools.
You can generate this server via the Truto UI or programmatically via the API.
Method 1: Via the Truto UI
For ad-hoc agent testing or internal IT ops, generating the server through the dashboard is the fastest route.
- Log into your Truto environment and navigate to the Integrated Accounts page.
- Select your connected Ivanti ITSM account.
- Click on the MCP Servers tab.
- Click Create MCP Server.
- Select your desired configuration. You can filter the server to only expose
readtools, restrict it by tags, or set an expiration date. - Copy the generated MCP server URL (e.g.,
https://api.truto.one/mcp/a1b2c3d4...).
Method 2: Via the Truto API
For production workflows where you are provisioning agents for your users programmatically, you should generate the MCP server via the REST API.
Make a POST request to the /integrated-account/:id/mcp endpoint:
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": "Ivanti ITSM Incident Triage Agent",
"config": {
"methods": ["read", "write", "custom"]
}
}'The response will contain the cryptographically secure token URL:
{
"id": "mcp-7a8b9c",
"name": "Ivanti ITSM Incident Triage Agent",
"config": { "methods": ["read", "write", "custom"] },
"expires_at": null,
"url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}How to Connect the MCP Server to Claude
Once you have the URL, connecting it to Claude requires zero additional authentication logic. The token in the URL securely identifies the exact Ivanti tenant and limits the scope of the exposed tools.
Method A: Via the Claude UI (Desktop/Web)
If you are using Claude Desktop or Claude Web (on supported enterprise/team plans), you can attach the server natively:
- Open Claude and navigate to Settings -> Integrations -> Add MCP Server (Note: in ChatGPT this is Settings -> Connectors -> Add).
- Give the connector a name (e.g., "Ivanti IT Desk").
- Paste the Truto MCP URL into the Server URL field.
- Click Add.
Claude will immediately execute the JSON-RPC initialize handshake and query the tools/list endpoint, reading the JSON schemas for all available Ivanti resources.
Method B: Via Manual Config File (Claude Desktop)
If you are configuring Claude Desktop locally for development, you can use the standard claude_desktop_config.json file. Because Truto's MCP servers communicate over HTTP POST via JSON-RPC, you will use the official @modelcontextprotocol/server-sse transport wrapper.
Locate your Claude config file:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json
Add the Truto endpoint under your mcpServers object:
{
"mcpServers": {
"ivanti-itsm": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sse",
"https://api.truto.one/mcp/a1b2c3d4e5f67890"
]
}
}
}Restart Claude Desktop. The server will initialize and load the tools automatically.
Hero Tools for Ivanti ITSM
Truto derives tools dynamically from the underlying proxy API documentation. When the LLM calls a tool, Truto maps the flat JSON arguments into the correct OData query parameters or request body properties.
Here are the highest-leverage tools exposed by the Ivanti ITSM integration.
List All Incidents
Tool name: list_all_ivanti_itsm_incidents
This tool queries the /api/odata/businessobject/incidents endpoint. It is essential for searching existing tickets. It supports standard OData $filter syntax, which allows the LLM to search for incidents by status, owner, or subject. Because the API uses pagination, the LLM is instructed to utilize the $top and $skip properties.
"Find all active incidents assigned to the 'Network Support' team. Return the Subject, RecId, and Status for the top 5 results."
Get Single Incident By ID
Tool name: get_single_ivanti_itsm_incident_by_id
Once the LLM knows the 32-character RecId of a ticket, it uses this tool to fetch the full payload of the incident. This is necessary before performing targeted updates or checking granular custom fields that might not have been returned in a heavily filtered list query.
"Get the full incident details for the ticket with RecId '9A8B7C6D5E4F3A2B1C0D9E8F7A6B5C4D'. What is the current Symptom description?"
Update an Incident By ID
Tool name: update_a_ivanti_itsm_incident_by_id
This tool executes an HTTP PATCH against a specific incident. Because it uses PATCH, the LLM only needs to provide the fields it wants to change. The LLM must be careful to provide valid OwnerTeam strings and, if required by the instance configuration, the matching _Valid RecId.
"Update incident RecId '9A8B7C6D5E4F3A2B1C0D9E8F7A6B5C4D'. Change its Status to 'Resolved' and add a resolution note to the Resolution field."
Get Business Object Metadata
Tool name: list_all_ivanti_itsm_business_object_metadata
This is arguably the most powerful tool for an autonomous agent. Ivanti instances are highly customized. This tool fetches the OData EDMX metadata XML for any business object. The LLM can read this metadata to discover available properties, navigation relationships (useful for finding attached Journal notes), and Quick Action IDs.
"Fetch the business object metadata for the 'Incident' object. I need to find the exact property name for the custom field related to 'Impact Analysis' and find the ActionId for the 'Close Incident' quick action."
Create a Record Action
Tool name: create_a_ivanti_itsm_record_action
Instead of manually patching fields, Ivanti allows you to run predefined "Quick Actions" or templates (e.g., Close_Incident, Accept_Task). This tool triggers those server-side workflows. The LLM must provide the business_object, the record_id, the action_name, and the ActionId (which it can discover via the metadata tool).
"Run the 'Assign to Me' record action on incident RecId '9A8B7C6D5E4F3A2B1C0D9E8F7A6B5C4D'. The ActionId is '1A2B3C4D5E6F'."
List Employees
Tool name: list_all_ivanti_itsm_employees
To properly assign an incident or task, the LLM often needs the employee's RecId to populate a ProfileLink_RecID or Owner_Valid field. This tool queries the employee business object, allowing the model to search by name or email.
"Search the employees list for a user named 'Sarah Connor'. I need her RecId so I can assign an incoming security incident to her."
For the complete inventory of available tools, required properties, and JSON schemas, view the Ivanti ITSM integration page.
Workflows in Action
Here is how an LLM uses these atomic MCP tools to orchestrate complex service desk operations autonomously.
Scenario 1: Autonomous Incident Triage and Assignment
When a user asks Claude to assign a specific ticket, the agent must navigate the RecId lookup process.
"Look up the incident regarding the 'VPN Connection Failure'. Find an employee named 'Alan Turing' and assign the incident to him. Change the status to Active."
flowchart TD
A["Agent Context<br>User Prompt"] --> B["list_all_ivanti_itsm_incidents<br>Search: 'VPN Connection Failure'"]
B --> C["Extract Incident RecId<br>e.g., '1234...'"]
C --> D["list_all_ivanti_itsm_employees<br>Search: 'Alan Turing'"]
D --> E["Extract Employee RecId<br>e.g., 'ABCD...'"]
E --> F["update_a_ivanti_itsm_incident_by_id<br>Patch Status, Owner, Owner_Valid"]
F --> G["Return Success to User"]Step-by-step execution:
- Claude calls
list_all_ivanti_itsm_incidentswith an OData$filteron theSubjectorSymptomfield to locate the ticket and extract itsRecId. - Claude calls
list_all_ivanti_itsm_employeesfiltering forDisplayName eq 'Alan Turing'to extract Alan'sRecId. - Claude calls
update_a_ivanti_itsm_incident_by_idpassing the incidentRecIdin the path, and a body containing{"Status": "Active", "Owner": "Alan Turing", "Owner_Valid": "<Alan's RecId>"}. - The agent returns a natural language summary confirming the assignment.
Scenario 2: Executing a Custom Quick Action
Users often need to trigger complex server-side logic defined by ITSM admins, rather than just changing field values.
"Find the ticket submitted by 'jdoe@example.com' about the server crash. Run the 'Initiate Root Cause Analysis' quick action on it."
Step-by-step execution:
- Claude calls
list_all_ivanti_itsm_incidentsfiltering by the creator's email to get the incident'sRecId. - Claude realizes it needs the
ActionIdfor "Initiate Root Cause Analysis". It callslist_all_ivanti_itsm_business_object_metadatafor theincidentsbusiness object. - The model scans the returned XML/EDMX payload, looking for the
<Action>element matching the requested name, and extracts the corresponding internalActionId. - Claude calls
create_a_ivanti_itsm_record_action, passing thebusiness_object("incidents"), the incidentrecord_id, theaction_name, and theActionId. - The agent confirms to the user that the server-side workflow has been triggered.
Security and Access Control
When connecting an AI agent to a sensitive enterprise system like Ivanti ITSM, you need granular control over what the LLM is allowed to do. Truto enforces security at the MCP token level, long before the request reaches the proxy API.
- Method Filtering: You can configure the MCP server to only allow specific HTTP methods. By setting
"methods": ["read"], you ensure the agent can only call tools mapped togetandlistoperations, preventing it from accidentally deleting or modifying records. - Tag Filtering: Truto allows you to restrict the MCP server to specific functional areas using integration tags. You can expose only
incidenttools while hidingemployeeorfinancetools. - Require API Token Auth: For high-security environments where the MCP URL might be exposed, you can enable
require_api_token_auth. This applies a secondary middleware layer requiring the MCP client to also pass a valid Truto API token in theAuthorizationheader, meaning the URL alone is not enough to access the tools. - Time-to-Live (TTL): By passing an
expires_atISO datetime when creating the server, Truto will automatically clean up the configuration and revoke the KV storage token using a Durable Object alarm when the time expires. This is ideal for granting temporary access to automated auditing agents.
Moving Forward with Agentic Service Management
Connecting Claude to Ivanti ITSM via a managed MCP server transforms your service desk from a static database into an interactive, intelligent agent. By delegating the complexities of OData filtering, RecId lookups, and EDMX metadata parsing to Claude's tool-calling capabilities, IT teams can resolve incidents faster and orchestrate workflows entirely through natural language.
With Truto handling the underlying OAuth lifecycle, proxy API normalization, and dynamic tool generation, your engineering team can focus on designing great AI workflows instead of reading API documentation.
FAQ
- How does Claude handle Ivanti's 32-character RecId requirements?
- Claude handles RecIds by chaining MCP tool calls. When asked to update an incident, it will first use the `list_all_ivanti_itsm_incidents` tool to search for the human-readable incident number and extract the 32-character RecId. It then passes that RecId into the subsequent `update_a_ivanti_itsm_incident_by_id` tool call.
- Does Truto automatically retry when Ivanti ITSM hits rate limits?
- No. Truto does not retry, throttle, or apply backoff on rate limit errors. If the Ivanti API returns an HTTP 429 error, Truto passes it directly to Claude along with standardized IETF rate limit headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The agent is responsible for handling its own retry logic.
- Can I prevent Claude from deleting records in Ivanti?
- Yes. When generating the MCP server URL in Truto, you can configure method filtering by passing `"methods": ["read", "update"]`. This will entirely omit the `delete` tools from the MCP server, making it structurally impossible for the LLM to delete records.
- How do I trigger an Ivanti Quick Action using Claude?
- To trigger a Quick Action, Claude first calls the `list_all_ivanti_itsm_business_object_metadata` tool to discover the specific `ActionId` for the desired workflow. It then passes that ID into the `create_a_ivanti_itsm_record_action` tool to execute the server-side template.