---
title: "Connect Atomicwork to ChatGPT: Manage Service Requests & IT Assets"
slug: connect-atomicwork-to-chatgpt-manage-service-requests-it-assets
date: 2026-06-08
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Atomicwork to ChatGPT using a managed MCP server. Automate IT service requests, asset management, and change workflows with AI."
tldr: "A comprehensive engineering guide on building an Atomicwork MCP server to give ChatGPT secure, read-write access to ITSM data. Covers dynamic form fields, rate limit handling, and automated asset provisioning."
canonical: https://truto.one/blog/connect-atomicwork-to-chatgpt-manage-service-requests-it-assets/
---

# Connect Atomicwork to ChatGPT: Manage Service Requests & IT Assets


If your team needs to connect Atomicwork to ChatGPT to automate employee support, resolve IT tickets, and provision assets, you need a [Model Context Protocol (MCP)](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms) server. This server acts as the translation layer between ChatGPT's native tool calls and Atomicwork's REST APIs. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide). If your team uses custom AI Agents, check out our guide on [connecting Atomicwork to AI Agents](https://truto.one/connect-atomicwork-to-ai-agents-sync-service-catalogs-user-data/).

Giving a Large Language Model (LLM) read and write access to a complex IT Service Management (ITSM) platform is an engineering challenge. You must handle contextual workspace boundaries, map dynamic custom form schemas to MCP tool definitions, and deal with strict rate limits. Every time Atomicwork updates an endpoint or an IT admin modifies a service catalog template, your integration has to adapt. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Atomicwork, connect it natively to ChatGPT, and execute complex ITSM workflows using natural language.

## The Engineering Reality of the Atomicwork 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 vendor APIs is difficult. If you decide to [build a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026) for Atomicwork, you own the entire API lifecycle. 

Here are the specific integration challenges that break standard CRUD assumptions when working with Atomicwork:

### Workspace Isolation and Context Propagation
Atomicwork relies heavily on the concept of workspaces. Almost every critical operation - listing requests, pulling service catalog items, finding user lists - requires a `workspace_id`. If an LLM needs to look up a ticket and then check the requester's department, your MCP server must strictly propagate this `workspace_id` across every subsequent tool call. Failing to inject this context results in 404 errors, causing the LLM to hallucinate that the record does not exist.

### Dynamic Form Schemas and Asset Types
Creating a service request or an IT asset in Atomicwork is not a simple POST request with a static JSON body. The API relies on dynamic forms. To provision a laptop, you must provide `asset_type_id` and an array of `form_fields` (display_name, serial_number, status). These fields change depending on how the IT admin configured the specific asset type. Your MCP server must expose tools that allow the LLM to read the schema (`list_all_atomicwork_forms_requests`) before attempting the write operation. If your tool schemas are static, write operations will fail the moment an admin adds a new required field.

### Multipart Uploads for Change Management
Creating change management records or adding attachments to a service request often requires multipart form data payloads. The LLM understands JSON natively, but it cannot encode binary file buffers or construct multipart boundaries. Your integration layer has to accept standard JSON arguments from the LLM, fetch the remote file reference, and translate it into a valid multipart payload for the Atomicwork API. 

### Strict Rate Limiting and HTTP 429s
When an LLM attempts to analyze dozens of tickets or batch-update asset statuses, it will hit Atomicwork's rate limits. It is critical to understand how Truto handles this: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When Atomicwork returns an HTTP 429, 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 specification. The LLM client or [agent framework](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck) is entirely responsible for reading these headers and executing exponential backoff. Do not expect the infrastructure to absorb these limits for you.

## How to Generate the Atomicwork MCP Server

Instead of building out OAuth handlers, schema mappers, and tool routing logic from scratch, you can use Truto to expose your connected Atomicwork instance as a fully functional MCP server. Truto dynamically generates these tools from Atomicwork's underlying resources and your configured API documentation.

You can generate an MCP server in two ways: via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

This is the fastest method for internal teams and support admins who just want to wire up their own ChatGPT interface.

1. Log into your Truto account and navigate to the integrated account page for your specific Atomicwork connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can filter the server to only allow specific methods (like `read` only) or specific resource tags (like `assets` or `requests`).
5. Copy the generated MCP server URL. This URL contains a secure cryptographic token that routes requests to your specific integrated account.

### Method 2: Via the Truto API

If you are provisioning AI capabilities for your end-users within your own SaaS product, you should use the API to generate temporary, scoped MCP servers programmatically.

Make an authenticated `POST` request to `/integrated-account/:id/mcp`.

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_ATOMICWORK_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Atomicwork ITSM Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["requests", "assets", "change_management"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API returns a payload containing your unique `url`. 

```json
{
  "id": "mcp_abc123",
  "name": "Atomicwork ITSM Server",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/TOKEN_STRING"
}
```

This URL handles all protocol handshakes and tool execution over JSON-RPC 2.0. 

## How to Connect the MCP Server to ChatGPT

Once you have the Truto MCP server URL, you must register it with your LLM client. You can do this through standard UI settings or via a configuration file for custom agent setups.

### Method A: Via the ChatGPT UI

For enterprise users leveraging ChatGPT directly:

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP features are gated behind this toggle).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "Atomicwork ITSM").
5. Paste the Truto MCP URL into the Server URL field.
6. Click **Add**. 

