Skip to content
  1. Home
  2. AI agents
  3. Tools, MCP and agent-to-agent
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. MCP sits on top of your APIs and underneath the model’s function calling. It replaces only the custom glue between them.
MCP roles, transports and what a 2026-07-28 request carriesA host, the AI application, runs one MCP client per connection. Client A talks to MCP server A, which wraps the ticketing API; client B talks to MCP server B, which wraps a database. Messages are JSON-RPC over stdio for a local server or Streamable HTTP for a remote one. Since the 2026-07-28 specification every request is self-contained: _meta carries the protocol version, client capabilities and client identity; Mcp-Method and Mcp-Name headers let gateways route without parsing the body; state is a handle the server hands out and the client passes back as an ordinary argument; and the reply is a result or input_required, after which the client retries the call with the input attached.Host, clients, serversHost (the AI app)Agent, model, instructionsMCP client AMCP client BJSON-RPC over stdio (local) or Streamable HTTP (remote)MCP server Awraps the ticketing APIMCP server Bwraps a databaseTicketing systemthe system behind the APIDatabaseread with a scoped accountWhat a 2026-07-28 request carries_metaversion, capabilities,client identityHeadersMcp-Method, Mcp-Namefor routingStatehandle passed backas an argumentReplyresult, orinput_required and retryMCP roles, transports and what a 2026-07-28 request carriesA host, the AI application, runs one MCP client per connection. Client A talks to MCP server A, which wraps the ticketing API; client B talks to MCP server B, which wraps a database. Messages are JSON-RPC over stdio for a local server or Streamable HTTP for a remote one. Since the 2026-07-28 specification every request is self-contained: _meta carries the protocol version, client capabilities and client identity; Mcp-Method and Mcp-Name headers let gateways route without parsing the body; state is a handle the server hands out and the client passes back as an ordinary argument; and the reply is a result or input_required, after which the client retries the call with the input attached.Host, clients, serversHost (the AI app)Agent, model, instructionsMCP client AMCP client BJSON-RPC: stdio or Streamable HTTPMCP server Awraps the ticketing APIMCP server Bwraps a databaseTicketing systemthe system behind the APIDatabaseread with a scoped accountA 2026-07-28 request carries_metaversion, capabilities,client identityHeadersMcp-Method, Mcp-Namefor routingStatehandle passed backas an argumentReplyresult, orinput_required and retry
A host runs one MCP client per server. Since 2026-07-28 each request is self-contained: version, capabilities and identity travel in _meta, routing headers sit on the POST, and state is a handle the client passes back.

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 tutorialIn 2026-07-28
initialize handshake, then capability negotiationNo 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 serverNo session header; a state handle the client passes back as an argument
HTTP+SSE transport with a GET streamStreamable 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 clientinput_required and a retried call; roots and sampling deprecated
Tasks in the core protocolio.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.

QuestionAPIFunction callingMCP
Who defines itThe system ownerThe 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 describesEndpoints, request and response shapesA tool name, description and JSON Schema per model callTools, resources and prompts a server offers, discoverable at run time
Who calls itAny program with credentialsThe model asks; your code runs itAny MCP client, with the model asking through function calling underneath
StateDepends on the APINone between callsStateless since 2026-07-28; state handles passed as arguments
Where it is reusedEverywhere alreadyInside one applicationAcross 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

CapabilityMicrosoftAWSGoogle
Where agents use MCPCopilot Studio (GA 29 May 2025); Microsoft 365 Copilot plugins; Foundry MCP tool with public and private (VNet) endpointsAgentCore Gateway (GA 13 Oct 2025) in front of OpenAPI, Lambda and existing MCP servers; AgentCore Runtime hosts serversGemini Interactions API remote MCP; Agent Platform tools behind Agent Gateway (GA 18 Jun 2026)
Vendor-published serversAzure 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 documentationManaged remote servers for about 80 products, from BigQuery to Cloud Run, several preview; Workspace servers in developer preview
Spec versions and transportsFoundry MCP tool page lists no version; Copilot Studio SSE transport in previewGateway accepts 2026-07-28, 2025-11-25, 2025-06-18 and 2025-03-26Streamable HTTP only on the Interactions API
Authorization optionsFoundry: key, Entra identity, Entra user delegation, OAuth identity passthrough; API Management: Entra JWT policyGateway outbound: OAuth two-legged, three-legged and token exchange, IAM SigV4, API keys; inbound OAuth or IAMIAM 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

MCP securityRead MCP vs A2ARead
MCP gateways and registriescoming
Tool calling and actionscoming

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.

  1. Introduction to the Model Context Protocol Model Context Protocol, undated page, read 2 November 2026
  2. Model Context Protocol specification changelog, 2026-07-28 Model Context Protocol, 28 July 2026
  3. The 2026-07-28 specification Model Context Protocol blog, 28 July 2026
  4. Authorization, specification 2026-07-28 Model Context Protocol, 28 July 2026
  5. Transports, specification 2026-07-28 Model Context Protocol, 28 July 2026
  6. Security best practices, 2026-07-28 Model Context Protocol, 28 July 2026
  7. Specification versioning Model Context Protocol, undated page, read 2 November 2026
  8. Extensions overview Model Context Protocol, undated page, read 2 November 2026
  9. Specification changelog, 2025-11-25 Model Context Protocol, 25 November 2025
  10. Specification changelog, 2025-06-18 Model Context Protocol, 18 June 2025
  11. Specification changelog, 2025-03-26 Model Context Protocol, 26 March 2025
  12. Enterprise-Managed Authorization is stable Model Context Protocol blog, 18 June 2026
  13. MCP Apps: the first official MCP extension Model Context Protocol blog, 26 January 2026
  14. Client registration in MCP Model Context Protocol blog, 22 August 2025
  15. MCP joins the Agentic AI Foundation Model Context Protocol blog, 9 December 2025
  16. Introducing the Model Context Protocol Anthropic, 25 November 2024
  17. Scaling AI agent infrastructure with the MCP stateless updates Google Developers Blog, 5 August 2026
  18. Expose a REST API as an MCP server in Azure API Management Microsoft Learn, 20 October 2026
  19. Model Context Protocol tool in Foundry Agent Service Microsoft Learn, 29 October 2026
  20. Model Context Protocol is now generally available in Microsoft Copilot Studio Microsoft Copilot blog, 29 May 2025
  21. MCP and API plugins for Microsoft 365 Copilot Microsoft Learn, 28 October 2026
  22. Announcing the Azure MCP Server stable release Azure SDK Blog, 28 October 2025
  23. Remote GitHub MCP Server is now generally available GitHub changelog, 4 September 2025
  24. MCP server targets for AgentCore Gateway AWS documentation, undated page, read 2 November 2026
  25. AWS MCP Server is now generally available AWS What’s New, 6 May 2026
  26. Announcing official MCP support for Google services Google Cloud blog, 10 December 2025
  27. MCP servers overview (Google Cloud) Google Cloud, undated page, read 2 November 2026
  28. MCP servers: supported products Google Cloud, undated page, read 2 November 2026
  29. Model Armor release notes Google Cloud, undated page, read 2 November 2026
  30. Gemini function calling Google AI for Developers, undated page, read 2 November 2026
  31. Connectors and MCP guide OpenAI developer documentation, undated page, read 2 November 2026
  32. OpenAI API changelog OpenAI developer documentation, undated page, read 2 November 2026
  33. MCP connector Anthropic Claude documentation, undated page, read 2 November 2026

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