Connect SolarWinds Service Desk to ChatGPT: Manage Incident Workflows

If you need to connect SolarWinds Service Desk to ChatGPT to automate IT operations, triage incoming support tickets, or manage asset workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's native tool calling capabilities and SolarWinds Service Desk's REST APIs. If your team uses Claude, check out our guide on connecting SolarWinds Service Desk to Claude or explore our broader architectural overview on connecting SolarWinds Service Desk to AI Agents.

Giving a Large Language Model (LLM) read and write access to an IT Service Management (ITSM) platform is an engineering challenge. Incident records are not flat database rows. They are complex graphs of assignees, requesters, nested comments, and specific Service Level Agreement (SLA) timers. You have to handle API rate limits, map dense incident objects into LLM-friendly schemas, and ensure that the AI does not hallucinate state changes.

You can either spend weeks building, hosting, and maintaining this infrastructure yourself, or use a managed integration layer to dynamically generate a secure, authenticated MCP server URL. This guide breaks down exactly how to use Truto to generate an MCP server for SolarWinds Service Desk, connect it natively to ChatGPT, and execute complex support workflows using natural language.

The Engineering Reality of the SolarWinds Service Desk API

A custom MCP server is a self-hosted API gateway that translates an LLM's JSON-RPC tool calls into vendor-specific REST requests. While the MCP standard provides a predictable way for models to discover tools, implementing it against the actual SolarWinds Service Desk API introduces strict architectural requirements.

If you decide to build a custom MCP server, you are responsible for the entire integration lifecycle. Here are the specific engineering challenges that break generic CRUD assumptions when working with SolarWinds Service Desk:

The Layout Expansion Problem

SolarWinds Service Desk heavily relies on a layout query parameter to control the density of API responses. If you call a standard endpoint like GET /api/v1/incidents/:id, the API returns a shallow object. Related entities - like the user who requested the ticket, the assigned IT staff, historical comments, and attached files - are returned as bare IDs or omitted entirely. To get the actual context an LLM needs to make a decision, your server must inject layout=detailed or specify exact sub-resources. If your MCP tools do not properly instruct the LLM on how to use the layout schema, the agent will operate blindly and hallucinate context.

Hard HTTP 429 Rate Limits

IT environments are noisy. If your AI agent attempts to run a bulk triage loop on 50 open incidents at once, SolarWinds Service Desk will aggressively throttle the connection and return 429 Too Many Requests. This is a critical architectural boundary. Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns 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 - your agent framework or the ChatGPT client - is strictly responsible for interpreting these headers and executing exponential backoff.

Flat Input Namespaces vs Nested JSON Bodies

When an MCP client calls a tool, all arguments arrive as a single flat JSON object. However, creating a SolarWinds Service Desk incident requires a highly structured nested JSON payload containing specific IDs for categories, subcategories, and custom field maps. Your MCP routing layer must be capable of dynamically splitting the LLM's flat input namespace into the exact query parameters and nested body schemas demanded by the vendor API.

How to Generate an MCP Server for SolarWinds Service Desk

Instead of writing and hosting the JSON-RPC protocol handling logic, you can use Truto to generate a fully managed MCP server. This server is dynamically derived from the underlying integration documentation records, meaning tools are only exposed if they have strict schema definitions attached. The server URL acts as a self-contained authentication token.

You can create this server in two ways.

Method 1: Via the Truto UI

For teams who want to spin up an environment quickly, you can generate the server directly from the dashboard.

1. Log into Truto and navigate to the Integrated Accounts page for your connected SolarWinds Service Desk instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can assign a human-readable name, filter allowed methods (e.g., read-only), and set an optional expiration date.
5. Click save and copy the generated MCP server URL.

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically for your users. The API validates the integration, generates a secure hashed token, stores the routing state in a distributed key-value store, and returns a ready-to-use URL.

Make a POST request to /integrated-account/:id/mcp.

