Why Upgrading Your MCP Server to 2.0 Solves Stateless Session Issues

Problems with MCP 1.x

When an MCP service is deployed on a Kubernetes cluster, each client establishes a stateful session by first calling initialize / initialized and receiving a Mcp-Session-Id. The server keeps the session context in memory, so if a node crashes the client loses its session, all requests fail, sticky sessions are required for load balancing, and serverless runtimes cannot run.

How MCP 2.0 Fixes the Issue

On 2026‑07‑28 the MCP specification was updated to a stateless model. The handshake is removed; every request carries a self‑describing _meta field that includes protocol version, client identity, and capability claims. The method name is conveyed via the Mcp-Method HTTP header and the service name via Mcp-Name. Version negotiation is performed inline: if the server does not support the requested version it returns UNSUPPORTED_PROTOCOL_VERSION (-32022) together with a list of supported versions, prompting the client to retry with a compatible version.

HTTP Header Constraints

The gateway can route and rate‑limit based on Mcp-Method and Mcp-Name without unpacking JSON. The MCP-Protocol-Version header must match the version declared in _meta; otherwise the server responds with HTTP 400.

Request Polling Replaced by MRTR

MCP 1.x relied on a Server‑Sent Events (SSE) long‑connection for the server to ask the client for input, which broke on network jitter. MCP 2.0 introduces MRTR (Multi‑Round Request). When the server needs additional input it ends the current request and returns a requestState token. The client collects the input, then resends a new HTTP request containing inputResponses and the original requestState. Each round is an independent HTTP request, allowing any node in the cluster to deserialize the state and continue processing.

Quick Start Code

Using the MCP SDK V2, a server can be created with createMcpHandler from @modelcontextprotocol/server v2. The factory function is invoked for every incoming HTTP request, producing a fresh McpServer instance:

const handler = createMcpHandler(({ era }) => {
  const instanceId = randomUUID();
  console.error(`[factory] era=${era} instance=${instanceId}`);
  const server = new McpServer({
    name: 'pig-release-gate',
    version: '1.0.0'
  });
  server.registerTool('check_pig_release', {
    description: 'Determine if PIG service should be released based on error rate, open incidents, and change window',
    inputSchema: deployGateInput,
    outputSchema: deployGateOutput
  }, async (input) => {
    const reasons = evaluateDeployment(input);
    const decision = reasons.length === 0 ? 'allow' : 'block';
    return {
      content: [{ type: 'text', text: summary }],
      structuredContent: { ...result, instanceId }
    };
  }, { legacy: 'reject' });
  return server;
});

The legacy: 'reject' flag tells the handler to accept only the 2026‑07‑28 protocol and reject 1.x handshake requests. To support both versions, change the flag to legacy: 'stateless'.

Deployment Options

createMcpHandler

returns a standard { fetch } object that can be exported directly to Cloudflare Workers, Deno, or Bun. In a Node.js environment, wrapping it with toNodeHandler allows mounting on Express, Fastify, or the native node:http server.

Client Side

The client locks the protocol version to 2026-07-28 via versionNegotiation:

const client = new Client({
  name: 'lengleng-pig-release-client',
  version: '1.0.0'
}, {
  versionNegotiation: { mode: { pin: '2026-07-28' } }
});
await client.connect(new StreamableHTTPClientTransport(endpoint));
assert.equal(client.getProtocolEra(), 'modern');

Test Results

Two scenarios were executed with the same tool:

Safe scenario (low error rate, no open incidents, approved change window) returned:

{
  "decision": "allow",
  "reasons": [],
  "instanceId": "a1b2c3d4-..."
}

Risk scenario (error rate 1.7%, two open incidents) returned:

{
  "decision": "block",
  "reasons": [
    "仍有 2 个故障未关闭",
    "生产环境错误率 1.7% 已达到 1% 门槛"
  ],
  "instanceId": "e5f6g7h8-..."
}

The differing instanceId values show that the factory was invoked twice, creating two separate McpServer instances, confirming that no cross‑request session state is reused.

Conclusion

The official Java SDK has not yet adapted to the stateless features of MCP 2.0 and returns HTTP 500, while the TypeScript SDK is the first Tier‑1 SDK to support the 2026‑07‑28 specification. A single call to createMcpHandler suffices to build a stateless MCP server.