MCP Toolbox adds support for the new 2026–07–28 MCP spec

Written by: Averi Kitsch, Staff Software Engineer @ Google (LinkedIn)

The Model Context Protocol (MCP) 2026–07–28 specification is now live. Its shift to a stateless model directly addressing the scaling bottlenecks for AI-agent infrastructure.

MCP Toolbox for Databases (v1.8.0+) natively supports the new specification, as do our Python, Go, and JS/TS SDKs. You can start building with the updated protocol versions today.

Why Statelessness Matters

Before this update, MCP required a strict handshake (specifically the initialize method) to coordinate capabilities between clients and servers. That model works fine for local desktop setups, but it falls apart in at-scale environments where servers run horizontally on serverless platforms like Cloud Run.

The new stateless standard changes the way clients and servers interact:

No more handshakes. Clients discover server capabilities on demand using the new server/discover endpoint. This means you do not need sticky sessions or centralized session stores to route traffic across multiple server instances.
Standardized HTTP headers. To make stream routing work properly, requests must now include standardized routing metadata like Mcp-Method and Mcp-Name. The Toolbox Server validates these headers against the request payloads to keep connections secure.

Check out The Future is Stateless: MCP 2026 Draft Spec Arrives in MCP Toolbox for a more in-depth review of MCP spec changes and benefits.

Silent Version Negotiation

In our draft releases, testing the new protocol required starting the server with an explicit CLI flag: –enable-draft-specs.

In MCP Toolbox Server v1.8.0, we have removed this flag. The server now negotiates the 2026–07–28 protocol version automatically. When a client connects, the server reads the request capabilities and matches them to the highest supported version. Your existing production workloads can keep running on older specs while you upgrade individual clients.

Client Setup

You can update your clients to the stateless version by changing a single parameter in your initialization code.

🐍 Python SDK (v1.3.0+)

The Python SDK uses the updated Protocol enum to toggle the transport layer. The client automatically switches to the new stateless HTTP transport.

from toolbox_core import ToolboxClient, Protocol

# Opt-in to the latest stateless protocol version
# Or use Protocol.MCP_LATEST to always use the latest stable version
async with ToolboxClient("http://localhost:5000", protocol=Protocol.MCP_v20260728) as client:
    tool = await client.load_tool("my-tool")
    result = await tool(param="my input")
    print(result)

📦 JS/TypeScript SDK (v1.1.0+)

For Node.js and web clients, pass the latest protocol constant when initializing the client.

import { ToolboxClient, Protocol } from '@toolbox-sdk/core';

const client = new ToolboxClient(
  'http://localhost:5000',
  undefined,
  undefined,
  protocol: Protocol.MCP_v20260728 // Or use Protocol.MCP_LATEST to always use the latest stable version
);
let tool = await client.loadTool("my-tool");
const result = await tool({input:"my input"});
console.log(result);

🐹 Go SDK (v1.1.0+)

This release is coming soon!

For Go, use the new client option to enable the updated protocol behaviors automatically.

package main

import (
 "context"
 "fmt"
 "github.com/googleapis/mcp-toolbox-sdk-go/core"
)

func main() {
  ctx := context.Background()

  client, err := core.NewToolboxClient(
    "http://localhost:5000", 
    core.WithProtocol(core.MCPLatest) // Or use core.MCPLatest to always use the latest stable version
  )
  if err != nil {
   panic(err)
  }
  defer client.Close()
  tool, err := client.LoadTool("my-tool", ctx)
  inputs := map[string]any{"input": "my input value"}
  result, err := tool.Invoke(ctx, inputs)
  if err != nil {
    panic(err)
  }

  fmt.Println(result)
}

Note: To restrict negotiation to a specific subset of versions, you can pass an array of supported protocols:

ToolboxClient("http://localhost:5000", protocol=[Protocol.MCP_v20260728, Protocol.MCP_v20251125])

Try It Out

Pivoting MCP to a stateless core simplifies tool usage for high-concurrency, multi-agent orchestrations. By aligning the MCP Toolbox for Databases server and SDKs with this specification, we’re paving the way for simpler, faster database interactions.

Ready to take it for a spin?

Download the v1.8.0 server binary, pull the container image, or run the server from NPX: npx @toolbox-sdk/server@1.1.0 or UVX: uvx toolbox-server==1.1.0
Have feedback or run into an issue? Drop an issue on GitHub or chat with us directly on Discord!

MCP Toolbox adds support for the new 2026–07–28 MCP spec was originally published in Google Cloud – Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Source Credit: https://medium.com/google-cloud/mcp-toolbox-adds-support-for-the-new-july-28-mcp-spec-a0fbe401cbba?source=rss—-e52cf94d98af—4