What Is MCP - and Why Everyone's Talking About It
MCP (Model Context Protocol) is the open standard that lets AI assistants connect to real tools, data, and services - turning a chat window into an agent that can actually do things. Here's what it is and why it matters.
TL;DR: MCP is an open standard, introduced by Anthropic in November 2024, that gives AI assistants a universal way to connect to external tools and data. Instead of building a custom integration every time you want an AI to touch a database or call an API, you build one MCP server and any MCP-compatible AI can use it. It's now the de-facto standard for agentic AI - adopted by Claude, ChatGPT, VS Code, Cursor, and hundreds of others.
The Problem MCP Solves
An AI model on its own is a very smart text predictor. Ask it to check your calendar, push a commit, or query your database - and it can only guess, hallucinate, or apologetically say it has no access.
Before MCP, the workaround was custom integrations. You'd write glue code to pipe your database into the model's context, hand-craft an API wrapper so the AI could call Stripe, and repeat the whole process for every tool, every model, and every platform. If you switched from Claude to GPT or added a new product, you rewrote everything.
That fragmentation is what MCP was designed to end. The MCP documentation puts it plainly: MCP is the USB-C port for AI. One standardized connection that works with any compatible device on either end.
What MCP Actually Is
MCP (Model Context Protocol) is an open protocol specification, launched by Anthropic on November 25, 2024. It defines a standard way for AI applications to communicate with external systems - files, databases, APIs, services, anything.
The architecture has three roles:
- MCP Host - the AI application itself (Claude Desktop, VS Code with Copilot, a custom agent you build). The host orchestrates everything.
- MCP Client - a connection manager that lives inside the host and maintains a dedicated connection to one MCP server.
- MCP Server - a program that exposes tools, data, or prompt templates. It can run locally on your machine or remotely in the cloud.
A single host can connect to many servers simultaneously. So your Claude Desktop instance could talk to a filesystem server, a GitHub server, and a Postgres server all at the same time - each through its own dedicated client connection.
The Three Primitives: Tools, Resources, Prompts
Every MCP server exposes capabilities using one or more of three building blocks:
Tools
Executable functions the AI can call to do things - run a database query, call an API, create a file, send a message. This is the "action" half of MCP. When the AI decides it needs to check the weather, it invokes a tool. The result comes back as structured data the AI can reason about and include in its response.
Resources
Read-only data sources that give the AI context - file contents, database schemas, API responses, documentation. The AI doesn't execute these; it reads them to ground its answers in real information rather than training data.
Prompts
Reusable prompt templates that structure how the AI interacts with a specific tool or workflow. Think of them as recipes - a few-shot example set for querying a database, or a system prompt tuned for a specific integration.
All three are discoverable at runtime. The AI asks the server "what tools do you have?" and gets back a list with descriptions and input schemas - no hardcoding required.
How a Tool Call Actually Works
Under the hood, MCP uses JSON-RPC 2.0 - a lightweight request-response protocol you've probably never had to think about, and you still don't have to. The SDKs handle it. But seeing one exchange makes the whole thing click:
// 1. Host asks the server: what tools do you have?
{ "method": "tools/list" }
// 2. Server replies with its tool catalog
{ "tools": [{ "name": "weather_current", "description": "Get current weather...", ... }] }
// 3. AI decides to use the tool, host fires the call
{ "method": "tools/call", "params": { "name": "weather_current", "arguments": { "location": "Austin, TX" } } }
// 4. Server executes it and returns the result
{ "content": [{ "type": "text", "text": "Currently 94F, sunny, humidity 42%" }] }
The AI reads that result, incorporates it into its reasoning, and gives you a grounded answer - not a guess.
Why Standardization Is the Real Unlock
The "USB-C" framing isn't just a cute analogy. The actual value of MCP is network effects from standardization.
If you build an MCP server for your product today, it immediately works with every MCP-compatible client - Claude, ChatGPT, VS Code Copilot, Cursor, and thousands of tools built by the community. You built it once. It works everywhere.
The adoption numbers back this up. In December 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF) - a directed fund under the Linux Foundation, co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. Stripe, GitHub, Notion, Hugging Face, and major cloud providers all shipped MCP servers. By early 2026, monthly SDK downloads had crossed 97 million - a 4,750% increase from launch. MCP is now permanently vendor-neutral, governed like Kubernetes or Node.js.
What This Means If You're Building
MCP changes what "building with AI" means in practice. A few concrete scenarios:
- You're a creator with a content database. Build one MCP server that exposes your archive as a resource. Now any MCP host - your own agent, Claude, a future tool you haven't heard of yet - can search and reference your work without you writing new integrations.
- You're shipping a product. Add an MCP server and your product becomes "AI-connectable" to the entire ecosystem of MCP clients. No partnership deal required.
- You're building an agent. Instead of hardcoding API calls, wire up MCP servers for each capability. Swap out or add tools without rewriting your agent's core logic.
MCP also runs locally. The stdio transport - where the server is just a local process - means you can connect an AI to your machine's filesystem, local databases, or internal tools with zero network exposure. No cloud required.
The Bigger Picture: From Chatbot to Agent
There's a reason MCP arrived right when "AI agent" stopped being a research term and started appearing on product roadmaps. The core limitation holding agents back wasn't model intelligence - it was connectivity. An agent that can only read what you paste into a chat window isn't an agent; it's an elaborate autocomplete.
Tool use is the primitive that changes that. And MCP is the standard that makes tool use composable, portable, and open. You don't need to pick a specific AI platform or vendor to get tool access. You connect the protocol once, and the tools work wherever the model runs.
That's why everyone's talking about it. Not because of the acronym - but because it's the layer that turns language models into things that can actually act.
Key takeaways
- MCP is an open standard (launched November 2024, now stewarded by the Agentic AI Foundation under the Linux Foundation) that lets AI apps connect to external tools, data, and services through a universal protocol.
- The three primitives - tools (actions), resources (data), and prompts (templates) - cover almost everything an AI agent needs to interact with the real world.
- Build one MCP server and it works with every MCP-compatible client: Claude, ChatGPT, VS Code, Cursor, and thousands more.
- MCP runs locally too - stdio transport means your own machine's data stays on your machine.
- Standardization is the value: network effects mean the ecosystem compounds over time, just like HTTP did for the web.
- Tool use is what separates an AI chatbot from an AI agent. MCP is the open, portable way to wire up those tools.
Try this next: Build Your First MCP Server - a step-by-step guide to exposing a real tool to any MCP-compatible AI in under an hour.