
What Is the Model Context Protocol (MCP)? How It Connects AI to Tools
The Model Context Protocol (MCP) connects AI applications to external tools and data through a shared interface.
If you have ever wanted your AI assistant to read a file, query a database, or check a project tracker, someone had to build that connection by hand. Each tool needed its own custom code, written to that tool’s quirks. Connect five assistants to ten tools and you face fifty separate integrations to build and maintain. MCP exists to collapse that work into a single, reusable standard. Anthropic introduced it in November 2024, and by 2026 it is supported across every major AI vendor, including OpenAI, Google, Microsoft, and AWS.
The clearest way to picture it: MCP is “USB-C for AI.” Before USB-C, every device had its own cable. Now one port handles power, video, and data for almost anything you plug in. MCP plays the same role for AI assistants — one standard connector instead of a drawer full of proprietary adapters.
Under the hood, MCP organizes connections into three roles: a host (the AI application the user interacts with, such as a desktop assistant or coding tool), a client (which lives inside the host and manages one connection), and a server (a small program that exposes a specific tool or data source). When you ask an assistant to fetch your latest commits, the host’s client opens a connection to a server that knows how to talk to your code repository.
According to MCP Docs, the protocol sends its messages using JSON-RPC 2.0 — a lightweight, well-established format for structured request-and-response exchanges — and the protocol is stateless, meaning every request carries the protocol version and the capabilities that request needs, so the server can process each request on its own. According to MCP Docs, the design was inspired by the Language Server Protocol (LSP), the standard that lets one code editor work with many programming languages. MCP applies that same “build it once, reuse it everywhere” idea to AI. According to MCP Docs, the current specification revision is dated 2026-07-28.
Most people first meet MCP through an AI coding assistant or a desktop chat application. Tools like Claude Desktop, Cursor, and Claude Code use MCP servers to reach beyond the chat window — pulling in files from your machine, reading issues from a project tracker, or running a query against a database. You install or enable a server once, and the assistant can use that capability in any conversation, without the vendor hard-coding support for that specific tool.
For example: you connect a filesystem server and a GitHub server to your assistant. Now you can ask it to summarize a folder of documents or open a pull request, and the model reaches the right tool through the same protocol each time. Because the interface is shared, a server someone else built and published works in your assistant too.
Treat MCP servers like browser extensions — each one you enable widens what the assistant can touch, including your files and accounts. Start with servers from sources you trust, review the permissions they request, and add them one at a time so you always know what is connected.
Start with what the Model Context Protocol is and how it connects AI assistants to external tools for the one-paragraph orientation, then move to the architecture piece on hosts, clients, servers, and the tools-resources-prompts primitives — the mental model every later decision, including who owns authentication, depends on.
When you are ready to expose your own service, building an MCP server with the official TypeScript and Python SDKs turns the spec into a working transport and config. For who maintains the standard and which applications support it, the explainer’s section on who created and supports MCP gives the picture. And before you wire any server into production or grant it access to real data, the same article’s section on checking a server before you connect it names what to look at first.

Two comparisons keep surfacing once MCP is running in production.
MCP is connectivity, not curation. MCP decides whether an assistant can reach a database, file system, or API at all. Context engineering for code decides what the assistant sees once it has that reach — which files, which conventions, which memory. A server wired in with no context discipline still floods the model with irrelevant tool output; solving one problem does not solve the other.
MCP is not competing with A2A — the two sit at different layers. The expected protocol war between MCP and Google’s Agent2Agent protocol resolved into convergence: MCP connects one agent to tools and data, A2A connects independent agents to each other. Betting on one does not require abandoning the other.
| Scenario | Use | Avoid |
|---|---|---|
| Connecting an assistant to many tools without per-tool code | ✅ | |
| A one-off script that calls a single API once | ❌ | |
| Reusing the same tool integration across different assistants | ✅ | |
| A closed app where you fully control both sides and need no interoperability | ❌ | |
| Exposing internal company tools to AI assistants safely | ✅ | |
| Situations needing a hard real-time guarantee the protocol does not promise | ❌ |
Q: Why does an MCP integration that worked in testing break after the client reconnects? A: One possible cause is state held in the connection. MCP connections were stateful up to revision 2025-11-25, so a dropped connection or a restart could lose a session; the current revision, 2026-07-28, removes the handshake and protocol-level sessions, so state that must span calls has to be passed explicitly, for example as a tool argument. The architecture article lists what changed in the current revision.
Q: Is it safe to point a coding agent at any MCP server from the public registry? A: Not without vetting it first — a server is code you are granting access to your files, credentials, or data, and the registry’s own documentation says to assume minimal-to-no moderation. The explainer walks through what to check before you connect a server.
Q: Will Google’s A2A replace MCP, or do the two need to coexist? A: They solve different problems, so coexistence is the likely outcome, not a winner-takes-all fight — MCP connects one agent to tools and data, A2A connects independent agents to each other.
Q: What breaks most home-grown MCP server builds? A: Two decisions, not code quality: picking the wrong transport (SSE is deprecated; use stdio or Streamable HTTP) and mismatching the config key each AI host expects. The build guide for the official TypeScript and Python SDKs walks through both before you write a single tool handler.
Part of the agentic and autonomous coding stack · closest neighbour: context engineering for code. New to this from a software background? Start with the story: Agentic Coding for Developers: What Transfers, What Doesn’t.
The Model Context Protocol defines a common language for AI assistants and external systems. Understanding its design reveals why a single standard can replace a tangle of one-off integrations between models and the services they need.

The Model Context Protocol (MCP) connects AI applications to external tools and data through a shared interface.

MCP architecture connects an AI host to a server through a client that exchanges messages to use tools, resources and prompts.
These guides walk through building and connecting MCP servers so your AI tools can reach real data and services. Expect hands-on setup, plus the trade-offs you weigh when exposing capabilities to an assistant.

Build and test a local issue-listing MCP server with the official TypeScript or Python SDK.