The Model Context Protocol (MCP) spec received a major update on July 28, fundamentally altering how servers manage state and communication. Developers who built infrastructure around the previous version are now facing a significant migration path. The core shift moves MCP from a persistent, session-based model—akin to a phone call—toward a stateless, request-response architecture, comparable to texting. This change eliminates the need for long-lived connections and server-side memory, prioritizing scalability and debuggability over bidirectional interactivity.

The Death of the Session Store

The most immediate impact is the removal of server-side session management. Previously, servers maintained Redis instances to map session IDs to client capabilities. Under the new spec, every request carries its own _meta field, including protocolVersion, clientInfo, and capabilities. This makes each request self-contained, allowing servers to run multiple instances behind a load balancer without complex session stickiness. While slightly more verbose in payload size, this approach drastically simplifies horizontal scaling.

Transport and Routing Changes

Developers must abandon WebSocket transports in favor of plain HTTP. The new Mcp-Method and Mcp-Name HTTP headers allow gateways to route and rate-limit requests without parsing JSON bodies, reducing gateway configuration complexity significantly. Additionally, the initialize handshake is no longer mandatory; servers can be called directly, or queried via a new server/discover endpoint. For caching, the ttlMs and cacheScope fields in tools/list responses enable aggressive CDN caching, reducing server load during high-traffic periods.

Deprecated Features and New Patterns

Three legacy features—Roots, Sampling, and Logging—are slated for deprecation within 12 months. Roots functionality is replaced by passing working directories as explicit tool arguments. Sampling, which allowed servers to request model completions from clients, is superseded by the client handling these requests via MRTR (Model Request to Resource) patterns. Logging is now expected to use standard observability stacks rather than the MCP stream. Interactive flows that previously required bidirectional WebSocket communication now use an inputRequired response pattern, where the server returns a prompt and the client re-sends the tool call with necessary data.

Serverless and SDK Benefits

The stateless architecture unlocks serverless deployment options. Developers can move MCP servers from long-lived VPS processes to platforms like Cloudflare Workers, where costs drop to near zero and infrastructure scales to zero when idle. The TypeScript SDK v2.0 simplifies this transition, with most code changes involving the deletion of session middleware and WebSocket transport logic rather than complex rewrites.

Key Takeaways

  • Statelessness is King: Remove session stores; every request must include client metadata in _meta.
  • HTTP Over WebSockets: Switch to plain HTTP transport and use Mcp-Method headers for routing.
  • Serverless Ready: The stateless architecture allows MCP servers to run on platforms like Cloudflare Workers, scaling to zero.
  • Deprecation Warning: Roots, Sampling, and Logging are deprecated; migrate to explicit arguments and standard observability tools.
  • Interactive Flows: Use inputRequired responses to handle mid-call data needs instead of bidirectional streams.

The Bottom Line

While the migration requires deleting significant chunks of legacy code, the move to stateless HTTP is an unambiguous win for scalability and debuggability. Developers should start migrating now, as the SDKs are stable and the 12-month deprecation window for legacy features will close faster than expected.