What Is MCP (Model Context Protocol)? A Plain-English Guide

MCP, short for Model Context Protocol, is an open standard that defines a common way for AI applications — chatbots, coding agents, IDE assistants — to connect to the external tools, files, and data sources they need to be useful. Anthropic created MCP and open-sourced it in November 2024 to replace one-off, custom-built integrations between AI models and outside systems with a single, reusable connection format. An AI application that speaks MCP can plug into any MCP server, and any MCP server built once can be used by any MCP-compatible application, the same way a USB-C cable works across different devices.

What is MCP (Model Context Protocol)?

The Model Context Protocol is, in Anthropic's own words, "a new standard for connecting AI assistants to the systems where data lives, including content repositories, business tools, and development environments," introduced so that "frontier models produce better, more relevant responses." The official project site, modelcontextprotocol.io, describes MCP more simply as "an open-source standard for connecting AI applications to external systems," and offers the comparison that has become MCP's shorthand ever since: MCP is "like a USB-C port for AI applications." Just as USB-C gives electronics one physical connector instead of a drawer full of proprietary cables, MCP gives AI applications one protocol instead of a different integration for every data source or tool.

Concretely, MCP lets an AI application such as Claude or ChatGPT reach three kinds of things through a single connection type: data sources (local files, databases), tools (search engines, calculators, APIs), and workflows (reusable, specialized prompts) — all so the AI can pull in information and take action rather than only generate text from what it already knows.

Who created MCP, and when

Anthropic built MCP internally and open-sourced it on November 25, 2024, crediting Anthropic engineers David Soria Parra and Justin Spahr-Summers as its creators, according to Anthropic's announcement post. The initial release shipped with the MCP specification and SDKs on GitHub, local MCP server support built into the Claude Desktop apps, and an open-source repository of pre-built MCP servers for Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer. Anthropic said early collaborators Block and Apollo had already integrated MCP into their own systems, and that Zed, Replit, Codeium, and Sourcegraph were working with MCP on their platforms — claims that come directly from that announcement, not from independent confirmation by Pandromeda.

A year later, Anthropic took the step of giving up sole stewardship of the project. On December 9, 2025, it donated MCP to the Agentic AI Foundation (AAIF), described as "a directed fund under the Linux Foundation" — the same non-profit body that stewards the Linux kernel, Kubernetes, Node.js, and PyTorch. Anthropic said it had been "committed to ensuring MCP remains open-source, community-driven and vendor-neutral," and that the donation was meant to carry that commitment forward. The AAIF was co-founded by Anthropic, Block, and OpenAI, with Google, Microsoft, AWS, Cloudflare, and Bloomberg listed as supporters; MCP joined Block's "goose" and OpenAI's "AGENTS.md" as the foundation's founding projects. Anthropic's post states that MCP's governance model "will remain unchanged" and that maintainers would continue to prioritize community input and transparent decision-making.

The problem MCP solves

Before MCP, Anthropic's announcement framed the core issue bluntly: even the most capable AI models are constrained by their isolation from data — "trapped behind information silos and legacy systems." Every time a developer wanted to connect a model to a new piece of software — a database, a ticketing system, a design tool — they effectively had to write a brand-new, custom integration. Multiply that by every model and every data source, and the integration work scales as roughly M × N: M different AI applications, each needing its own bespoke connector for N different tools and systems, with no connector reusable between them.

MCP reduces that to something closer to M + N. A tool or data source gets exposed once, through one MCP server. Any MCP-compatible AI application — any host — can then reach it through the same protocol, without the tool's maintainer needing to know or care which specific AI product is on the other end. This is also why MCP matters more now than a conventional API ever did on its own: APIs are endless and inconsistent in shape, authentication, and documentation quality, while MCP gives every server a predictable, machine-discoverable shape that a model can reason about and call without a human writing glue code for each one. The same architectural idea that connects a conversational assistant to a calendar is what lets an AI coding agent reach a design file or an issue tracker, which is part of why MCP has become foundational to the current wave of AI agents generally, not just chat assistants.

How MCP works: hosts, clients, and servers

MCP's own architecture documentation defines three participants in a client-server model:

• MCP Host — the AI application that coordinates everything, such as Claude Code or Claude Desktop. The documentation's own example names Visual Studio Code as a host.
• MCP Client — a component the host creates for each server it talks to. Each client keeps one dedicated connection to one server and fetches context from it on the host's behalf.
• MCP Server — a program that exposes context, whether it runs locally on the same machine or remotely over the network.

A local server — the official documentation gives a filesystem server as the example — typically uses a "stdio" transport and serves a single client directly over standard input/output, with no network overhead. A remote server, such as an issue-tracking or monitoring server running on a vendor's own infrastructure, typically uses "Streamable HTTP" and can serve many clients at once, authenticated with bearer tokens, API keys, or OAuth. Underneath either transport, MCP's data layer runs on JSON-RPC 2.0: clients and servers exchange structured requests and responses, including a discovery step where a client asks a server what protocol version and capabilities it supports before doing anything else.

The core building blocks: tools, resources, and prompts

What a server actually offers is expressed through a small set of primitives defined by the protocol. The table below summarizes them as described in MCP's architecture documentation.

Clients discover what's available by calling list methods (such as tools/list) before ever invoking anything, which is what lets the set of available tools change dynamically — a server can add, remove, or modify tools, and push a notification so connected clients refresh what they know is possible.

MCP versus a plain, hand-built integration

