Connect five models to ten tools by hand and you are writing fifty adapters, each with its own auth quirks and response shapes. Anthropic called this the M×N integration problem when it open-sourced the Model Context Protocol on November 25, 2024. MCP turns M×N pairwise adapters into M+N implementations of one shared interface.
The Model Context Protocol is an open standard, built on JSON-RPC 2.0, that lets an AI application (the host) connect to external tools and data through MCP servers using one consistent interface. A server exposes tools, resources, and prompts; a client discovers and calls them; the model never needs a custom integration per tool. It works the same way over a local process or a remote endpoint.
What does the Model Context Protocol actually do?
The Model Context Protocol follows a host-client-server split. The host is the application coordinating the conversation, something like Claude Desktop or an IDE. For every server it connects to, the host spins up a dedicated MCP client that holds that one connection and speaks only to that server. The server is the program exposing capabilities, and it does not need to know anything about the model calling it, or even that a model is involved at all. That separation is what lets a single filesystem or Slack server work unmodified with any MCP-compliant host, whether that host ships from Anthropic, runs in an open-source IDE, or is a script someone wrote on a Friday afternoon.
Before MCP, that consistency did not exist. Anthropic’s original announcement described AI assistants as isolated behind information silos, with every new data source needing its own bespoke implementation. A server built for the Model Context Protocol exposes three primitives, and each does a different job.
| Primitive | What it exposes | Who decides to use it |
|---|---|---|
| Tools | Executable functions: file writes, API calls, database queries. | The model, during a conversation. |
| Resources | Read-only context: file contents, schema, records. | The application, usually attached upfront. |
| Prompts | Reusable templates for structuring a task. | The user, picked explicitly from a menu. |
How does a tool call travel through MCP?
Every message on the wire is JSON-RPC 2.0, regardless of transport. A local server on the same machine talks over stdio; a remote one talks over Streamable HTTP with bearer-token or OAuth-gated authorization. The client first calls tools/list to learn what a server can do, then issues tools/call with the tool name and arguments. A trimmed version of that call:
1{ 2 "jsonrpc": "2.0", 3 "id": 3, 4 "method": "tools/call", 5 "params": { 6 "name": "weather_current", 7 "arguments": { 8 "location": "Bengaluru", 9 "units": "metric" 10 } 11 } 12} 13// server replies with the same "id" and a 14// "result.content" array holding the answer
Nothing in that payload names a model or a vendor. That is deliberate: the same server answers Claude, a custom agent, or any other MCP-compliant host without a rewrite, which is what turns multi-agent orchestration from bespoke wiring into configuration. Swap the host and the server does not need to change at all, because the Model Context Protocol never encoded anything host-specific in the first place.
What MCP does not solve. The protocol standardizes the interface, not the judgment. A server can still expose a destructive tool through a vague description, and a model can still misuse it. MCP moved the integration problem from M×N down to M+N; it did not remove the need for scoped permissions, argument validation, or a human checkpoint before anything irreversible runs. Anthropic’s own reference server implementations are a reasonable starting point precisely because they model that discipline, rather than because the protocol enforces it for you.
- MCP is an open, JSON-RPC 2.0 based standard, open-sourced by Anthropic on November 25, 2024, for connecting AI applications to external tools and data.
- The architecture splits into host, client, and server, with one dedicated client per server connection.
- Servers expose three primitives: tools for actions, resources for read-only context, and prompts for reusable templates.
- Local servers typically use the stdio transport; remote servers use Streamable HTTP with OAuth-based authorization.
- MCP standardizes the wire format for tool calls; it does not replace scoped permissions or human review of risky actions.
Conclusion
The Model Context Protocol settles how a tool call is shaped and shipped, and it does that job well enough that most teams stop thinking about it once the server is wired in. What the agent does with the result, and how much of it survives into the next turn, is a separate design problem that MCP deliberately leaves alone. See memory management in agents for how that history gets kept or dropped.
Frequently Asked Questions
What is the Model Context Protocol?
The Model Context Protocol, or MCP, is an open standard that lets AI applications connect to external tools and data sources through a single consistent interface. Anthropic open-sourced it on November 25, 2024. Instead of writing a custom integration for every model-and-tool pair, both sides implement MCP once.
What problem does MCP actually solve?
It solves the M×N integration problem. Connecting M AI applications to N external tools once required M×N custom adapters. MCP standardizes the interface both sides implement, cutting that down to M+N implementations: one per application, one per tool.
What is the difference between an MCP tool, resource, and prompt?
Tools are executable functions the model can invoke, like an API call or a file write. Resources are read-only context, such as file contents or database records, usually attached without the model deciding. Prompts are reusable templates a user selects explicitly to structure a task.
What transport does MCP use?
MCP defines two standard transports. Stdio connects a local server to a client over standard input and output on the same machine, with no network overhead. Streamable HTTP connects a remote server over HTTP, typically secured with OAuth 2.1 or bearer tokens, and supports many clients at once.
Does MCP make tool calls safe by default?
No. MCP standardizes how a tool call is formatted and transmitted, not what the tool is permitted to do. A server can still expose a destructive action with a misleading description. Scoped permissions, argument validation, and human review of irreversible actions remain the integrator’s responsibility.
Who maintains MCP now?
Anthropic created and open-sourced MCP. In December 2025, Anthropic donated the protocol to the Agentic AI Foundation, a directed fund under the Linux Foundation, moving it to a formal open-governance model as adoption grew across the industry.