System Atlas
the atlas
AI · AI & LLMs6 minApplied

What is MCP (Model Context Protocol)

One open protocol that connects AI apps to any tool or data source — USB-C for AI.

the gist

MCP standardizes how AI apps talk to tools and data. An MCP Host (like Claude or an IDE) runs MCP Clients that connect over a standard transport to MCP Servers, each exposing tools, resources and prompts. It replaces bespoke, per-integration glue with a single reusable protocol.

ANALOGY // USB-C for AI: before, every device needed its own proprietary cable; now one standard port means any device plugs into any host without custom wiring.
living diagram01 / 05
MCP HostClaude · IDEMCP Clientper connectionMCP protocolstdio · HTTPMCP ServerresourcesMCP ServertoolsMCP ServerpromptsData sourceAPI / codeFiles
01

The host

An MCP Host — Claude Desktop, an IDE like Cursor, or any AI application — is the environment the user works in and the place the LLM lives. It's the party that needs external capabilities: access to files, databases, APIs, the web. On its own it has none of them, which is exactly the gap MCP fills.

02

The client

Inside the host runs one or more MCP Clients, and each client maintains a single, dedicated one-to-one connection to exactly one server. The client's job is to translate the host's needs into MCP protocol messages and relay responses back. Running one client per server keeps connections cleanly isolated from each other.

03

The protocol

Client and server communicate using MCP, a standard message format carried over a standard transport — stdio for a server running locally on your machine, HTTP for a remote one. Because the protocol is fixed, any compliant client can talk to any compliant server without custom code. This shared contract is the whole reason integrations become reusable.

04

The servers

Each MCP Server is a lightweight program that fronts one system — a database, a code repository, the Slack API, the local filesystem — and advertises what it offers. It exposes three kinds of capability: tools (actions the model can invoke), resources (data it can read), and prompts (reusable templates). Anyone can write a server for any system, and it works with every host.

05

A tool call round-trip

In use, the host's LLM decides to invoke a tool; the client packages that call into an MCP message and sends it across the transport to the right server. The server executes the action against its backend — running the query, calling the API — and returns the result back up through the client to the host. One standard round-trip, regardless of which tool or system is involved.

the full picture
01

The N×M integration problem

LLMs became genuinely useful once we started connecting them to the outside world — letting them read files, query databases, search the web, and call APIs. But before MCP, every one of those connections was a bespoke piece of glue code. If you wanted Claude to talk to GitHub, you wrote a custom GitHub integration. If you also wanted it to talk to Slack, a Postgres database, and your internal ticketing system, that was three more one-off integrations, each with its own way of describing capabilities, passing arguments, and handling auth.

Now multiply that. Say there are N AI applications (Claude Desktop, an IDE, a chatbot, a custom agent) and M tools/data sources (GitHub, Slack, Postgres, Google Drive, a dozen internal services). If every app needs its own custom connector to every tool, you are on the hook for N × M integrations. Ten apps and twenty tools is two hundred connectors — and every new tool has to be re-integrated separately into every app, by every team, forever. The work is duplicated, incompatible, and never finished.

This is the exact shape of a problem that standards are built to solve, and it has a famous historical parallel: hardware peripherals before USB. Every device needed its own proprietary port and cable. USB collapsed that mess into one standard connector — build a device to the USB spec once, and it plugs into anything. MCP (the Model Context Protocol), an open standard introduced by Anthropic in late 2024, does the same thing for AI. Build a tool as an MCP server once, and every MCP-compatible app can use it, with zero custom code on either side. That is why it's described as "USB-C for AI": one universal port between models and the world.

02

How a standard turns N×M into N+M

The magic of a standard protocol is arithmetic. Instead of every app-to-tool pair needing its own connector, each app implements the protocol once (that's the client side) and each tool implements the protocol once (that's the server side). Now any app speaks to any tool through the shared contract, so the total work drops from N × M to N + M.

Concretely: the GitHub team writes *one* MCP server for GitHub. From that moment, Claude Desktop, Cursor, and any future MCP host can all use GitHub without writing a single line of GitHub-specific integration code — they already know how to speak MCP. Add a brand-new AI app and it instantly gains access to the entire ecosystem of existing MCP servers. Add a brand-new tool and every existing app can immediately use it. The network effect compounds: every server written benefits every host, and every host built benefits from every server.

This decoupling is the entire value proposition. The people who know a system best (the GitHub team, your internal platform team) build and maintain its server, exposing exactly the capabilities they choose. The people building AI applications don't need to know anything about GitHub's API internals — they just connect to the server. Responsibility lands where the expertise is, integrations become reusable assets rather than throwaway glue, and the ecosystem grows instead of fragmenting. The rest of this article covers the architecture that makes this work and the three kinds of things a server can expose.

03

The architecture: host, client, server

MCP defines three roles, and keeping them straight is the key to understanding the whole system.

The Host is the AI application the user actually interacts with — Claude Desktop, an IDE like Cursor, or any custom agent. It's where the LLM runs and where the user's requests originate. The host coordinates everything but doesn't talk to tools directly.

Inside the host live one or more Clients. A client is a connector component, and the rule is one client per server — each client maintains a single, dedicated connection to exactly one MCP server. If a host connects to three servers, it runs three clients. This one-to-one pairing keeps each connection isolated, independently managed, and secure; a misbehaving server can't bleed into another's connection.

On the other side are the Servers. A server is a (usually lightweight) program that wraps one external system — a database, an API, the local filesystem, a SaaS product — and exposes its capabilities through MCP. Servers can run locally (a process on your own machine, communicating over stdio — standard input/output) or remotely (reached over HTTP), and the protocol abstracts that difference away so a client interacts with both the same way.

The flow is: the host's LLM decides it needs an external capability, the relevant client packages that into a standard MCP message, the message travels over the transport to the server, the server executes against its backend, and the result returns along the same path. Standard messages, standard transports, clean separation of concerns — that's the architecture.

04

What a server exposes: tools, resources, prompts

An MCP server doesn't just offer a single capability — it advertises up to three distinct kinds of thing, and the distinction matters because they serve different purposes.

  • Tools are *actions the model can take* — functions with side effects or computation. "Create a GitHub issue", "run this SQL query", "send a Slack message", "search the web". These are typically model-controlled: the LLM decides, in the course of its reasoning, that it needs to invoke one, and it emits a call with the right arguments (the same function-calling mechanism agents use). Tools are how MCP lets a model *do* things.
  • Resources are *data the model can read* — files, database records, documents, API responses, exposed as readable content the host can pull into context. These are more like GET endpoints: they provide information without side effects. Resources are often application-controlled, meaning the host decides what to load in and when, rather than the model reaching for them mid-reasoning. This is how a server feeds relevant context to the model.
  • Prompts are *reusable templates* — pre-written, parameterized prompt structures a server can offer for common workflows ("summarize this pull request", "draft a release note from these commits"). These are typically user-controlled, surfaced in the host's UI as something the user explicitly picks. They let a server package expert-designed interactions so every app gets them for free.

Together these three primitives cover the full surface of what an AI app needs from an external system: the ability to act on it (tools), to read from it (resources), and to invoke well-designed workflows against it (prompts) — all described in one standard vocabulary that every host already understands.

05

Why it matters, and how it fits with agents

MCP's significance is that it's an open standard, not a single vendor's proprietary plugin system. That openness is what enables an ecosystem: because the spec is public and anyone can implement a client or a server, thousands of community and official servers now exist for everything from Postgres and Puppeteer to Google Drive, Sentry, and Stripe. Any MCP-capable host can tap that entire library instantly, and adopting a new AI application no longer means abandoning your integrations.

The tight connection to remember is between MCP and agents. An agent is an LLM in a loop that reasons and calls tools; MCP is the standard way to *give it those tools*. Without a standard, every agent builder has to hand-write and maintain integrations for every capability their agent needs. With MCP, an agent connects to a set of MCP servers and immediately inherits a whole toolbox — file access, database queries, API calls — with no per-tool integration work. MCP is, in effect, the plumbing that makes tool-using agents practical to build and to scale.

A few things worth keeping in perspective: MCP standardizes the *connection*, but the LLM still has to decide *when and how* to use each capability, and security and permissioning (which servers a host trusts, what a server is allowed to touch) remain real concerns you must design for — the one-client-per-server isolation helps but doesn't absolve you. Still, the core idea is simple and powerful: define one universal protocol between AI applications and external systems, and the entire N × M integration mess collapses into a reusable, growing ecosystem. That's why MCP has become foundational infrastructure for applied AI so quickly.

what to remember
01

MCP is an open protocol that standardizes how AI apps connect to external tools and data — 'USB-C for AI'.

02

An MCP Host (Claude, an IDE) runs one or more MCP Clients, each holding a connection to a server.

03

MCP Servers expose three things: tools (actions), resources (data), and prompts (templates).

04

Communication runs over a standard transport — stdio for local, HTTP for remote.

05

It replaces N-times-M custom integrations with one protocol every server and client speaks.

check yourself

Quick quiz

Q1

What problem does MCP primarily solve?

Q2

What does an MCP Server expose?

follow the thread