
What is an MCP server? How one works, with a real example
American Cloud
American Cloud Team
An MCP server is a program that gives an AI app like Claude, ChatGPT or Cursor a list of tools it can call, such as "list my servers", "price this cluster" or "add a DNS record". It speaks the Model Context Protocol, an open standard Anthropic released in November 2024, so one server works with every app that supports the protocol.
That's the whole idea. What the AI can actually do with it comes down to two details: where the program runs and whose credentials it holds.
How does an MCP server work?
The protocol has three roles. The host is the AI app you talk to. Inside it, a client keeps one connection to one server. The server is the program that offers the tools.
A server can offer three kinds of things. Tools are functions the model can run. Resources are data the app can read, like a file or a database record. Prompts are templates a user can pick. The servers people talk about are mostly tools.
When the app connects, it asks the server for its tool list. Each entry has a name, a plain-English description and the arguments it takes. The model reads those descriptions, and when your question needs one, it asks the app to call that tool. The server runs it and sends back the result. Every message is JSON-RPC 2.0.
Here's one real entry from our server's tool list, as the app receives it (from @americancloud/mcp 0.9.2; arguments left out):
{
"name": "get_cost_estimate_kubernetes",
"title": "Get Kubernetes cost estimate",
"description": "Preview the price of a Kubernetes cluster configuration without creating it. Takes the same arguments as create_kubernetes_cluster.",
"annotations": {
"title": "Get Kubernetes cost estimate",
"readOnlyHint": true,
"destructiveHint": false,
"idempotentHint": true,
"openWorldHint": true
}
}That description is what the model reads. It says what the tool does and where its arguments come from, so the model can chain calls on its own: find the packages, check the versions, then price the cluster.
Is an MCP server a real server?
Sometimes. A remote MCP server is a real server, run by whoever publishes it. A local one is a small program on your laptop that only looks like a server to the app. The protocol defines a transport for each.
A local server is started by your AI app on your own computer. The two talk over stdio, the program's standard input and output, so there's no network port and no web server. It usually serves one app. Our local server is the open-source package @americancloud/mcp: your app runs it with npx, and it reads an American Cloud API token from your config. The token goes from your machine straight to our API.
A remote server is a web service. The app sends each message as an HTTP POST to one address, which the spec calls Streamable HTTP, and one server handles many users. Ours is at https://mcp.americancloud.com/mcp. You paste that address into your app and sign in to American Cloud in your browser. Your app never sees a token. From then on it acts as you, and it can do what your American Cloud role allows and nothing more.
What's inside a real MCP server?
Mostly a long list of tools. Ours has 179, in seven groups:
| Group | Tools | What they cover |
|---|---|---|
| Networking | 57 | Networks and VPCs, public IPs, firewall, port forwarding, load balancers, ACLs |
| Databases | 36 | Managed PostgreSQL, MySQL and Redis, backups |
| Storage | 27 | Block storage, snapshots, object storage buckets and keys |
| Compute | 25 | VMs, sizes, images, regions, SSH keys |
| WordPress | 16 | Managed WordPress sites |
| Kubernetes | 11 | Clusters, node sizes, versions, scaling |
| DNS | 7 | Zones and records |
Some tools read, like list_vms or list_firewall_rules. Some change things, like create_vm, scale_vm or create_dns_record. Every tool carries hints that say which kind it is: readOnlyHint means it changes nothing, and destructiveHint means it may change or remove something that already exists. Apps use them to decide when to ask you first. The spec calls them hints, though, so an app should trust them only if it trusts the server.
What's the difference between an MCP server and an API?
An MCP server usually sits on top of an API. Ours calls the same American Cloud API our SDKs and Terraform provider call, with the same permissions. It doesn't add powers the API doesn't have.
What changes is who it's written for. An API is written for a programmer, who reads the docs and writes code against each endpoint. An MCP server is written for a model: each tool describes itself, the app reads the list when it connects, and the model picks the tools on its own. Nobody writes integration code.
So use both, for different jobs. Scripts, CI pipelines and infrastructure you want to rebuild the same way every time belong in code, through the API, an SDK or Terraform. Questions ("what's running, and what does it cost?"), audits and one-off changes are faster as a sentence to an assistant with an MCP server behind it.
Does ChatGPT use MCP?
Yes. On ChatGPT plans that allow custom servers, you add an MCP server in Developer mode, and OpenAI's API can connect models to remote MCP servers directly. When Anthropic gave the protocol to the Linux Foundation's Agentic AI Foundation in December 2025, it counted ChatGPT, Cursor, Gemini, Microsoft Copilot and VS Code among the apps that had adopted it. It's no longer one company's format.
Ours works with ChatGPT, Claude, Claude Code, Cursor, Codex and Grok through the hosted server, while Windsurf and VS Code use the local package. The setup guide for each app shows the exact steps.
Is it safe to connect an MCP server to your cloud account?
It's as safe as the access you give it. The spec puts it bluntly: tools are arbitrary code execution, and there should always be a human in the loop who can deny a call. Anthropic's Claude Code docs add that a server which fetches outside content can expose you to prompt injection, where text in that content tries to steer the model.
So treat an MCP server like any credential. Connect servers you trust, give each app the least access it needs, and keep confirmations on for anything that changes your account. On our hosted server each app gets its own row in Connected apps, set to Read-only, Full access or Custom. Billing, users and API keys stay out of every app's reach, and you can revoke one at any time. The local server is read-only until you start it with --allow-writes. Either way, it manages your account, not your machines: it never runs commands inside a VM. We cover the setup in more depth in giving AI safe access to your cloud.
How do you connect one?
In most apps it's one address and a sign-in. In Claude Code it's one line:
claude mcp add --transport http americancloud https://mcp.americancloud.com/mcpThen ask it what's running in your account. The Claude Code guide has the rest. To see how other clouds' servers compare on where they run and what they can change by default, read which cloud providers have an MCP server.