const response = await fetch('https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "SolarWinds IT Triage Server",
    config: { 
      methods: ["read", "write"], 
      tags: ["incident-management"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); 
// Returns: https://api.truto.one/mcp/a1b2c3d4e5f6...

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you simply pass it to the ChatGPT client. The URL itself contains the secure routing token, meaning you do not need to configure OAuth or API keys inside the LLM interface.

Method A: Via the ChatGPT UI

If you are using ChatGPT Plus, Pro, or Enterprise, you can connect the server natively through the application settings.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (custom MCP support requires this flag to be active).
3. Under the MCP servers or Custom connectors section, click to add a new server.
4. Name: Enter a recognizable label like "SolarWinds Service Desk".
5. Server URL: Paste the Truto MCP URL generated in the previous step.
6. Click Save. ChatGPT will immediately perform a handshake, run the tools/list protocol, and expose the integration to your prompt interface.

Method B: Via Manual Config File

If you are connecting via a local agent framework or standardizing deployments across developer machines, you can define the connection via a standard JSON configuration file using the Server-Sent Events (SSE) transport wrapper.

Create an mcp_config.json file in your project directory:

{
  "mcpServers": {
    "solarwinds-service-desk": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

When your MCP client initializes, it executes the wrapper, connects to the remote Truto URL over HTTPS, and streams the JSON-RPC tool schemas securely to the context window.

Hero Tools for Incident Management

Truto dynamically derives MCP tools directly from the SolarWinds Service Desk integration schemas. Here are the highest-leverage tools available for IT operations.

List All Incidents

list_all_solar_winds_service_desk_incidents

This tool retrieves a paginated list of tickets. Because the API returns minimal data by default, you should instruct the LLM to use the layout query parameter to fetch expanded details.

"Fetch the 10 most recent SolarWinds Service Desk incidents. Pass 'layout' as 'detailed' in the query so I can see the assignee names and categories. Provide a bulleted summary of their statuses."

Get Single Incident by ID

get_single_solar_winds_service_desk_incident_by_id

When an alert fires or a user reports an issue, the LLM needs to drill into the specific record. This tool fetches the complete JSON graph for a single ticket, including custom fields and resolution timers.

"Get the full details for incident ID 84029. Tell me who requested it, what department they are in, and how long the ticket has been in the 'Awaiting User' state."

Create an Incident

create_a_solar_winds_service_desk_incident

Allows the LLM to generate new tickets on behalf of users or automated monitoring systems. It requires the LLM to assemble the complex JSON body required by the platform.

"Create a new high-priority incident for a database connection failure. Set the requester to 'system-alerts@example.com', set the category to 'Infrastructure', and the subcategory to 'Database'."

Update an Incident

update_a_solar_winds_service_desk_incident_by_id

Used for modifying ticket state, changing assignees, or escalating priorities. This is the primary execution vector for automated triage workflows.

"Update incident ID 84030. Change its state to 'Resolved' and update the assigned group ID to 105 (Network Engineering)."

Create a Comment

create_a_solar_winds_service_desk_comment

Communication is the core of ITSM. This tool allows the AI to add internal work notes or public replies to an existing ticket without altering its core state.

"Add a public comment to incident ID 84031 that says: 'We have identified the VPN routing issue and are currently restarting the primary gateway. Next update in 15 minutes.'"

Download Attachments

solar_winds_service_desk_attachments_download

Users frequently attach screenshots, log files, or error reports to tickets. This tool handles the specific binary retrieval logic required to access files linked to an incident.

"Download the attachment associated with incident ID 84032. Extract the text from the provided error log and explain why the Active Directory sync failed."

For the complete tool inventory and granular schema details, review the SolarWinds Service Desk integration page.

Workflows in Action

Exposing individual tools to ChatGPT is useful, but the real value lies in orchestrating multi-step workflows. Here is exactly how an AI agent uses these tools in the real world.

Scenario 1: Level 1 IT Triage Automation

An IT administrator wants ChatGPT to act as a Level 1 dispatcher, reading incoming tickets, acknowledging them, and routing them to the correct department.

"Check all unassigned incidents created in the last hour. For each ticket, read the description. If it mentions 'VPN' or 'connectivity', add a comment acknowledging the issue and assign the incident to the Network team."

Step-by-step execution:

1. The agent calls list_all_solar_winds_service_desk_incidents using specific query parameters to filter for unassigned status and a recent creation date.
2. The agent loops through the returned JSON array, analyzing the text of each description.
3. For matching tickets, it calls create_a_solar_winds_service_desk_comment with a polite, standardized response.
4. Finally, it calls update_a_solar_winds_service_desk_incident_by_id to alter the group assignment ID on the ticket.

Result: The user gets a plain text confirmation in the chat interface summarizing which tickets were routed and which were ignored, saving the IT staff 30 minutes of manual clicking.

Scenario 2: Major Incident Post-Mortem Prep

A DevOps engineer needs to gather context on a resolved P1 incident to write a post-mortem document.

"I need to write a post-mortem for incident #10425. Fetch the incident details, list all the comments in chronological order, and summarize the timeline of how the issue was diagnosed and resolved."

Step-by-step execution:

1. The agent calls get_single_solar_winds_service_desk_incident_by_id, passing layout=detailed to ensure comments and history are included in the payload.
2. The agent reads the nested comment graph, parsing the timestamps and author identities.
3. The agent synthesizes the raw JSON logs into a coherent narrative text block within the ChatGPT interface.

Result: The engineer receives a ready-to-paste chronological timeline of the outage, completely bypassing the need to read through dozens of manual ticket notes.

Security and Access Control

Giving an LLM write access to an ITSM platform requires strict security boundaries. Truto MCP servers enforce configuration filters at the proxy level, ensuring the LLM cannot physically execute unauthorized operations.

• Method Filtering: You can restrict a server using config.methods. Setting this to ["read"] drops all POST, PUT, and DELETE operations. The LLM can view tickets but cannot alter them, preventing accidental record deletion.
• Tag Filtering: By passing config.tags: ["incidents"], you can limit the server to a specific operational domain, ensuring the agent cannot access unrelated endpoints like HR service catalogs or financial asset registers.
• Additional Authentication: Setting require_api_token_auth: true forces the client to pass a valid Truto API token in the Authorization header alongside the MCP URL. This protects the server even if the URL is leaked in internal documentation.
• Time-to-Live Expire: Passing an ISO datetime to expires_at ensures the server automatically self-destructs. The distributed key-value entries are purged, instantly revoking the LLM's access to SolarWinds Service Desk without requiring manual key rotation.

Automating your IT service management does not require maintaining endless integration scripts. By mapping the SolarWinds Service Desk API to the Model Context Protocol, you can shift the burden of triage, tracking, and communication directly to ChatGPT.