Connect Cloudways to ChatGPT: Manage Servers & App Deployments

If you need to connect Cloudways to ChatGPT so your AI agents can orchestrate server provisioning, trigger application backups, deploy code via Git, and monitor disk usage, you need a Model Context Protocol (MCP) server. If your team uses Claude, check out our guide on connecting Cloudways to Claude or explore our broader architectural overview on connecting Cloudways to AI Agents.

Giving a Large Language Model (LLM) read and write access to a managed cloud hosting platform is a high-stakes engineering challenge. You are exposing actual infrastructure to an agentic workflow. You either spend weeks building, hosting, and maintaining a custom MCP server to map JSON-RPC calls into Cloudways' specific payload structures, or you use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

This guide breaks down exactly how to use Truto to generate a secure MCP server for Cloudways, connect it natively to ChatGPT, and execute complex DevOps workflows using natural language.

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your DevOps AI agents in seconds. :::

The Engineering Reality of the Cloudways API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against the Cloudways API is an exercise in managing state, handling infrastructure fragmentation, and orchestrating multi-step dependent requests.

If you decide to build a custom MCP server for Cloudways, you own the entire API lifecycle. Here are the specific integration challenges that make exposing Cloudways to an LLM difficult:

The Asynchronous Polling Trap

Unlike standard CRUD APIs where a POST request returns a newly created entity, Cloudways relies heavily on asynchronous background jobs. Operations like create_a_cloudways_server, create_a_cloudways_manage_take_backup, or create_a_cloudways_git_pull do not return the final state. Instead, they return an operation_id.

If you hand a generic REST tool to ChatGPT, the model will fire the backup request, see a 200 OK with an operation ID, and falsely assume the backup is complete. Your MCP server must either wrap these endpoints in a blocking polling loop (which risks timing out the LLM connection) or explicitly expose a separate "check operation status" tool, instructing the LLM to write its own polling loop.

The Dual-Layer Dependency Hierarchy

Cloudways structure isolates resources into Servers and Apps. Almost every application-level action (updating PHP versions, managing cron jobs, triggering an app backup, deploying Git) strictly requires both the server_id and the app_id.

This forces a rigid sequence on the LLM. If a user asks "Deploy the latest code to my staging app," the LLM must first search for the app, extract its app_id, realize it also needs the parent server_id, look up the server, and finally construct the deployment payload. If your MCP tools do not properly define these dependencies in their JSON Schema, the LLM will hallucinate IDs or fail validation.

Provider-Specific Infrastructure Fragmentation

Cloudways abstracts multiple underlying IaaS providers (DigitalOcean, AWS, Google Compute Engine, Vultr, Linode), but this abstraction leaks at the API layer. Volume scaling operations (create_a_cloudways_server_scale_volume) only work on Amazon and GCE servers. Block storage attachment (create_a_cloudways_server_attach_storage) is exclusively for DigitalOcean.

An LLM attempting to attach block storage to an AWS instance will fail. Your tool descriptions must explicitly map out these vendor constraints so the agent knows which operations apply to which infrastructure targets.

Generating the Cloudways MCP Server

Truto eliminates the need to build a custom server by dynamically generating tools directly from Cloudways API documentation and exposing them via a managed JSON-RPC endpoint.

First, you must connect Cloudways as an Integrated Account in your Truto environment. Once connected, you can generate an MCP server URL scoped exclusively to that specific Cloudways tenant. You can do this via the Truto UI or programmatically via the API.

Option 1: Via the Truto UI

For ad-hoc DevOps tasks or internal testing, generating the server via the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Cloudways account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your configuration. You can filter by methods (e.g., only allow read operations) or filter by tags (e.g., only expose servers and apps).
6. Click Generate and copy the resulting MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...). Treat this URL as a secret - it contains the authentication token required to execute tools.

Option 2: Via the Truto API

If you are building an automated platform that provisions AI agents dynamically, you can generate MCP servers programmatically.

