Connect Rackspace to Claude: Track Events & Automate Support

If your team needs to connect Rackspace to Claude to automate cloud infrastructure support, track ticketing events, or manage resources, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's JSON-RPC tool calls and Rackspace's REST and Atom 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 connecting Rackspace to ChatGPT or explore our broader architectural overview on connecting Rackspace to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling infrastructure provider like Rackspace is an engineering challenge. You have to handle Rackspace's unique Cloud Identity token lifecycles, parse Atom feeds into JSON, and map complex service catalogs to MCP tool definitions. Every time an endpoint changes, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Rackspace, connect it natively to Claude, and execute complex support workflows using natural language.

The Engineering Reality of the Rackspace 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 infrastructure APIs is painful.

If you decide to build a custom Rackspace MCP server, here are the specific integration challenges you will face:

The Cloud Identity Service Catalog Maze

Rackspace does not use standard static API endpoints for all operations. Authentication via the Rackspace Cloud Identity service requires submitting a username and API key to receive an auth token. More importantly, the response includes a massive federated service catalog containing dynamic endpoint URLs mapped by region and service type. An LLM cannot natively resolve these dynamic endpoints. A managed MCP server handles the auth configuration, extracts the correct endpoint from the service catalog, and routes the LLM's payload correctly in the background.

Atom Feeds vs REST JSON

Not all Rackspace data is exposed as clean REST JSON. Consolidated ticketing and infrastructure events are exposed via CloudFeeds, which uses the Atom syndication format (XML). If you expose raw XML to Claude, you waste valuable context window tokens and increase hallucination rates on parsing. Truto normalizes the CloudFeeds Atom feed into a clean JSON schema so tools like list_all_rackspace_ticket_events return structured, predictable arrays for the model.

Multi-Step File Attachments

Uploading an attachment to a support ticket in Rackspace is not a single API call. You must first request an upload URL, submit the file via multipart form data, receive an expiring UUID, and then execute a subsequent ticket update call injecting that UUID. AI models struggle with orchestrating strict multi-step ephemeral states. Managed tools define exact required parameters (like passing the UUID into the ticket comment payload) to guarantee the operation succeeds.

Hard 429 Rate Limits

Rackspace enforces strict API rate limits across its infrastructure endpoints. It is important to understand that Truto does not retry, throttle, or apply automatic backoff on rate limit errors. When the upstream Rackspace API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your LLM agent or MCP client is responsible for reading these headers and executing its own backoff strategy.

Step 1: Generate the Rackspace MCP Server

Truto derives MCP tools dynamically from your connected Rackspace account's documentation and resource schemas. A tool only appears in the MCP server if it has a corresponding documentation record, acting as a strict quality gate. Tools are never cached - they are built on-the-fly during the tools/list initialization.

You can generate the MCP server URL using either the Truto UI or the API.

Method A: Via the Truto UI

1. Log into your Truto dashboard and navigate to the integrated account page for your Rackspace connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (name, allowed methods, tags, and expiration).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method B: Via the API

You can programmatically generate servers for your own users by making a POST request. The API validates the integration, generates a secure token, and returns a ready-to-use URL.

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": "Rackspace Support Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'

The response contains the URL required for the MCP client:

{
  "id": "abc-123",
  "name": "Rackspace Support Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Step 2: Connect the MCP Server to Claude

Once you have the Truto MCP URL, you connect it to Claude. The URL alone contains the cryptographic token that encodes the integrated account and tool permissions. You can connect it via Claude's UI or via manual configuration files.

Method A: Via the Claude UI

1. Open Claude Desktop (or your web workspace if supported).
2. Navigate to Settings -> Integrations (or Developer settings depending on your tier) -> Add MCP Server.
3. Paste the Truto MCP URL.
4. Click Add. Claude will instantly execute the handshake and list the Rackspace tools.

Method B: Via Manual Configuration File

For local agent development using Claude Desktop, you can map the Server-Sent Events (SSE) transport using the official MCP CLI tool. Open your claude_desktop_config.json file (located in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add:

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

Restart Claude Desktop. The tools will now be available in the chat interface.

Rackspace Hero Tools for Claude

When Claude lists tools from the server, all query parameters and body schemas are flattened into a single JSON-RPC argument namespace. The Truto router handles separating the arguments and routing them to the correct upstream Rackspace API request.

Here are the highest-leverage operations for infrastructure support automation.

list_all_rackspace_accounts

Retrieves all Rackspace accounts available to the authenticated user. This is critical for getting the accountId needed for cross-account ticketing operations and infrastructure queries.

"Claude, list all Rackspace accounts I have access to. Filter the response to show me the names, account IDs, and the current service level for each."

list_all_rackspace_tickets

Audits the current support ticket queue. Claude automatically handles pagination via the limit and next_cursor parameters injected by Truto.

"Fetch the last 20 open support tickets for account ID 987654. Summarize the subject, severity, and current status of each ticket in a markdown table."

create_a_rackspace_ticket

Generates a new Rackspace support ticket. The tool schema enforces required fields like accountId, subject, category, and comment.text to prevent validation errors.

"Create an urgent severity support ticket for account ID 987654. The subject is 'Database Node Unresponsive'. Use the 'Cloud Servers' category and 'Performance' subcategory. Add a comment explaining that node DB-04 has dropped all connections for the past 15 minutes."

rackspace_tickets_add_comment

Appends a new comment to an existing ticket, useful for keeping Rackspace support engineers updated on internal investigations.

"Add a comment to ticket ID 11223344. Tell support that we have tried rebooting the load balancer on our end, but traffic is still failing health checks. Ask them to verify the edge routing rules."

list_all_rackspace_ticket_events

Reads the CloudFeeds Atom feed and returns normalized ticketing events. This allows Claude to track state changes and support replies without polling individual tickets.

"Check the ticket events feed for account ID 987654. Are there any new updates published in the last 4 hours regarding ticket 11223344?"

list_all_rackspace_resources

Queries the infrastructure resources the user has access to. This helps Claude map failing server hostnames to their exact Rackspace resource IDs before creating a ticket.

"List all Rackspace resources for account ID 987654. Find the resource ID that matches the server named 'prod-db-cluster-node-2'."

To see the full schema requirements and the complete tool inventory, visit the Rackspace integration page.

Workflows in Action

AI agents excel at orchestrating multi-step API workflows. Here is how Claude uses the Rackspace MCP tools to resolve complex support scenarios.

Workflow 1: Triage and Escalate Cloud Alerts

When a monitoring system fires an alert, a human normally has to log into Rackspace, look up the server ID, and manually file a ticket. Claude can automate this triage process.

"An alert just fired for high latency on the 'payment-gateway-app' server. Look up its resource ID in Rackspace, check if there are any existing open tickets for it, and if not, create a high-severity support ticket asking for a network route trace."

flowchart TD
    A["Claude analyzes<br>user prompt"] --> B["list_all_rackspace_resources<br>(Search for server name)"]
    B --> C["list_all_rackspace_tickets<br>(Check for duplicates)"]
    C --> D{Existing<br>ticket found?}
    D -->|Yes| E["rackspace_tickets_add_comment<br>(Update with new alert)"]
    D -->|No| F["create_a_rackspace_ticket<br>(File high-severity ticket)"]
    E --> G["Return summary<br>to user"]
    F --> G

Execution Steps:

1. Claude calls list_all_rackspace_resources to find the exact ID and location metadata for the 'payment-gateway-app' server.
2. It calls list_all_rackspace_tickets filtering by the account ID to ensure a teammate has not already reported the outage.
3. Seeing no existing ticket, it calls create_a_rackspace_ticket with the server details embedded in the comment payload.
4. Claude replies to the user with the newly created ticket ID and link.

Workflow 2: Automated Status Auditing

Support engineers waste hours manually checking ticket updates. Claude can audit the event feed and compile a brief.

"Review the Rackspace ticket events feed for account ID 987654. Identify any tickets that Rackspace support updated in the last 24 hours, read the latest comment on each, and give me a summary of what they need from us."

sequenceDiagram
    participant User
    participant Claude Desktop
    participant Upstream as "Rackspace API"

    User->>Claude Desktop: "Review ticket events..."
    Claude Desktop->>Upstream: list_all_rackspace_ticket_events
    Upstream-->>Claude Desktop: Returns recent CloudFeeds data
    
    rect rgb(245, 245, 245)
    Note over Claude Desktop,Upstream: Loop over recently updated tickets
    Claude Desktop->>Upstream: get_single_rackspace_ticket_by_id (Ticket A)
    Upstream-->>Claude Desktop: Returns Ticket A comments
    Claude Desktop->>Upstream: get_single_rackspace_ticket_by_id (Ticket B)
    Upstream-->>Claude Desktop: Returns Ticket B comments
    end

    Claude Desktop->>User: Renders summary of pending action items

Execution Steps:

1. Claude calls list_all_rackspace_ticket_events to retrieve the normalized Atom feed data.
2. It analyzes the timestamps in the payload to isolate events from the last 24 hours.
3. For each active event, it extracts the ticket ID and calls get_single_rackspace_ticket_by_id to read the full comment thread.
4. It synthesizes the support engineers' replies into actionable bullet points for the team.

Security and Access Control

Exposing root-level infrastructure tools to an LLM requires strict boundary control. Truto MCP servers allow you to define exact guardrails:

• Method Filtering: Restrict an MCP server to read-only operations. By setting methods: ["read"] during creation, you prevent Claude from executing create, update, or delete tools, mitigating accidental infrastructure changes.
• Tag Filtering: Group operations by business domain. You can restrict the server using tags: ["support"] to only expose ticketing endpoints, hiding underlying billing or compute APIs.
• Expiration Controls: Assign an expires_at ISO datetime. Truto automatically schedules a Durable Object alarm to destroy the token and KV entries exactly when the time expires - perfect for granting contractor access.
• Double Authentication: Enable require_api_token_auth: true to force the MCP client to pass a valid Truto API token in the headers, adding a layer of identity verification beyond URL possession.

Connect Your Cloud Stack to Claude

Building an MCP server for Rackspace from scratch forces you to manage Cloud Identity federation, Atom feed parsers, and multi-step file uploads. It distracts your engineering team from building your actual product.

Truto’s managed MCP infrastructure handles token lifecycles, normalizes complex data models, and dynamically auto-generates schema-accurate tools. Your AI agents get immediate, secure access to the exact APIs they need to automate support tasks, without maintaining a single line of integration code.