Model Context Protocol

Authors 6 articles 64 min total read
Definition
The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that lets AI assistants connect to external tools and data sources through one common interface instead of custom integrations built separately for each tool.
Also called: MCP, MCP standard, AI context protocol

What Model Context Protocol is

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 connection is stateful with capability negotiation, meaning each side announces up front what it can do. 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 2025-11-25.

MCP standardizes what an assistant can reach; vetting servers and adding auth stay your job. · More AI cheat sheets
  • MCP standardizes how an assistant reaches tools, databases, and APIs — one protocol instead of a custom integration per service, and adoption now spans ChatGPT, Gemini, and AWS, not just Claude.
  • The two decisions that break most self-built servers are transport (stdio or Streamable HTTP — SSE is deprecated) and matching the config key each AI host expects.
  • Authentication is optional by the spec, not an oversight — every server you connect is a data-exposure decision, not just an install.
  • MCP and Google’s A2A turned out to be layers, not rivals: MCP connects an agent to tools and data, A2A connects agents to each other.

How Model Context Protocol is used in practice

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.

How to read MCP: spec first, limits before you build

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.

Before wiring anything into production, read the technical limits: missing authentication, tool sprawl, and stateful connections — it names the failure modes this page’s FAQ keeps circling back to. 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 where the standard stands today, MCP’s 2026 adoption across ChatGPT, Gemini, and AWS, and its race against Google’s A2A tracks the platform-by-platform picture. And before you grant any server access to real data, the governance case on trusting third-party MCP servers is the read that keeps convenience from outrunning accountability.

MONA asks: 'If MCP already defines tools, resources, and prompts, why do half these servers still get hacked?' MAX answers: 'Because the spec makes authentication optional by design — you have to add that layer yourself, or you shipped a server with the door unlocked.' — comic dialog.
MCP's spec leaves the front door unlocked; closing it is your job, not the protocol's.

How MCP differs from context engineering and from Google’s A2A

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.

When Model Context Protocol fits — and when it doesn't

ScenarioUseAvoid
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❌

Common questions about running MCP in production

Q: Why does an MCP integration that worked in testing break after the client reconnects? A: Because MCP connections are stateful by design — the server holds session context between calls, and a dropped connection or restart can silently lose it. The technical limits of MCP covers this alongside the other two structural weaknesses the spec leaves for you to solve: tool sprawl and optional authentication.

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 does not audit for that. The governance case against trusting third-party MCP servers by default walks through what to check before you connect one.

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. MCP’s 2026 adoption story covers how that convergence played out across ChatGPT, Gemini, and AWS.

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.

Sources

1

Understand the Fundamentals

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.

2

Build with Model Context Protocol

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.

4

Risks and Considerations

Connecting an AI assistant to external systems widens what it can touch — and what can go wrong. Consider data exposure, unvetted third-party servers, and weak access controls before you let a model act through MCP.