Glossary · Integration
Model Context Protocol (MCP)
The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools and data through one uniform interface instead of many bespoke integrations.
The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, for connecting AI applications to external tools and data. It uses JSON-RPC 2.0, letting a host reach any compliant server through one uniform interface instead of N bespoke integrations.
- MCP standardises how AI apps connect to tools and data: one interface instead of N custom ones.
- It uses JSON-RPC 2.0 and defines two transports: stdio and Streamable HTTP.
- Servers expose three primitives: tools, resources and prompts; clients offer sampling, roots and elicitation.
- The single, uniform boundary is what makes access auditable and governable.
- Since December 2025 MCP is governed under the Linux Foundation's Agentic AI Foundation.
Also known as: MCP
The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools and data through one uniform interface instead of many bespoke integrations.
Introduced and open-sourced by Anthropic in November 2024, it replaces the M-by-N problem (every application wiring up to every tool separately) with a single protocol that any compliant application and any compliant tool can speak.
How Model Context Protocol works
MCP uses JSON-RPC 2.0 messages exchanged between three roles: a host (the AI application), clients (connectors inside the host), and servers (services that expose capabilities). It defines two standard transports. In stdio, the client launches the server as a subprocess and they exchange newline-delimited messages over standard input and output: the common case for local tools. In Streamable HTTP, the server runs independently and handles connections over HTTP POST and GET, optionally using server-sent events to stream messages: the common case for remote servers.
A server offers three kinds of capability: tools the model can call to act, resources it can read for context, and prompts, which are reusable templated workflows. Clients can in turn offer servers sampling, roots and elicitation. When a connection initialises, the two sides negotiate which capabilities are in play, so a host always knows what a server can and cannot do. This is the same idea as tool use, standardised so one integration works everywhere.
Why Model Context Protocol matters for enterprise AI adoption
The enterprise value is one integration surface instead of N. Wrap an internal system as an MCP server once, and every MCP-capable assistant, IDE and agent can use it without a new bespoke connector each time. That is fewer integrations to build, fewer to maintain, and one consistent contract as the tools around them change.
The governance value may matter more. A single, uniform boundary is a single place to enforce permissions, obtain consent, and log every access for audit, which is exactly what an AI governance framework needs. MCP's adoption has been rapid, and in December 2025 it became a founding project of the Agentic AI Foundation under the Linux Foundation, co-founded by Anthropic, Block and OpenAI (Linux Foundation, December 2025). Multi-vendor governance under a neutral foundation is a signal an enterprise can plan around, rather than betting on one company's roadmap.
Common mistakes with Model Context Protocol
The first mistake is treating an MCP server as trusted because it is easy to connect. The specification is explicit that tool descriptions from an untrusted server should be treated with caution and that a host must obtain user consent before invoking a tool. A server you did not write or vet is code you are inviting into your workflow.
The second is skipping the boundary controls MCP makes possible: connecting a server and then not logging or scoping what it can reach, which throws away the governance benefit that was the point. The third is assuming MCP replaces orchestration; it standardises how tools are reached, but the coordination, state and retries around those calls are still yours to build.
Related terms
- Tool use: the capability MCP standardises across applications.
- Agent orchestration: the layer that coordinates the tools MCP exposes.
- AI governance framework: where MCP's single boundary becomes an audit control.
- Retrieval-augmented generation: often surfaced to a model as an MCP resource or tool.
How Chokmah approaches Model Context Protocol
We use MCP where it reduces integration sprawl, and we treat every server as a security boundary. In a workflow sprint we prefer servers the client controls or that we vet, scope what each can reach, and log every access so the connection is auditable rather than opaque. Under a governance retainer, that single boundary becomes one of the cleanest controls in the framework: one place to see, and gate, what the agents touch.
Sources
- Model Context Protocol, Specification (2025-06-18). https://modelcontextprotocol.io/specification/2025-06-18
- Linux Foundation, Formation of the Agentic AI Foundation, December 2025. https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation
Related terms
- Tool useTool use is the mechanism by which an AI model calls external functions, APIs or data sources during a task, instead of answering only from what it learned in training.
- Agent orchestrationAgent orchestration is the coordination layer that routes work across multiple AI agents and tools so a multi-step task completes reliably, handling state, retries, handoffs and stopping conditions.
- AI governance frameworkAn AI governance framework is the documented set of policies, roles, controls and records that determine who may deploy an AI system, on what data, with what testing, and who is accountable when it fails.
- Retrieval-augmented generation (RAG)Retrieval-augmented generation (RAG) is a technique that fetches relevant passages from your own documents and supplies them to a language model as grounding before it generates an answer.
Frequently asked questions
The integration explosion. Before a standard, connecting M AI applications to N tools meant building and maintaining roughly M times N bespoke integrations, each with its own auth, schema and quirks. MCP collapses that: a tool is wrapped once as an MCP server, and any MCP-compatible application can use it. For an enterprise, the payoff is fewer integrations to maintain and one consistent place to apply access controls and audit logging.
MCP uses JSON-RPC 2.0 messages between a host application, its clients, and servers. It defines two standard transports: stdio, where the client launches the server as a subprocess and they exchange messages over standard input and output, and Streamable HTTP for remote servers. Servers expose three kinds of capability (tools the model can call, resources it can read, and prompt templates) negotiated when the connection initialises.
For most, yes, with governance. The value is real: one integration surface instead of many, and a single boundary where you enforce permissions and logging. The caution is equally real: the specification itself warns that tool descriptions from an untrusted server should not be trusted and that hosts must get user consent before invoking tools. Treat each server as a security boundary, prefer servers you control or vet, and validate what tools can do before you connect them.
Anthropic introduced and open-sourced MCP in November 2024. In December 2025 it became a founding project of the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded by Anthropic, Block and OpenAI. Day-to-day technical direction stays with the existing maintainers and the community's proposal process; the foundation provides neutral, multi-vendor governance rather than control by any single company.
Put the concept to work
We install working agentic workflows, not vocabulary. Book a free AI Reality Check.