ChatGPT will immediately initialize the connection, call the `tools/list` protocol method, and render the available Atomicwork tools to the model.

*(Note: If your team uses Claude Desktop, navigate to Settings -> Integrations -> Add MCP Server, paste the URL, and click Add.)*

### Method B: Via Manual Configuration File (SSE Client)

If you are running headless AI agents or local developer environments (like Cursor or custom LangChain scripts), you can configure the connection via a standard JSON configuration file. Truto provides an SSE (Server-Sent Events) transport command to bridge standard I/O to remote HTTP MCP endpoints.

Create or update your `mcp-servers.json` file:

```json
{
  "mcpServers": {
    "atomicwork": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/TOKEN_STRING"
      ]
    }
  }
}
```

This command establishes a persistent connection to the Truto MCP router, allowing your agent to stream tool calls and receive paginated API responses.

## Atomicwork Hero Tools for AI Agents

When connected, your AI agent has access to all documented Atomicwork REST API endpoints translated into strict JSON Schema tools. In the MCP architecture, the query parameters and body payloads are merged into a single flat input namespace. The MCP router handles unpacking this and routing the arguments correctly. 

Here are the highest-leverage operations your agent can perform.

### Search Service Requests
**Tool Name:** `list_all_atomicwork_requests_search`

Retrieves and filters requests within a specific workspace. This is the primary entry point for agents triaging the queue. It supports searching by keyword, status, and requester.

> "Find all open service requests in the engineering workspace related to VPN access issues created in the last 48 hours."

### Fetch Full Request Details
**Tool Name:** `get_single_atomicwork_requests_id_by_id`

Once the agent has the `id` from the search tool, it must use this tool to retrieve the complete metadata, custom fields, and timeline of the ticket. 

> "Get the full details and current status for request ID req_98765 in workspace ws_12345."

### Update Request Activity Notes
**Tool Name:** `create_a_atomicwork_request_activity_note`

Allows the AI agent to update the end-user or leave internal notes for human agents. This is essential for automated triage workflows where the LLM resolves Tier 1 issues and logs the solution.

> "Add a public activity note to request display_id IT-402 explaining that their software license has been successfully provisioned, and mark the note as resolved-attempt."

### Search IT Assets
**Tool Name:** `list_all_atomicwork_assets_search`

Queries the asset inventory. The agent can use this to determine who holds a specific device, check warranty status, or verify if stock is available for a new hire.

> "Search the asset database for any unassigned MacBook Pro M3 laptops currently marked as 'In Stock'."

### Provision IT Assets
**Tool Name:** `create_a_atomicwork_asset`

Registers a new asset in the system. The agent must pass the `asset_type_id` and the specific `form_fields` dictated by the asset template. 

> "Create a new asset record for a Dell XPS 15. The serial number is SN-998877, assign it to user ID usr_555, and set the status to 'Deployed'."

### Initiate Change Management
**Tool Name:** `create_a_atomicwork_change_management_change`

ITSM compliance requires change records for infrastructure modifications. This tool allows the LLM to draft a formal change request, populating impact, urgency, and rollout plans.

> "Draft a new change management record. The subject is 'Emergency Database Patching'. Set the change type to 'Standard', urgency to 'High', and list the requester as user ID usr_999."