It's fair to ask why this needed a dedicated protocol instead of everyone simply calling each other's REST APIs. The difference is standardization and discoverability, not raw capability — anything MCP does could, in principle, be hand-coded. The table below lays out the practical contrast.

Why MCP matters for Claude Code and AI coding agents

MCP's own documentation lists running examples that point squarely at software development: "Claude Code can generate an entire web app using a Figma design," and an enterprise chatbot can be wired into "multiple databases across an organization." Anthropic's own developer documentation for Claude Code's MCP support frames the trigger for connecting a server in very practical terms: "Connect a server when you find yourself copying data into chat from another tool, such as an issue tracker or monitoring dashboard. Claude can then read and act on that system directly." The documentation's example prompts give a sense of the range — asking Claude Code to pull a Jira ticket and open a GitHub pull request for it, check Sentry and Statsig for how a feature is performing, query a production Postgres database, or turn a Figma design into an updated email template.

That same documentation describes how Claude Code connects to servers over remote HTTP, the now-deprecated SSE transport, local stdio processes, or WebSockets, and how server configurations can be scoped to a single project (and checked into version control so a team shares them), to a single user across all of that user's projects, or kept local to one project on one machine. It also carries an explicit caution worth repeating here: "Verify you trust each server before connecting it. Servers that fetch external content can expose you to prompt injection" — a reminder that giving a model the ability to act through tools also means giving it a wider attack surface. This is the same underlying mechanism that powers Claude Code's broader extensibility, which Pandromeda has covered separately in its explainer on what Claude Code is and how it works. It's also the layer underneath the comparisons in Pandromeda's GitHub Copilot vs. Claude Code workflow guide, since how well a coding agent connects to a team's actual tools is as much a differentiator as the underlying model.

How big the MCP ecosystem has become

By the time Anthropic donated MCP to the Agentic AI Foundation in December 2025, it cited figures to describe the standard's reach: more than 10,000 active public MCP servers, adoption by ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code, deployment support from AWS, Cloudflare, Google Cloud, and Microsoft Azure, over 97 million monthly SDK downloads combined across the Python and TypeScript SDKs, and a Claude connector directory listing more than 75 connectors. Separately, the project's own GitHub organization shows the scale of the open-source side of that ecosystem: its servers repository of reference MCP servers, its Python and TypeScript SDK repositories, a C# SDK built "in collaboration with Microsoft," and the MCP Inspector developer tool, all maintained under the modelcontextprotocol GitHub organization. The specification itself has also kept evolving since the 2024 launch; Anthropic's December 2025 post notes that the protocol's November 2025 revision added asynchronous operations, statelessness, and server identity, and that an official, community-run registry now exists for discovering MCP servers.

From an Anthropic project to a Linux Foundation initiative

MCP's governance history is itself a useful signal of how seriously the industry has taken it as shared infrastructure rather than one company's product. It launched as an Anthropic open-source release in November 2024, and just over a year later moved under the Agentic AI Foundation, a directed fund of the Linux Foundation, with Anthropic, Block, and OpenAI as co-founders and Google, Microsoft, AWS, Cloudflare, and Bloomberg as named supporters. Anthropic framed the AAIF's purpose as ensuring that "agentic AI evolves transparently, collaboratively, and in the public interest" — language that mirrors how other foundational developer infrastructure, like Kubernetes or Node.js, has been governed under the same umbrella. Anthropic's post is explicit that this was a deliberate continuation of an existing stance, not a reversal: the company says it has been "committed to ensuring MCP remains open-source, community-driven and vendor-neutral" since the start.

Security considerations developers should know

Because an MCP server can hand an AI application real capabilities — reading files, querying production databases, sending messages, opening pull requests — the protocol's own documentation devotes a section specifically to security, and Anthropic's Claude Code documentation repeats the warning directly to end users: an untrusted server that can fetch external content is a path for prompt injection, where text pulled from outside the conversation tries to redirect what the model does next. Connecting a server is, in effect, extending some amount of trust to whoever built and operates it, which is why scoped permissions, reviewing a server's source before installing it, and the project-level approval prompts that tools like Claude Code implement are treated as part of using MCP correctly rather than optional extras.

What's next for MCP

MCP is no longer a single-vendor bet: it sits under neutral open-source governance, has a growing, versioned specification, and is cited as supported by major AI assistants and cloud providers well beyond its originator. For a developer deciding whether to build against it, the practical path is to start with the official documentation at modelcontextprotocol.io, review the reference servers and SDKs in the modelcontextprotocol GitHub organization, and, for anyone working inside Claude Code specifically, Anthropic's own MCP guide for the tool. For everyone else, the simplest way to see MCP in action is to connect one existing server — a GitHub, Postgres, or Google Drive connector, say — to an MCP-aware assistant and watch it read or act on that system directly, instead of being told about it secondhand through copy-pasted text.

Frequently asked questions

What does MCP stand for? Model Context Protocol.

Who made MCP? Anthropic, through engineers David Soria Parra and Justin Spahr-Summers, who open-sourced it on November 25, 2024.

What is an MCP server? A program that exposes tools, resources, and/or prompts to AI applications over the Model Context Protocol, running either locally or remotely.

Is MCP only for Claude? No. It is an open protocol; Anthropic's own December 2025 donation announcement cites adoption by ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code, among others.

Who governs MCP now? The Agentic AI Foundation, a directed fund under the Linux Foundation, following Anthropic's December 9, 2025 donation of the project.

Is MCP safe to use with any server? Not automatically. Anthropic's own Claude Code documentation warns that an untrusted MCP server that fetches external content can expose a user to prompt injection, so only connecting trusted servers is advised.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage