The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that lets AI applications connect to external tools and…
Define the Model Context Protocol as an open standard for wiring AI apps to tools and data.
The Model Context Protocol (MCP) is an open standard that gives AI applications a single, consistent way to reach external tools and data — files, databases, APIs, and more. Anthropic introduced MCP in November 2024 and released it as open source, and it has since been adopted across many AI tools and IDEs.
The point of MCP is to replace one-off, custom integrations with a shared protocol. Once a tool speaks MCP, any MCP-compatible AI client can use it without new glue code.
Walk the host, client, and server roles and the three things an MCP server can expose.
MCP uses a client-server design with three roles. The host is the AI application the user interacts with (for example Claude Desktop or an IDE). Inside the host, an MCP client opens a connection to one MCP server. The server exposes capabilities and runs the actual work.
Messages travel as JSON-RPC 2.0, over local standard input/output for local servers or over HTTP for remote ones.
An MCP server can expose three kinds of capability. Tools are functions the model can call to take actions, such as querying a database or creating a file. Resources are read-only data the app can load into context, like a document or record. Prompts are reusable templates the user can invoke.
The client discovers these at connection time, so the AI app learns what a server offers without hard-coding it.
See how MCP turns an M-times-N integration mess into a simpler M-plus-N standard.
Before MCP, connecting M AI applications to N tools meant writing M×N custom integrations — every app needed bespoke code for every tool. That does not scale, and each integration breaks on its own.
MCP changes the math to M+N: each tool implements the protocol once as a server, each app implements it once as a client, and any app works with any tool.
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
}
}
}This is all a host needs to gain filesystem tools: name the server and how to launch it. The client starts the server, discovers its tools, and the model can then read and write files under /data — no custom code in the host.
Contrast MCP with calling REST APIs directly, and note when each fits.
You can always give a model a raw REST API, but then you hand-write the tool definitions, auth, and result formatting for every service, and repeat that work in every app. MCP standardizes that layer: capability discovery, a common message format, and a consistent way to expose tools, so integrations are reusable across hosts.
Reach for MCP when the same tools must serve many AI apps, or when you want to plug in third-party servers without building each connection yourself. A single script calling one API may not need it.
The Model Context Protocol (MCP) is an open standard from Anthropic (November 2024) that connects AI applications to tools and data through a uniform client-server interface. A host runs an MCP client that talks to MCP servers exposing tools, resources, and prompts over JSON-RPC. MCP turns M×N custom integrations into M+N, making tool connections reusable across any MCP-compatible app.
Pick a tool you use often (say GitHub or a database). Sketch what an MCP server for it would expose as tools, resources, and prompts — then explain why publishing it once as an MCP server beats wiring it into each AI app separately.
What is the Model Context Protocol (MCP)?
MCP is an open protocol — not a model — that standardizes how AI apps reach tools and data, replacing custom per-tool integrations.
Who created MCP and when?
Anthropic introduced the Model Context Protocol in November 2024 and open-sourced it; it has since seen broad adoption.
What problem does MCP solve?
By defining one protocol, MCP lets each tool and each app implement the interface once, so any client works with any server.
How is MCP different from a normal REST API?
A raw API still needs custom tool definitions, auth, and formatting in every app; MCP provides a shared, discoverable interface so those integrations are written once and reused.