To view the complete inventory of available Atomicwork tools, including schema definitions for audit logs, user lists, and assessment forms, visit the [Atomicwork integration page](https://truto.one/integrations/detail/atomicwork).

## Workflows in Action

Giving an LLM raw API endpoints is only half the battle. The real value is orchestrating multi-step workflows autonomously. Here is how specific ITSM personas use these tools in production.

### Scenario 1: Automated Asset Provisioning and Ticket Resolution
**Persona:** IT Service Desk Agent  
**Trigger:** A new employee submits a ticket requesting a standard developer laptop.

> "Check request IT-805. Verify if we have any unassigned MacBook Pros in stock. If we do, assign one to the requester, update the asset database, and add a note to the ticket saying their laptop is ready for pickup."

**Agent Execution Sequence:**
1.  **`get_single_atomicwork_requests_id_by_id`**: The agent fetches the request to find the user's ID and exact equipment requirement.
2.  **`list_all_atomicwork_assets_search`**: The agent queries the asset database filtering for `status: 'in_stock'` and `model: 'MacBook Pro'`.
3.  **`update_a_atomicwork_assets_id_by_id`**: The agent updates the selected asset record, changing the status to `deployed` and inserting the user's ID into the `assigned_to` field.
4.  **`create_a_atomicwork_request_activity_note`**: The agent adds a note to the original request to inform the employee and closes the ticket loop.

**Result:** The LLM successfully provisions hardware without human intervention, maintaining perfect data hygiene in the asset registry.

### Scenario 2: Emergency Change Management Triage
**Persona:** Site Reliability Engineer (SRE)  
**Trigger:** Multiple alerts fire regarding a critical service degradation.

> "Find any critical service requests submitted in the last hour regarding the payment gateway. If there are multiple, draft an emergency change management record to rollback the latest deployment, link the affected request IDs, and set the impact to 'Company-wide'."

**Agent Execution Sequence:**
1.  **`list_all_atomicwork_requests_search`**: The agent searches for requests matching the keyword 'payment gateway' with a priority of 'Critical'.
2.  **`list_all_atomicwork_forms_requests`**: The agent quickly checks the expected dynamic schema for the 'Emergency Change' form type.
3.  **`create_a_atomicwork_change_management_change`**: The agent constructs the complex JSON payload, populating `urgency`, `impact`, the rollback plan in the custom fields, and appending the request IDs it found in step one.

**Result:** A formal, audit-compliant ITSM record is generated in seconds, allowing the SRE team to focus on resolving the actual technical incident rather than filling out paperwork.

## Security and Access Control

Exposing an ITSM platform to an autonomous AI agent carries significant security implications. Truto provides strict governance controls at the token level, ensuring your agents only have access to the data they need.

*   **Method Filtering (`config.methods`):** You can restrict an MCP server to strictly read-only operations. By passing `methods: ["read"]`, the server will refuse to generate tools for `create`, `update`, or `delete` endpoints, physically preventing the LLM from mutating data.
*   **Tag Filtering (`config.tags`):** You can limit the domain scope of the server. By passing `tags: ["assets"]`, the LLM will only see tools related to IT asset management, completely isolating it from sensitive HR or payroll tickets.
*   **Enforced API Token Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. By enabling this flag, the client must also provide a valid Truto API token via a standard `Authorization: Bearer` header. This ensures internal URLs leaked in logs cannot be exploited by unauthorized personnel.
*   **Ephemeral Servers (`expires_at`):** You can grant temporary access by setting an ISO datetime expiration. Once the clock strikes, the token is automatically wiped from distributed storage, and all subsequent tool calls are rejected.

## Final Thoughts

Connecting ChatGPT to Atomicwork transforms your LLM from a passive knowledge base into an active IT operations engine. Rather than teaching engineers how to write custom schema parsers and OAuth handlers, relying on dynamically generated MCP tools ensures your integration adapts to Atomicwork API updates automatically.

By carefully scoping your MCP server tokens and instructing your LLM to handle 429 rate limit backoffs properly, you can deploy enterprise-grade ITSM automation in hours, not months. Stop writing boilerplate integration code, and start writing workflows.

> Want to embed AI tool-calling for Atomicwork natively inside your SaaS product? Talk to our engineering team about SuperAI.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)