---
title: "Connect Ivanti ITSM to Claude: Sync Incidents and Business Objects"
slug: connect-ivanti-itsm-to-claude-sync-incidents-and-business-objects
date: 2026-11-16
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "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."
tldr: "Connect Claude to Ivanti ITSM using a managed MCP server to automate incident resolution, query OData endpoints, and execute quick actions. Includes full setup instructions and workflow architecture."
canonical: https://truto.one/blog/connect-ivanti-itsm-to-claude-sync-incidents-and-business-objects/
---

# Connect Ivanti ITSM to Claude: Sync Incidents and Business Objects


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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) 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/](https://truto.one/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/](https://truto.one/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.

> Want to give your AI agents secure, authenticated access to Ivanti ITSM and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## 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 `RecId`s 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](https://truto.one/how-do-mcp-servers-auto-generate-tools-from-api-documentation/)**. 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.

1. Log into your Truto environment and navigate to the **Integrated Accounts** page.
2. Select your connected Ivanti ITSM account.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can filter the server to only expose `read` tools, restrict it by tags, or set an expiration date.
6. 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:

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

```json
{
  "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:

1. Open Claude and navigate to **Settings -> Integrations -> Add MCP Server** (Note: in ChatGPT this is Settings -> Connectors -> Add).
2. Give the connector a name (e.g., "Ivanti IT Desk").
3. Paste the Truto MCP URL into the Server URL field.
4. 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:

```json
{
  "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](https://truto.one/integrations/detail/ivantiitsm).

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

```mermaid
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:**
1. Claude calls `list_all_ivanti_itsm_incidents` with an OData `$filter` on the `Subject` or `Symptom` field to locate the ticket and extract its `RecId`.
2. Claude calls `list_all_ivanti_itsm_employees` filtering for `DisplayName eq 'Alan Turing'` to extract Alan's `RecId`.
3. Claude calls `update_a_ivanti_itsm_incident_by_id` passing the incident `RecId` in the path, and a body containing `{"Status": "Active", "Owner": "Alan Turing", "Owner_Valid": "<Alan's RecId>"}`.
4. 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:**
1. Claude calls `list_all_ivanti_itsm_incidents` filtering by the creator's email to get the incident's `RecId`.
2. Claude realizes it needs the `ActionId` for "Initiate Root Cause Analysis". It calls `list_all_ivanti_itsm_business_object_metadata` for the `incidents` business object.
3. The model scans the returned XML/EDMX payload, looking for the `<Action>` element matching the requested name, and extracts the corresponding internal `ActionId`.
4. Claude calls `create_a_ivanti_itsm_record_action`, passing the `business_object` ("incidents"), the incident `record_id`, the `action_name`, and the `ActionId`.
5. 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 to `get` and `list` operations, 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 `incident` tools while hiding `employee` or `finance` tools.
*   **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 the `Authorization` header, meaning the URL alone is not enough to access the tools.
*   **Time-to-Live (TTL):** By passing an `expires_at` ISO 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.
