The Model Context Protocol (MCP) is an open standard for connecting AI applications to external systems, such as files, databases, business tools and workflows, through one common interface. The project's own documentation compares it to "a USB-C port for AI applications": instead of every AI application writing its own connector for every system, a system exposes an MCP server once and any MCP-capable application can use it. This page explains MCP in plain terms first, then gives practitioners the detail: the architecture, the building blocks, the transports, every specification version to date, what changed in the 2026-07-28 revision, the official SDKs, the MCP Registry, and how the project is governed and licensed. It is written for developers, architects and anyone who needs to understand what MCP is before deciding how to use or govern it. Facts come from the specification repository, modelcontextprotocol.io and the project blog. Last checked: 2026-11-15.
This is an independent reference page from NHI Mgmt Group based on public project documentation; it is not sponsored or endorsed by any provider.
Key takeaways
- One protocol, many connections. MCP defines how an AI application (the host) talks to servers that offer tools, data and prompts, using JSON-RPC 2.0 messages over stdio or Streamable HTTP.
- The current revision is 2026-07-28. It removed the initialise handshake and protocol sessions, so every request now carries its own protocol version and client capabilities. Revisions 2025-11-25 and earlier are called "legacy".
- Open governance since December 2025. Anthropic introduced MCP on 25 November 2024 and donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation, on 9 December 2025. The existing maintainers keep technical control.
- Ten official SDKs in three tiers. C#, Go, Python, Ruby, Rust and TypeScript are Tier 1; Java is Tier 2; Kotlin, PHP and Swift are Tier 3.
- The official registry is still in preview. The MCP Registry stores metadata about public servers, not code, and warns that breaking changes or data resets may happen before general availability.
What is MCP?
An AI model on its own only knows what is in its training data and the prompt. To do useful work it needs context (a document, a ticket, a database row) and the ability to act (create an issue, run a query, send a message). Before MCP, each AI application built its own integration for each system. MCP replaces that with a standard: a system is wrapped once as an MCP server, and any MCP host, such as a chat assistant, an IDE or an agent framework, can connect to it.
The specification says MCP "takes some inspiration from the Language Server Protocol", which standardised how editors add support for programming languages. In the same way, MCP standardises how AI applications add tools and context. The project blog of December 2025 listed first-class client support in ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot and Visual Studio Code (listed alphabetically), and cited "over 97 million monthly SDK downloads" and "10,000 active servers" at that time.
MCP is a protocol, not a product. It says nothing about which model you use, and it does not decide what a tool may do: those decisions sit with the host, the server and whoever configures them.
How MCP works: hosts, clients and servers
The architecture has three roles, defined in the specification and the architecture guide:
| Role | What it is | Example |
|---|---|---|
| Host | The AI application that coordinates one or more MCP clients and talks to the model | A desktop assistant, an IDE, an agent runtime |
| Client | A connector inside the host that maintains a connection to one MCP server | One client per configured server |
| Server | A program or service that offers tools, resources or prompts to clients | A file system server, a ticketing server, a database server |
The architecture guide notes that local servers using stdio typically serve a single client, while remote servers using Streamable HTTP typically serve many. Messages follow JSON-RPC 2.0: requests with an ID, results or errors in reply, and notifications that need no reply.
The building blocks: tools, resources and prompts
MCP separates what servers offer from what clients offer. The 2026-07-28 specification lists:
| Primitive | Offered by | Purpose | Who controls it |
|---|---|---|---|
| Tools | Server | "Functions for the AI model to execute", described by a name and a JSON Schema for inputs and, optionally, outputs | Model chooses; host may require approval |
| Resources | Server | "Context and data, for the user or the AI model to use", identified by URI | Application or user selects |
| Prompts | Server | "Templated messages and workflows for users", such as slash commands | User invokes |
| Elicitation | Client | Lets a server ask the user for more information | User answers |
| Sampling and Roots | Client | Server asks the host's model for a completion; client tells the server which directories it may use | Deprecated in 2026-07-28 |
For a practical comparison of when to model something as a tool, a resource or a prompt, see MCP Tools vs Resources vs Prompts.
Transports: stdio and Streamable HTTP
The current specification defines two standard transports:
- stdio: the host starts the server as a local subprocess and exchanges newline-delimited JSON-RPC messages over standard input and output. Logs go to standard error.
- Streamable HTTP: the server is an HTTP endpoint. Clients POST requests, and the server can stream responses. Since 2026-07-28 each POST carries
Mcp-MethodandMcp-Nameheaders, and the protocol version travels in theMCP-Protocol-Versionheader.
Streamable HTTP replaced the original HTTP+SSE transport in revision 2025-03-26, and 2026-07-28 reclassified HTTP+SSE as formally Deprecated. The Streamable HTTP vs stdio MCP Transport guide covers the trade-offs, and MCP SSE to Streamable HTTP Migration covers the move.
MCP specification versions
MCP versions are dates, written YYYY-MM-DD. As of 15 November 2026 the specification repository holds five released revisions and a draft.
| Revision | Era | Headline changes (from each revision's changelog) |
|---|---|---|
| 2024-11-05 | Legacy | First published revision |
| 2025-03-26 | Legacy | Authorisation framework based on OAuth 2.1; Streamable HTTP replaces HTTP+SSE; JSON-RPC batching; tool annotations |
| 2025-06-18 | Legacy | Batching removed; structured tool output; servers classified as OAuth resource servers; Resource Indicators (RFC 8707) required; elicitation; resource links; protocol version header |
| 2025-11-25 | Legacy | OpenID Connect Discovery; icons; incremental scope consent; URL mode elicitation; tool calling in sampling; Client ID Metadata Documents; experimental tasks |
| 2026-07-28 | Modern (current) | Stateless protocol: no initialise handshake, no sessions; server/discover; subscriptions/listen; Multi Round-Trip Requests; tasks moved to an extension; caching hints |
| draft | Not final | Work in progress towards the next revision; the site labels it "a not-yet-finalized specification" |
The specification defines "modern" versions (2026-07-28 and later, with per-request metadata) and "legacy" versions (2025-11-25 and earlier, with an initialize handshake). An implementation that supports both is "dual-era". A server that does not support a requested version must answer with UnsupportedProtocolVersionError (code -32022) listing the versions it does support. The changelog page of each revision is the authority on what changed.
What changed in 2026-07-28
This revision is the largest change to date, and most of it makes a remote MCP server behave like an ordinary HTTP service. The changelog's major items:
- Sessions removed: the
Mcp-Session-Idheader is gone and list endpoints no longer vary per connection. Servers that need state across calls pass explicit handles as tool arguments. - Handshake removed: each request carries
io.modelcontextprotocol/protocolVersionandio.modelcontextprotocol/clientCapabilitiesin_meta. - Discovery added: servers must implement
server/discoverto advertise versions, capabilities and identity. - Subscriptions reworked:
subscriptions/listenreplaces the HTTP GET stream andresources/subscribe. - Removed methods:
ping,logging/setLevelandnotifications/roots/list_changed; log level is set per request. - Tasks moved out: experimental tasks became the
io.modelcontextprotocol/tasksextension, with polling throughtasks/get. - Multi Round-Trip Requests: instead of the server sending its own requests (sampling, elicitation, roots), it returns an
input_requiredresult and the client retries with the answers. - Result types: every result carries
resultType, eithercompleteorinput_required. - No stream resumption: SSE event IDs and
Last-Event-IDare removed; a broken stream means re-issuing the request.
Deprecations: Roots, Sampling and Logging are deprecated, as are the HTTP+SSE transport, two includeContext values and OAuth Dynamic Client Registration (in favour of Client ID Metadata Documents). The revision also adopted a feature lifecycle policy with Active, Deprecated and Removed states and "a minimum twelve-month deprecation window", plus a public registry of deprecated features. On the authorisation side, clients must validate the iss parameter (RFC 9207) when present and must key stored credentials by issuer. The MCP Authorisation Specification Guide covers those rules in depth.
Extensions
Since 2026-07-28, optional features can live outside the core as extensions, named {vendor-prefix}/{extension-name} and negotiated through capabilities. Each extension moves through Experimental, Beta and Stable stages. The extensions overview, as of 15 November 2026, lists:
| Extension | Stage | What it adds |
|---|---|---|
| Enterprise-Managed Authorization | Stable | Centralised access control for enterprise environments |
| MCP Apps | Stable | Interactive UI elements (charts, forms, video players) shown inline in conversations |
| MCP Tasks | Beta, heading to core | Long-running operations with polling, mid-flight input and durable handles |
| OAuth Client Credentials | Stable | Machine-to-machine authentication with the OAuth 2.0 client credentials flow |
| Skills over MCP | Beta | Workflow instructions and supporting files discovered through MCP resources |
For the security side of interactive UIs see the MCP Apps Security Guide.
Official SDKs
The project publishes ten SDKs under the modelcontextprotocol GitHub organisation. Tiers reflect feature completeness, protocol support and maintenance commitment. The SDK page notes that "SDKs adopt new protocol revisions on their own schedules", so check which revisions your SDK supports before relying on 2026-07-28 behaviour.
| Tier | Languages (alphabetical) |
|---|---|
| Tier 1 | C#, Go, Python, Ruby, Rust, TypeScript |
| Tier 2 | Java |
| Tier 3 | Kotlin, PHP, Swift |
Alongside the SDKs, the project maintains the MCP Inspector for testing servers and a repository of reference server implementations.
The MCP Registry
The MCP Registry at registry.modelcontextprotocol.io is "the official centralized metadata repository for publicly accessible MCP servers". It stores a server.json record per server (a unique name such as io.github.user/server-name, where to find the package or remote URL, how to run it, and discovery data), not the code itself, which stays on npm, PyPI, Docker Hub or the server's own host. Namespaces are managed through DNS verification, and the registry exposes a REST API plus an OpenAPI specification that private registries can implement.
- Status: in preview, with possible breaking changes or data resets before general availability.
- Public only: the registry "does not support private servers"; organisations host their own registry for internal servers.
- Unopinionated: it is meant to feed downstream aggregators and marketplaces, which add curation and ratings.
Listing in the registry is not a security review. The MCP Registry and Server Publishing Security Guide and MCP Server Trust Assessment cover how to judge a server before use.
Governance and licensing
| Topic | As documented |
|---|---|
| Origin | Introduced by Anthropic on 25 November 2024 with the specification and SDKs, local server support in the Claude desktop apps and an open source server repository; created by David Soria Parra and Justin Spahr-Summers (repository README) |
| Foundation | Donated to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation, on 9 December 2025; AAIF co-founded by Anthropic, Block and OpenAI, with goose and AGENTS.md as fellow founding projects |
| Technical decisions | Remain with the MCP maintainers through Specification Enhancement Proposals (SEPs) and working groups; the blog states the Linux Foundation "will not dictate the technical direction of MCP" |
| Licence | Transitioning from MIT to Apache 2.0: new code and specification contributions are Apache 2.0, documentation is CC-BY-4.0, and contributions without relicensing consent remain MIT |
| Regulation | Supported under the Linux Foundation's EU Cyber Resilience Act stewardship framework (community policies) |
| Roadmap | Updated 22 August 2026: priorities include agentic messaging, HTTP-native transport hardening, agent identity (including DPoP and workload identity federation) and improved primitives |
MCP compared with function calling and APIs
MCP does not replace a model provider's native function calling or an organisation's APIs. Function calling is how a model asks the host to run a tool in one provider's API; MCP standardises where those tools come from, so the same server works across hosts. APIs remain the systems MCP servers call. See MCP vs Native Function Calling, MCP vs OpenAPI Tool Definitions and, for agent-to-agent messaging, the A2A Protocol Security Guide.
Security and identity
Every MCP server is a new path from an AI application into a system, usually holding a credential: an API key, an OAuth token or a service account. That makes MCP servers non-human identities in their own right. The specification addresses part of this through its authorisation rules and security best practices, and the roadmap names agent identity and delegation as a priority. Controls are covered in depth elsewhere on this site, so this page does not repeat them: start with the MCP Security Guide, then Top 10 MCP Security Risks, MCP Static Token Audit and the MCP Gateway and MCP Server Governance Guide. Real incidents show why: the postmark-mcp malicious MCP server case turned a trusted-looking package into a data exfiltration path.
Common misconceptions
- "MCP is an Anthropic product." Anthropic introduced it, but since December 2025 MCP is a founding project of the Agentic AI Foundation under the Linux Foundation, with its own maintainers, working groups and SEP process. Hosts from many providers implement it.
- "An MCP server is a kind of model." A server holds no model. It exposes tools, resources and prompts; the host's model decides when to call them.
- "MCP connections are stateful sessions." That was true of legacy revisions. From 2026-07-28 each request is self-contained, and state across calls is carried in explicit handles.
- "A registry listing means a server is safe." The official registry is deliberately unopinionated metadata. Trust decisions belong to the organisation installing the server.
- "MCP handles authorisation for me." The specification defines how OAuth-based authorisation works for HTTP servers, while the specification says stdio implementations should not follow it and should take credentials from the environment instead, and what each tool may do is still the server owner's design choice.
Practitioner checklist
- Record which MCP protocol revision each host, client SDK and server in your estate supports, and plan for mixed legacy and modern versions.
- Check each SDK's own documentation before adopting 2026-07-28 features; SDKs move on their own schedules.
- Move remaining HTTP+SSE servers to Streamable HTTP, and stop building new features on Roots, Sampling or Logging.
- Prefer Client ID Metadata Documents over Dynamic Client Registration for new OAuth clients, and validate
isson authorisation responses. - Treat the public MCP Registry as discovery metadata, not approval; run your own registry or allow list for internal and sanctioned servers.
- Inventory every MCP server and the credential it holds, and assign each an owner.
- Follow the deprecated features registry and the changelog so the twelve-month deprecation windows do not catch you out.
Standards and references
- Model Context Protocol: Specification 2026-07-28
- Model Context Protocol: Key changes in 2026-07-28
- Model Context Protocol: Versioning and compatibility
- Model Context Protocol: SDKs
- Model Context Protocol: The MCP Registry
- Model Context Protocol: Extensions overview
- MCP Blog: MCP joins the Agentic AI Foundation
- Anthropic: Introducing the Model Context Protocol
Related NHI Mgmt Group resources: MCP Security Guide · MCP Security Best Practices Explained · MCP Authorisation Specification Guide · AI Agent Platforms and MCP Executive Briefing