Written by: Mariana Fonseca, Editorial Team, AI Growth Agent
Key Takeaways
The points below summarize how MCP moves messages, how its transport and session models work, and where it fits beside REST APIs and RAG.
- MCP is an open, vendor-neutral protocol based on JSON-RPC 2.0 that standardizes how AI hosts discover and invoke external tools, resources, and prompts via clearly defined client-server roles.
- Two transport bindings exist: stdio for local, zero-infrastructure servers and Streamable HTTP for remote, scalable deployments with authentication and audit support.
- The 2026-07-28 revision removed protocol-level sessions, which made MCP fully stateless at the wire level while applications still manage state via explicit handles.
- MCP layers on top of existing APIs to provide runtime capability discovery and reduce the M×N integration problem for agents.
How The MCP Protocol Communicates: JSON-RPC 2.0
MCP runs over JSON-RPC 2.0, and all messages MUST be UTF-8 encoded. The wire format follows standard JSON-RPC 2.0 request, response, and notification shapes, and these message patterns are identical on every transport binding.
The example below shows a minimal tool call and its response. Notice the _meta block that carries protocol version and client capabilities, and the resultType field on the response, which the 2026-07-28 revision requires.
// Request { "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "search_docs", "arguments": { "query": "MCP transport options" }, "_meta": { "io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientInfo": { "name": "my-client", "version": "1.0" }, "io.modelcontextprotocol/clientCapabilities": {} } } } // Response { "jsonrpc": "2.0", "id": 1, "result": { "resultType": "complete", "content": [ { "type": "text", "text": "MCP supports stdio and Streamable HTTP transports." } ] } } As of the 2026-07-28 revision, every request carries its protocol version and client capabilities in _meta.io.modelcontextprotocol/* fields. The resultType field is required on all results. Use "complete" for ordinary results and "input_required" for the Multi Round-Trip Request pattern. The initial spec was published on 2024-11-05, with subsequent revisions on 2025-03-26, 2025-06-18, 2025-11-25, and 2026-07-28.
That message format stays constant no matter how the bytes travel. MCP separates the message layer from the transport layer, and the spec defines two standard transport bindings.
Transport Options: Stdio And Streamable HTTP
MCP is RPC-based, and the transport is separate from the message format. The two standard transport bindings are stdio for local servers and Streamable HTTP for remote servers.
stdio is a newline-delimited JSON-RPC binding. The client launches the MCP server as a subprocess, so the two ends communicate over standard streams. The server reads from stdin and writes to stdout, while stderr carries logs. That design removes the need for a network listener or an HTTP layer. stdio is the right transport for:
- Local developer tools, CLI integrations, and file-system servers
- Desktop AI clients like Claude Desktop and Cursor, which launch MCP servers as subprocesses by default
- Zero-infrastructure setups with no server to deploy, port to expose, or authentication to configure
Streamable HTTP exposes a single HTTP endpoint. The client POSTs a JSON-RPC message, and the server responds with either a plain JSON object for short calls or a request-scoped SSE stream for long-running operations. Streamable HTTP is the right transport for:
- Remote MCP servers and multi-tenancy deployments
- Enterprise requirements including authentication, RBAC, audit trails, and horizontal scaling
- Cloud infrastructure deployments on Kubernetes or serverless where long-lived connections are a liability
The legacy HTTP+SSE transport was deprecated in spec version 2025-03-26 and reclassified as Deprecated under the feature lifecycle policy introduced in 2026-07-28, with a minimum twelve-month deprecation window before removal.
Stateful Versus Stateless Sessions
Sessions in early MCP versions meant a connection-scoped context established by an initialize/initialized handshake. Within that context, the server could maintain state and the client was pinned to the issuing server instance. The related search phrase “mcp protocol stateless” reflects genuine confusion about how this model changed across spec revisions.
The 2025-03-26 revision introduced session management via the Mcp-Session-Id header. Clients had to include that header on every subsequent request, which pinned traffic to the specific container or pod holding in-memory session state. Google Cloud engineers identified four production bottlenecks from this model: round-robin load balancers returning 400 errors when requests hit the wrong pod, forced sticky session affinity that blocked efficient autoscaling, zero fault tolerance on pod restarts, and complex infrastructure demands such as shared Redis session stores.
The 2026-07-28 revision removed protocol-level sessions and the Mcp-Session-Id header entirely (SEP-2567 and SEP-2575), which made the protocol stateless at the protocol layer. Every request now carries its protocol version, client identity, and client capabilities in _meta. These travel in the io.modelcontextprotocol/protocolVersion and io.modelcontextprotocol/clientCapabilities fields. Any request can land on any server instance behind a plain round-robin load balancer without shared storage.
As Microsoft Engineering Manager Jeff Handley noted: “’Stateless protocol’ doesn’t mean ‘stateless application.’ If your server needs to carry state across calls, do what HTTP APIs have always done: mint an explicit handle from one tool (a basketId, a browserId) and have the model pass it back as an ordinary argument on later calls.” Servers needing cross-call state use explicit, server-minted handles passed as ordinary tool arguments rather than relying on a protocol-level session.
MCP Protocol Versus A Traditional API
MCP defines how AI clients discover and call tools, while the underlying API still performs the business logic.
The distinction that matters is what MCP standardizes that REST does not. REST APIs have no self-description at runtime and depend on OpenAPI specs, SDKs, or documentation the client must already know about. MCP provides built-in runtime capability discovery via tools/list, which returns names, descriptions, and JSON Schema for each tool. A compliant MCP server can be added to a client that has never heard of the product and be useful in the same session, with no code generation, SDK release, or client-side version bump.
The recommended architecture is LLM agent to MCP server to REST API. The MCP server translates agent tool calls into REST requests, and the underlying REST API remains unchanged. GitHub’s MCP server illustrates this. When a Claude agent calls create_issue, the MCP server translates it into a POST /repos/{owner}/{repo}/issues call to GitHub’s REST API, which never needs to know an agent called it.
In MCP, the method name travels in the JSON-RPC body, never in the path, and every request goes to the same URL. A conventional REST call uses distinct paths and HTTP verbs. MCP also reduces the M×N integration problem. Without a standard protocol, connecting M agents to N services requires N×M custom adapters. MCP collapses that to N+M by having each service build one MCP server and each agent build one MCP client.
See how Blog MCP exposes your content to agent crawlers.
MCP Protocol Versus RAG
MCP invokes tools as actions, while RAG retrieves data as context. These mechanisms solve different problems at different layers of an AI system.
RAG is a technique, not a protocol. There is no RAG specification and no RAG client-server handshake. RAG is an architecture built with an embedding model, a vector database, and retrieval logic glued in front of an LLM call. Its standard mechanics are three steps: indexing (documents chunked and converted into vector embeddings), retrieval (the query is embedded and a similarity search finds the most semantically related passages), and augmentation (retrieved passages are inserted into the prompt as context).
MCP is an open standard with a defined message format and transport bindings. RAG is read-only by nature, while MCP can be read-only or read-write and supports actions with side effects such as sending an email or creating a ticket. MCP data freshness matches the underlying system the server queries, often in real time. RAG data freshness matches the last index or embedding update.
A common production pattern is exposing a RAG pipeline as an MCP tool. The vector search and reranking logic lives inside an MCP server that exposes a single search_knowledge_base tool, so the AI application calls it like any other tool without knowing RAG is happening under the hood. Most production agents use both, routing each piece of context to the layer that fits its properties: RAG for large, slow-changing, read-only knowledge, and MCP for live, volatile, or write-required data.
Local Versus Remote Servers
stdio servers run locally as subprocesses, launched by the client in the same user context. Streamable HTTP servers are ordinary hosted services behind existing infrastructure, deployed the way any other web service is deployed. Only stdio MCP servers have to run on the user’s machine. A Streamable HTTP MCP server is a standard HTTPS endpoint that scales on commodity HTTP infrastructure.
Server-to-server calls sit outside the core MCP protocol pattern. Servers do not initiate JSON-RPC requests and clients do not send JSON-RPC responses. A process that needs to call another MCP server must do so as a client. Some orchestration frameworks build multi-server workflows by having an agent client call multiple MCP servers in sequence, which remains an application-layer pattern rather than a protocol feature.
What Developers Report Running MCP Servers In Production
Teams often start with stdio because it is fast to wire up locally, then hit a wall the moment a second user shows up or a security team asks for an audit trail. stdio provides no audit trail and is one client per process, so multi-user deployments require a wrapper or a gateway that takes on the networking, authentication, and lifecycle work that Streamable HTTP already handles.
The gap between demo servers and production servers is real. An automated survey of open-source MCP server repositories found that most had no application-level reference to the MCP session ID, which suggests most servers were already operating without meaningful session state. The 2026-07-28 revision formalizes what the ecosystem was already doing in practice.
The stateless revision also changes infrastructure requirements significantly. Cloudflare’s Code Mode MCP Server for the entire Cloudflare API, released in February 2026 using an unofficial stateless mode, scaled to thousands of requests per second and served billions of tool calls. The GitHub MCP Server upgraded to the 2026-07-28 spec and completely removed Redis session storage.
Where The MCP Protocol Meets Publishing: AI Growth Agent
Once agents can call tools over MCP, brands need their content exposed in the formats those agents consume. AI Growth Agent focuses on that publishing layer.
AI Growth Agent ships Blog MCP, which is also compatible with Chrome 146+ and other WebMCP-enabled browsers. The product exposes schema, manifest, discovery, and capability guidance to agents. It serves OpenAI discovery and Agent Card guidance via /.well-known/. It publishes llms.txt and llms-full.txt and serves Markdown to agent crawlers. It also supports natural language query parameters via /?s={query}, which auto-trigger personalized, internally linked responses. AI Growth Agent was the first to bring Blog MCP to market, with clients running it in the summer of 2025, roughly a year before Google released Web MCP.
The MCP protocol is how agents reach tools. AI Growth Agent makes the brand’s own content reachable the same way, on a site the client owns, with the full technical and agentic SEO stack included in every package. Clients average more than 12,000 additional AI citations and mentions across the first twelve weeks, with content indexing in as little as ten days.
Explore whether Blog MCP fits your publishing roadmap.
Conclusion
MCP operates as a real protocol at the wire level, with JSON-RPC 2.0 messages, two standard transport bindings, and a session model that evolved from stateful initialization to fully stateless per-request metadata. It serves as the discovery and invocation layer between an LLM agent and the REST APIs that perform the underlying work. RAG functions as a retrieval technique with no spec or handshake, while MCP provides an open standard with both.
Once agents can reach tools over MCP, the content those agents read and cite has to be structured for them. AI Growth Agent puts MCP to work at the publishing layer, making the brand’s content reachable by the agents MCP connects, on a site the client owns, with the full technical and agentic SEO stack included. Traditional search tools show you where your brand stands. AI Growth Agent makes your brand the answer.
Book a kickoff and see your first article live within a week.
