AI assistants are only as useful as the systems they can reach. A model that cannot read your files, query your database or open a ticket in your issue tracker is limited to what it already knows. The Model Context Protocol (MCP) is the open standard that solves this problem by giving AI applications one consistent way to connect to external tools and data.
This guide explains what MCP is, how its architecture works, what changed in the major stateless revision of the specification, and how to start building or using MCP servers safely.
Key takeaways
- MCP is an open protocol that lets AI applications connect to tools, data sources and workflows through a single standard interface.
- Anthropic open-sourced MCP in November 2024 and contributed it to the Agentic AI Foundation, a directed fund of the Linux Foundation, in December 2025.
- The architecture has three participants: hosts, clients and servers. Servers expose tools, resources and prompts.
- The 2026-07-28 specification made the protocol stateless, so MCP servers can scale like ordinary HTTP services.
- Security still depends on you: trust only vetted servers, grant minimal permissions and keep a human in the loop for sensitive actions.
What is the Model Context Protocol?
MCP is an open specification that defines how an AI application requests context and actions from an external program. Instead of writing a custom integration for every pairing of AI app and service, a developer builds one MCP server for a service, and any MCP-compatible application can use it.
A common analogy is a universal port. Before shared standards, every device needed its own cable. MCP plays a similar role for AI: one connector shape that works across many applications and many services. The official documentation is careful to note its scope. MCP only covers how context is exchanged. It does not dictate which model an application uses or how that model reasons over the information it receives.
Who maintains MCP?
Anthropic introduced and open-sourced the protocol in November 2024. In December 2025, it was contributed to the newly formed Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation, as a founding project alongside Block’s goose and OpenAI’s AGENTS.md. Vendor-neutral governance is a large part of why competing AI platforms now support the same protocol.
The problem MCP solves
Imagine five AI applications that each need to connect to ten business systems. Without a standard, that is fifty separate integrations, each with its own authentication, data format and maintenance burden. With MCP, each system needs one server and each application needs one client implementation. The integration effort shrinks from multiplication to addition.
This also changes who can build integrations. A SaaS company can publish an official MCP server for its product once, and every compatible assistant, coding tool or agent platform can use it immediately.
How MCP works: hosts, clients and servers
MCP follows a client-server design with three participants:
- MCP host: the AI application the person actually uses, such as an AI desktop app, a coding assistant or an IDE.
- MCP client: a component inside the host that maintains a dedicated connection to one server. A host creates one client for each server it connects to.
- MCP server: a program that provides context or actions, such as access to a filesystem, a database, a CRM or a monitoring platform.
The official documentation uses Visual Studio Code as an example. When VS Code connects to a remote error-monitoring server and a local filesystem server, it creates two separate clients, one for each connection.
Local and remote servers
A server is called local when it runs on the same machine as the host and communicates through standard input and output. It is called remote when it runs elsewhere and is reached over HTTP. Local servers usually serve a single client, while remote servers typically serve many.
The two layers of the protocol
Data layer
The data layer defines the messages themselves. It uses JSON-RPC 2.0, a lightweight format for requests, responses and notifications. This layer covers capability discovery, the core primitives described below, and utilities such as progress updates.
Transport layer
The transport layer defines how messages travel. MCP supports two transports:
- Stdio: for local processes on the same machine, with no network overhead.
- Streamable HTTP: for remote servers, using HTTP POST with optional Server-Sent Events for streaming. It supports standard authentication such as bearer tokens and API keys, and the specification recommends OAuth for obtaining tokens.
If OAuth and identity providers are new to you, our Okta tutorial explains how modern single sign-on and token-based access work.
MCP primitives: what servers and clients can offer
Primitives are the building blocks of every MCP integration. Servers expose three core types:
| Primitive | What it is | Example |
|---|---|---|
| Tools | Functions the AI application can call to take an action | Run a database query, create a ticket, send a calendar invite |
| Resources | Read-only data that provides context | File contents, a database schema, an API response |
| Prompts | Reusable templates that structure an interaction | A code review checklist or a set of few-shot examples |
Each primitive has list methods for discovery, such as tools/list, and methods for use, such as tools/call, resources/read and prompts/get. Because the application discovers tools at runtime, a server can add or change capabilities without the host being rebuilt.
Clients can also offer a primitive to servers. Elicitation lets a server ask the user for more information or for confirmation before an action, which is essential for keeping people in control. In the 2026-07-28 revision, the older client features roots and sampling, and the server logging feature, were deprecated in favor of simpler alternatives such as passing paths through tool parameters and logging to standard error or OpenTelemetry.
What changed in the 2026-07-28 specification
The 2026-07-28 release is the largest revision since MCP launched. Its central change is that the protocol is now stateless.
- No more session handshake. The initialize exchange and the session ID header were removed. Every request now carries its protocol version, client capabilities and client identity in a
_metafield. - Discovery on demand. Servers implement a
server/discoverrequest that returns supported versions and capabilities, and the response can be cached. - Standard infrastructure. Because no request depends on the one before it, servers can run behind ordinary load balancers without sticky sessions, using the same cloud-native tooling teams already rely on.
- Official extensions. Tasks, for long-running operations that return a durable handle the client can poll, became an official extension. MCP Apps, for server-rendered interactive interfaces, and Enterprise Managed Authorization, which lets an organization’s identity provider decide server access, were also formalized.
- Stronger authorization. Validation of the issuer parameter in authorization responses is now required, closing a class of OAuth mix-up attacks.
- Predictable change. A formal deprecation policy guarantees at least twelve months between a feature’s deprecation and its earliest removal.
For teams that deployed earlier versions, the practical work is updating SDKs, removing session-dependent logic and testing against the new version. For new projects, the stateless design is simply easier to run in production.
What an MCP request looks like
Here is a simplified tool call under the current specification. The client names the tool, passes arguments that match the tool’s input schema and includes the per-request metadata:
{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "weather_current",
"arguments": { "location": "San Francisco", "units": "imperial" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientInfo": { "name": "example-client", "version": "1.0.0" },
"io.modelcontextprotocol/clientCapabilities": { "elicitation": {} }
}
}
} The server responds with a content array that can hold text, images, audio or links to resources. The host passes that result back to the model, which uses it to continue the conversation or decide on the next step.
Real-world use cases
- Software development: coding assistants read repositories, run tests, query logs and open pull requests through MCP servers for source control and monitoring platforms.
- Data and analytics: analysts ask questions in plain language while a database or warehouse server runs the queries. If you work with cloud warehouses, our Snowflake tutorial covers the fundamentals.
- IT and operations: agents check service status, summarize incidents and draft change requests. Teams exploring this should also read about applying machine learning to DevOps.
- Business automation: assistants update CRM records, prepare reports and move information between systems, a natural next step for teams already using robotic process automation.
- Marketing: connected assistants pull campaign and analytics data so teams can analyze performance without exporting spreadsheets by hand.
MCP compared with APIs and function calling
| Approach | What it does | Main limitation |
|---|---|---|
| Direct API integration | Custom code connects one app to one service | Must be rebuilt for every app and service pairing |
| Model function calling | A model requests a function defined by the developer | Definitions are tied to one application and often one model provider |
| MCP | A standard protocol for discovering and calling tools and data | Adds a protocol layer and requires careful trust and permission design |
These approaches are complementary. MCP servers usually wrap existing APIs, and hosts often translate MCP tools into the function-calling format their model expects.
Security best practices
Connecting an AI system to real tools creates real risk. A server can read data and take actions, so treat every server like software with access to your accounts.
- Install servers only from trusted sources. Prefer official servers published by the vendor of the service and review open-source code before running it.
- Apply least privilege. Use scoped tokens and read-only access wherever possible. Our CyberArk tutorial explains privileged access principles that apply directly here.
- Keep a human in the loop. Require confirmation for actions that send messages, change data or spend money. Elicitation exists for exactly this purpose.
- Plan for prompt injection. Content returned by a tool, such as a web page or an email, can contain instructions aimed at the model. Hosts should treat tool output as data, not as commands.
- Centralize authorization. In organizations, route server access through your identity provider so permissions can be granted and revoked in one place.
- Log and monitor. Record which tools were called, by whom and with what result, so unusual behavior is visible quickly.
How to get started
- Try an existing server. Connect a reference server, such as the filesystem server, to an MCP-compatible assistant to see discovery and tool calls in action.
- Read the specification. The architecture overview is the best starting point before diving into the full specification.
- Choose an official SDK. SDKs are available for popular languages, including TypeScript, Python, Go and C#, and they handle the protocol details for you.
- Test with MCP Inspector. The MCP Inspector lets you call your server’s tools and inspect responses without a full AI application.
- Start small and read-only. Expose one or two well-described tools, confirm they behave correctly, then add write actions with confirmation steps.
Good tool names and descriptions matter more than most teams expect. The model decides which tool to call based on that text, so describe exactly what each tool does and when it should be used.
MCP is also part of a wider shift toward agents that act on websites and services. To see how that shift is changing search visibility, read our guide on optimizing for Google AI Overviews and AI Mode.
Frequently asked questions
Is MCP only for Anthropic’s Claude?
No. MCP is an open standard governed by the Agentic AI Foundation under the Linux Foundation. It is supported by many AI applications, coding tools and agent platforms from different vendors.
Is MCP free to use?
Yes. The specification and the official SDKs are open source. Individual servers may connect to paid services, but the protocol itself has no licensing fee.
Do I need to be a developer to use MCP?
Not to use it. Many AI applications let you add connectors through a settings screen. Building your own server does require programming knowledge, although the SDKs make the protocol work straightforward.
What is the difference between an MCP server and an API?
An API is an interface for one specific service. An MCP server typically wraps one or more APIs and exposes them in the standard MCP format, so any compatible AI application can discover and use them without custom code.
Do servers built for older MCP versions still work?
Versions are negotiated per request, and the formal deprecation policy gives at least twelve months of notice before removing a feature. Still, servers built before the 2026-07-28 revision should be updated and retested to take advantage of the stateless design.
Sources
- Model Context Protocol: Architecture overview
- Model Context Protocol Blog: The 2026-07-28 specification
- Agentic AI Foundation: MCP graduates to enterprise infrastructure
- MCP Inspector on GitHub