Make a POST request to the /integrated-account/:id/mcp endpoint using your Truto API token. You can pass a config object to enforce strict access controls on the generated server.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Cloudways Read-Only Agent",
    "config": {
      "methods": ["read"],
      "tags": ["servers", "apps", "analytics"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API returns a database record containing the secure url.

{
  "id": "mcp-abc-123",
  "name": "Cloudways Read-Only Agent",
  "config": { "methods": ["read"], "tags": ["servers", "apps", "analytics"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you need to register it as a tool provider for your LLM. You can do this directly in the ChatGPT interface or via a local configuration file for desktop clients.

Option 1: Via the ChatGPT UI

If you have a ChatGPT Plus, Pro, Team, or Enterprise account with Developer Mode enabled, you can connect remote MCP servers directly in the browser.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on.
3. Under MCP servers / Custom connectors, click Add new server.
4. Enter a descriptive name (e.g., "Cloudways Prod Infra").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately perform an MCP handshake, call the tools/list protocol method, and parse the Cloudways API schemas into usable agent tools.

Option 2: Via Manual Configuration (Desktop/CLI)

If you are running a local agent framework, Claude Desktop, or a custom ChatGPT-compatible client that relies on local configuration files, you can use the official SSE transport package to proxy the connection.

Add the following entry to your MCP configuration file (e.g., mcp-servers.json):

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

Restart your client. The framework will launch the SSE transport script, connect to Truto's JSON-RPC endpoint, and populate the tool list.

Security and Access Control

Exposing production infrastructure to an LLM requires strict boundaries. Truto provides several mechanisms to lock down what the AI agent can do:

• Method Filtering: By passing "methods": ["read"] during server creation, you strip out all POST, PUT, PATCH, and DELETE tools. The LLM can query server status and disk usage, but it cannot delete apps or restart servers.
• Tag Filtering: Use "tags": ["analytics"] to limit the server entirely to read-only metric endpoints, keeping the agent away from core application configuration tools.
• Require API Token Auth: Setting require_api_token_auth: true forces the MCP client to pass a valid Truto API token in the Authorization header. This adds a secondary layer of authentication beyond the tokenized URL.
• Ephemeral Servers (expires_at): You can set an exact ISO datetime for the MCP server to self-destruct. This is critical for granting temporary access during incident response (e.g., giving an agent 2 hours of write access to debug a failing application).

Cloudways Hero Tools for AI Agents

Truto automatically derives tools from the integration's documentation and resource schemas. Here are 7 of the most powerful Cloudways tools your agent can leverage.

list_all_cloudways_servers

Retrieves the complete list of servers attached to the account, including their current status, IP addresses, IaaS provider, and region.

Usage note: This is usually the first tool an agent must call to resolve a natural language request (e.g., "my production server") into the required numeric server_id.

"List all Cloudways servers currently running on my account and show me their public IPs and current health status."

list_all_cloudways_apps

Lists all applications on the account. Crucially, the response data structure maps applications to their parent servers.

Usage note: Agents use this to map an application name (like "Main Corporate WordPress") to its app_id and corresponding server_id for downstream tasks.

"Find the app ID and server ID for the application labeled 'Staging API'."

create_a_cloudways_manage_take_backup

Initiates an on-demand backup of a specific Cloudways application.

Usage note: This is an asynchronous operation. It returns an operation_id. You should instruct your prompt to track this ID if confirmation is required.

"Trigger an immediate backup for the app ID 12345 on server ID 67890. Return the operation ID so we can track it."

create_a_cloudways_git_pull

Pulls the latest commits from a linked Git repository and deploys them to the specified application.

Usage note: If deploy_path is left empty, it defaults to the public_html folder. This is the core tool for agentic CI/CD workflows.

"Deploy the latest code from Git for the 'Frontend Client' app. Use the default public_html deployment path."

list_all_cloudways_monitor_summaries

Retrieves bandwidth or disk usage summaries for an application or server.

Usage note: Requires you to specify the type parameter (e.g., bandwidth). Agents can use this to detect anomalies or compile daily infrastructure reports.

"Get the disk usage monitoring summary for server ID 445566. Is the database drive nearing capacity?"

update_a_cloudways_php_version_by_id

Updates the PHP version running on a specific application.

Usage note: This allows agents to execute routine stack upgrades. It returns an operation_id for tracking the background upgrade process.

"Update the PHP version for app ID 99887 to PHP 8.2."

create_a_cloudways_server_restart

Initiates a full restart of a Cloudways server.

Usage note: Highly destructive in a production environment. This tool should ideally be hidden behind an MCP configuration that restricts write access, or heavily guarded by a "Human-in-the-loop" approval step in your agent logic.

"The monitoring agent reported a memory leak. Restart server ID 112233 immediately."

(To view the complete inventory of available Cloudways operations, schemas, and required parameters, visit the Truto Cloudways integration page.)

Workflows in Action

When you combine these tools inside an LLM, you unlock autonomous infrastructure management. Here are two real-world DevOps scenarios.

Scenario 1: The Automated Incident Responder

When an application experiences severe latency, an IT admin can ask ChatGPT to investigate the server metrics and perform an emergency restart if necessary.

"Check the disk and bandwidth metrics for the 'Analytics DB' server. If it looks stalled, initiate a server restart and tell me the operation ID."

1. ChatGPT calls list_all_cloudways_servers to match the name "Analytics DB" to a server_id.
2. It calls list_all_cloudways_monitor_summaries using that server_id to retrieve recent telemetry.
3. Upon analyzing the JSON response and identifying a spike or stall, it calls create_a_cloudways_server_restart.
4. It returns the resulting operation_id to the user in the chat interface.

sequenceDiagram
    participant User as User (ChatGPT)
    participant Truto as Truto MCP Server
    participant Upstream as Upstream API (Cloudways)

    User->>Truto: Call list_all_cloudways_servers
    Truto->>Upstream: GET /server
    Upstream-->>Truto: { servers: [...] }
    Truto-->>User: [server_id: 10492]

    User->>Truto: Call list_all_cloudways_monitor_summaries
    Truto->>Upstream: GET /server/10492/monitor
    Upstream-->>Truto: { metrics: [...] }
    Truto-->>User: [High load detected]

    User->>Truto: Call create_a_cloudways_server_restart
    Truto->>Upstream: POST /server/10492/restart
    Upstream-->>Truto: { operation_id: 88472 }
    Truto-->>User: "Restart initiated. Operation ID: 88472"

Scenario 2: The Safe Deployment Agent

Deploying code to a staging environment requires a strict order of operations: backup first, then pull code.

"I need to deploy staging. Create a backup for the 'Staging Backend' app, then pull the latest Git branch into it."

1. ChatGPT calls list_all_cloudways_apps to find the app_id and server_id for "Staging Backend".
2. It calls create_a_cloudways_manage_take_backup to secure the current state.
3. It calls create_a_cloudways_git_pull to initiate the code deployment.

Handling Rate Limits

When automating infrastructure, it is easy for an AI agent to fire off dozens of monitoring requests in a tight loop.

Truto does not silently retry, throttle, or apply backoff logic to rate limit errors. If your AI agent exceeds Cloudways' API limits, the upstream API returns an HTTP 429. Truto immediately passes that 429 error back to the caller, normalizing the upstream data into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification.

Your AI framework (e.g., LangChain, AutoGen, or custom application logic) is entirely responsible for reading these headers, pausing execution, and retrying the tool call once the ratelimit-reset window has cleared.

Wrap Up

Building a custom integration layer to expose Cloudways to an LLM requires handling fragmented IaaS logic, resolving asynchronous operation IDs, and enforcing strict security boundaries. By using Truto's documentation-driven MCP generation, you offload the infrastructure maintenance entirely.

You simply connect the account, configure your access filters, and hand the secure URL to ChatGPT.

Ready to give your AI agents secure access to your Cloudways infrastructure? Book a demo to see Truto's auto-generated MCP servers in action. :::