- Home
- AI agents
- Tools, MCP and agent-to-agent
- What is MCP?
Build · Tools, MCP and agent-to-agent
What is MCP?
MCP, the Model Context Protocol, is an open standard that lets an AI application connect to tools and data through one common interface instead of a custom integration for each system. A system exposes its capabilities once as an MCP server, and any MCP-capable client can find and call them. The current specification is 2026-07-28.
In this guide: 83 pages
Key takeaways
- An MCP server describes a system’s tools, resources and prompts once; any client that speaks MCP can use them. The official documentation calls it a USB-C port for AI applications.
- The 2026-07-28 specification is stateless. If a tutorial shows an initialize handshake, a session id or an HTTP+SSE transport, it describes the 2025 protocol.
- A remote server is an OAuth 2.1 resource server: tokens are bound to one server, clients use PKCE, and a server must never forward a token meant for somewhere else.
- MCP sits on top of your APIs and underneath the model’s function calling. It replaces only the custom glue between them.
How does MCP work?
An MCP host, the AI application, runs one client per connection; each client talks to one server, and the server wraps a system such as a database, a SaaS API or a file system. Messages are JSON-RPC 2.0 over one of two transports: stdio for a local server or Streamable HTTP for a remote one.
A server offers three primitives. Tools are actions the model can call, each with a JSON Schema for inputs and, optionally, outputs; since 2025-11-25 the default dialect is JSON Schema 2020-12. Resources are readable data behind URIs, such as a document or a table. Prompts are reusable templates a client can offer its users. On the client side, elicitation lets a server ask the user for input, including a URL mode for an OAuth or payment page handled outside the chat.
Over stdio the client starts the server as a subprocess and the two exchange newline-delimited JSON. Over Streamable HTTP each message is an HTTP POST to a single endpoint, and the reply comes back as JSON or as a server-sent event stream scoped to that one request; a single subscriptions/listen stream carries change notifications. The original HTTP+SSE transport of 2024 was replaced by Streamable HTTP in March 2025 and formally deprecated in July 2026. Copilot Studio, OpenAI’s Responses API and Anthropic’s connector still accept it for compatibility, while Gemini’s Interactions API takes Streamable HTTP only.
Versions are date strings marking the last backward-incompatible change, and a client or server may support several at once. A client built for 2026-07-28 falls back to the handshake-based protocol when it meets a server on 2025-11-25 or earlier. Optional features live in extensions negotiated through an extensions capability, each off by default and moving through experimental, beta and stable stages. MCP Apps (interactive HTML returned by a tool, launched 26 Jan 2026), Enterprise-Managed Authorization and OAuth Client Credentials are stable; Tasks, Skills over MCP and Server Cards are beta.
What changed in the 2026-07-28 specification?
The core became stateless. There is no initialize handshake and no Mcp-Session-Id; every request carries what the server needs to handle it on its own, so any server instance behind a plain load balancer can answer. Several 2025 features were deprecated at the same time.
Each request now carries its protocol version, client capabilities and client identity in _meta, and a mandatory server/discover call advertises the versions and capabilities a server supports. A server that needs state across calls, a shopping cart for example, hands the model an explicit handle and gets it back as an ordinary argument on the next call. Because that handle passes through the client, the spec tells servers to sign or encrypt it, bind it to the user, and never treat possession of a handle as authentication.
Server-to-client requests over a held-open stream are gone. Instead of calling elicitation/create or sampling/createMessage back into the client, a server returns input_required and the client retries the original call with the input attached, which the spec calls a multi round-trip request. Every POST must carry Mcp-Method and Mcp-Name headers so gateways and web application firewalls can route and filter without parsing the body, and list results must include a cache lifetime and scope; tools should also come back in a deterministic order so model prompt caches hit more often.
Deprecated, with a 12-month minimum offramp under the new lifecycle policy: the HTTP+SSE transport, dynamic client registration (in favour of Client ID Metadata Documents), and the roots, sampling and logging features. Tasks, experimental in 2025-11-25, moved out of the core into the io.modelcontextprotocol/tasks extension, where a client polls tasks/get. SSE resumability through Last-Event-ID was removed, and the resource-not-found error code changed from -32002 to -32602. GitHub’s remote server removed its Redis session storage after the change, and Google’s team, which maintains the Go SDK, shipped v1.7.0 on release day.
What a 2025-era tutorial shows, and what the current specification does instead.
| In the tutorial | In 2026-07-28 |
|---|---|
| initialize handshake, then capability negotiation | No handshake; version and capabilities in _meta on every request; server/discover to learn what a server supports |
| Mcp-Session-Id header keeps state on the server | No session header; a state handle the client passes back as an argument |
| HTTP+SSE transport with a GET stream | Streamable HTTP with a single POST endpoint and subscriptions/listen; HTTP+SSE deprecated |
| Dynamic client registration (RFC 7591) | Client ID Metadata Documents; dynamic registration deprecated |
| Server calls sampling, elicitation or roots on the client | input_required and a retried call; roots and sampling deprecated |
| Tasks in the core protocol | io.modelcontextprotocol/tasks extension, beta, polled with tasks/get |
How does authorization work for a remote MCP server?
A remote MCP server is an OAuth 2.1 resource server and the client is an OAuth client. The server publishes protected resource metadata (RFC 9728) so the client can find the authorization server, the client uses PKCE (a proof that the party redeeming the authorization code is the one that requested it) and sends a resource parameter so the token is bound to that server, and the server validates the audience of every token it receives.
Six requirements are normative in 2026-07-28: the server implements RFC 9728; the client supports both RFC 8414 metadata and OpenID Connect discovery; the client includes the resource parameter (RFC 8707) in authorization and token requests; the server validates the token audience; the server never accepts or forwards any other token, which the spec calls the token passthrough prohibition; and the client validates the iss parameter (RFC 9207) when it is present. A local stdio server takes credentials from its environment instead.
Client registration changed twice. Open dynamic client registration (RFC 7591) let any client register itself with an authorization server, which enterprises did not want. The 2025-11-25 revision introduced Client ID Metadata Documents: the client uses an HTTPS URL as its client_id and the authorization server fetches the client’s metadata from that URL. In 2026-07-28 dynamic registration is deprecated and kept only for authorization servers without CIMD support.
Two authorization extensions are stable. OAuth Client Credentials covers machine-to-machine use. Enterprise-Managed Authorization (stable since 18 Jun 2026) lets the client obtain an identity assertion grant from the corporate identity provider during single sign-on, so users reach a server with no per-app consent screen and IT sets policy centrally. Okta was the first identity provider; Claude, Claude Code, Cowork and VS Code (preview) the first clients; Asana, Atlassian, Canva, Figma, Granola, Linear and Supabase the first servers. The underlying ID-JAG grant was still an IETF draft on 2 Nov 2026. Minimal scopes are the spec’s recommendation: request the least scope first and let the server challenge for more through WWW-Authenticate.
How is MCP different from function calling and from an API?
An API is the contract a system offers to any caller; function calling is the model-vendor feature that returns a structured tool call for your code to run; MCP is the standard layer between them that describes tools so any client can discover them. Most clients turn each MCP tool into a function-calling tool for the model.
Three layers that get confused with each other.
| Question | API | Function calling | MCP |
|---|---|---|---|
| Who defines it | The system owner | The model vendor (OpenAI function_call, Claude tool_use, Gemini function_call) | The MCP project, under the Agentic AI Foundation since 9 Dec 2025 |
| What it describes | Endpoints, request and response shapes | A tool name, description and JSON Schema per model call | Tools, resources and prompts a server offers, discoverable at run time |
| Who calls it | Any program with credentials | The model asks; your code runs it | Any MCP client, with the model asking through function calling underneath |
| State | Depends on the API | None between calls | Stateless since 2026-07-28; state handles passed as arguments |
| Where it is reused | Everywhere already | Inside one application | Across agents, IDEs and chat clients that speak MCP |
MCP does not replace an API, and it does not decide which tools a model sees; what it removes is the custom adapter between the two. Microsoft 365 Copilot plugins, Foundry tools, AgentCore Gateway targets and OpenAI’s remote MCP tool all consume servers the same way, which is why a server written once can serve several platforms.
How do Microsoft, AWS and Google implement it?
Where each cloud speaks MCP, with statuses as the vendor pages showed on 2 Nov 2026.
Capability, Microsoft, AWS, Google
| Capability | Microsoft | AWS | |
|---|---|---|---|
| Where agents use MCP | Copilot Studio (GA 29 May 2025); Microsoft 365 Copilot plugins; Foundry MCP tool with public and private (VNet) endpoints | AgentCore Gateway (GA 13 Oct 2025) in front of OpenAPI, Lambda and existing MCP servers; AgentCore Runtime hosts servers | Gemini Interactions API remote MCP; Agent Platform tools behind Agent Gateway (GA 18 Jun 2026) |
| Vendor-published servers | Azure MCP Server 1.0 (28 Oct 2025); remote GitHub MCP Server (GA 4 Sep 2025); any API Management REST API as a server (GA 18 Nov 2025) | AWS MCP Server for any AWS API (GA 6 May 2026, us-east-1 and eu-central-1); AWS Knowledge MCP Server for documentation | Managed remote servers for about 80 products, from BigQuery to Cloud Run, several preview; Workspace servers in developer preview |
| Spec versions and transports | Foundry MCP tool page lists no version; Copilot Studio SSE transport in preview | Gateway accepts 2026-07-28, 2025-11-25, 2025-06-18 and 2025-03-26 | Streamable HTTP only on the Interactions API |
| Authorization options | Foundry: key, Entra identity, Entra user delegation, OAuth identity passthrough; API Management: Entra JWT policy | Gateway outbound: OAuth two-legged, three-legged and token exchange, IAM SigV4, API keys; inbound OAuth or IAM | IAM allow and deny policies; Model Armor scanning of MCP calls (GA 22 Apr 2026) |
OpenAI and Anthropic also speak MCP: the Responses API has had remote MCP since 20 May 2025, and Anthropic’s MCP connector is beta, tools only, and has pinned tool lists since its 2026-09-15 header.
Frequently asked questions
Is MCP only for Claude?
No. Anthropic released it on 25 Nov 2024 and donated it to the Linux Foundation’s Agentic AI Foundation on 9 Dec 2025. Copilot Studio, Microsoft Foundry, AgentCore, Gemini, ChatGPT and the OpenAI API all speak it, and the official SDKs cover TypeScript, Python, Go, C# and Ruby.
What is an MCP server?
A program that wraps one system and describes its tools, resources and prompts in the MCP format so a client can discover and call them. It runs as a local subprocess over stdio or as a remote HTTP service, and a remote one is an OAuth 2.1 resource server with its own protected resource metadata.
Why do most tutorials show an initialize handshake and a session id?
Because they were written for the 2025 revisions. The 2026-07-28 specification removed both: version, capabilities and identity travel in _meta on every request, and state is a handle the client passes back. Current clients still fall back to the old handshake for older servers, so old code runs, but new servers should not be written that way.
Does MCP replace our APIs?
No. An MCP server sits in front of an API and describes it for agents; the API keeps doing the work. Azure API Management and AgentCore Gateway generate the MCP layer from an existing REST or OpenAPI definition, so the API itself changes nothing.
Should we use MCP resources and prompts, or only tools?
Start with tools. Azure API Management and Anthropic’s connector support tools only, and most gateways and registries catalogue tools first. Resources and prompts are useful inside a client you control, such as an IDE; through a gateway, check what it supports before an agent depends on them.
More in Tools, MCP and agent-to-agent
Sources
Each source was read on 2 November 2026. The date shown is the date on the page, or the page’s ms.date for Microsoft Learn; an undated page shows the date it was read.
- Introduction to the Model Context Protocol
- Model Context Protocol specification changelog, 2026-07-28
- The 2026-07-28 specification
- Authorization, specification 2026-07-28
- Transports, specification 2026-07-28
- Security best practices, 2026-07-28
- Specification versioning
- Extensions overview
- Specification changelog, 2025-11-25
- Specification changelog, 2025-06-18
- Specification changelog, 2025-03-26
- Enterprise-Managed Authorization is stable
- MCP Apps: the first official MCP extension
- Client registration in MCP
- MCP joins the Agentic AI Foundation
- Introducing the Model Context Protocol
- Scaling AI agent infrastructure with the MCP stateless updates
- Expose a REST API as an MCP server in Azure API Management
- Model Context Protocol tool in Foundry Agent Service
- Model Context Protocol is now generally available in Microsoft Copilot Studio
- MCP and API plugins for Microsoft 365 Copilot
- Announcing the Azure MCP Server stable release
- Remote GitHub MCP Server is now generally available
- MCP server targets for AgentCore Gateway
- AWS MCP Server is now generally available
- Announcing official MCP support for Google services
- MCP servers overview (Google Cloud)
- MCP servers: supported products
- Model Armor release notes
- Gemini function calling
- Connectors and MCP guide
- OpenAI API changelog
- MCP connector
Planning an AI program?
Talk to the team that builds it and runs it after launch.
- Built to SOC 2, HIPAA and GDPR standards
- EU AI Act-aligned delivery
- Microsoft Solutions Partner