MCP 2026-07-28 深度拆解：当 AI 工具协议决定「干掉全部会话状态」——从有状态握手到无状态自包含，一个被 10 万+ Agent 采用的协议如何用 9 项破坏性变更重新定义工具集成的终极形态

2026 年 7 月 28 日，Anthropic 发布了 MCP（Model Context Protocol）第 5 版规范，官方将其定性为「问世以来规模最大、最系统性的一次颠覆式修订」。核心变化：协议层彻底无状态化，移除 initialize 握手和 Mcp-Session-Id，引入 Multi Round-Trip Requests（MRTR）替代双向流，新增 MCP Apps 和 Tasks 扩展框架。这不是一次小修小补——它从根本上改变了 AI Agent 与工具交互的部署模型、扩展方式和架构假设。

本文将从协议演进脉络出发，逐层拆解 9 项破坏性变更的技术细节，对比新旧架构差异，提供完整的迁移实战代码，并分析这次修订对整个 AI Agent 生态的深远影响。

一、背景：MCP 为什么需要一次「推倒重来」？

1.1 MCP 的诞生与定位

MCP（Model Context Protocol）由 Anthropic 于 2024 年 11 月底推出，定位是「AI 的 USB 接口」——一个开放标准协议，统一 LLM 与外部数据源、工具之间的通信方式。

在 MCP 出现之前，每个 AI 应用要对接每个工具都需要写定制适配器：解析 API、处理认证、管理错误。M 个应用对接 N 个工具，复杂度是 M×N。MCP 将这个复杂度降维到 M+N：工具提供方实现一次 MCP Server，所有 MCP Client 都能调用。

截至 2026 年 7 月，MCP 已被 Claude Desktop、Cursor、VS Code Copilot、Windsurf、Cline 等主流 AI 编码工具原生支持，GitHub 上的 MCP Server 数量超过 5000 个，覆盖数据库、文件系统、API 网关、CI/CD、监控等几乎所有开发场景。

1.2 旧协议的三大痛点

MCP 2025-11-25 版本（当前主流版本）采用「有状态双向连接」模型，虽然直觉上自然，却在生产环境中暴露了三个致命问题：

痛点一：粘性会话制约水平扩展

旧协议要求客户端先完成 initialize / initialized 握手，服务端签发 Mcp-Session-Id，后续所有请求必须携带此 ID 并路由到同一实例。这意味着：

• 部署到 Kubernetes 后必须配置粘性会话（Sticky Session）
• 部署到 Serverless（Cloudflare Workers、Vercel Edge）后无法直接使用轮询负载均衡
• 实例回收时会话丢失，需要额外的会话存储和故障迁移机制

痛点二：双向流增加运维复杂度

旧协议中，服务端可以通过持续打开的 SSE 流主动向客户端发起请求（如 sampling/createMessage、roots/list）。这种设计：

• 要求客户端和服务端都维护长连接状态
• 在网关、防火墙、CDN 后面容易被中断
• 让 OpenTelemetry 链路追踪变得困难（一条调用链跨越多个有状态连接）

痛点三：协议能力与应用能力耦合

旧协议将 UI 渲染（Apps）、异步任务（Tasks）、企业鉴权等应用层能力直接塞进核心协议，导致协议越来越臃肿，每次新增功能都需要修改核心规范。

二、9 项破坏性变更全景拆解

2.1 变更一：移除 initialize / initialized 握手

旧协议流程：

客户端 → 服务端: initialize（携带协议版本、客户端信息、能力声明）
服务端 → 客户端: initialize 响应（携带协议版本、服务器信息、能力声明）
客户端 → 服务端: notifications/initialized（确认握手完成）
// 之后才能开始工具调用

新协议流程：

// 没有握手。每个请求自包含协议版本和客户端能力。
POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search",
    "arguments": {"query": "MCP protocol"}
  },
  "_meta": {
    "io.modelcontextprotocol/protocolVersion": "2026-07-28",
    "io.modelcontextprotocol/clientCapabilities": {
      "sampling": false,
      "roots": false
    }
  }
}

影响分析：

握手移除意味着「先建连接、再延续会话」的前提不存在了。每个请求都是一份自包含的文档，任何服务端实例拿到后都能直接处理。这是无状态化的基础。

Python 迁移示例：

# 旧写法（需要维护会话）
import mcp

client = mcp.Client("http://localhost:3000")
await client.initialize()  # ← 这一行没了
result = await client.call_tool("search", {"query": "hello"})

# 新写法（无状态）
import httpx

async def call_mcp_tool(server_url: str, tool_name: str, args: dict):
    """每次调用都是自包含请求，无需维护会话"""
    response = await httpx.AsyncClient().post(
        f"{server_url}/mcp",
        headers={
            "MCP-Protocol-Version": "2026-07-28",
            "Mcp-Method": "tools/call",
            "Mcp-Name": tool_name,
            "Content-Type": "application/json",
        },
        json={
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {"name": tool_name, "arguments": args},
            "_meta": {
                "io.modelcontextprotocol/protocolVersion": "2026-07-28",
                "io.modelcontextprotocol/clientCapabilities": {},
            },
        },
    )
    return response.json()

2.2 变更二：移除 Mcp-Session-Id 和协议层会话

这是无状态化的核心。旧协议中，服务端通过 Mcp-Session-Id 头标识会话，客户端后续请求必须携带。新协议彻底删除了这个头。

跨调用状态怎么办？——显式业务句柄

删除协议会话后，购物车、浏览器实例、审批流程等跨调用状态需要通过「显式业务句柄」管理：

# 旧写法：状态藏在协议会话里
session = await client.initialize()
# 服务端内部维护 session_id → browser_instance 的映射
await client.call_tool("create_browser", {})  # 返回隐式状态
await client.call_tool("open_page", {"url": "https://example.com"})  # 自动使用同一会话的浏览器
await client.call_tool("screenshot", {})  # 同上

# 新写法：状态通过显式句柄传递
result = await call_mcp_tool(server, "create_browser", {})
browser_id = result["browserId"]  # 显式句柄

await call_mcp_tool(server, "open_page", {
    "browser_id": browser_id,  # 显式传递
    "url": "https://example.com"
})

await call_mcp_tool(server, "screenshot", {
    "browser_id": browser_id  # 显式传递
})

架构差异对比：

2.3 变更三：GET 流端点删除

旧协议的 Streamable HTTP 传输同时暴露 POST 和 GET 两个端点：

• POST 用于发送请求
• GET 用于建立 SSE 流，接收服务端推送

新协议只保留 POST 端点。SSE 仅作为「该请求的响应流」存在，不再有独立的 GET 流端点。Last-Event-ID 再开机制也被移除——断线后用新的 request ID 重新请求即可。

这意味着什么？

# 旧协议：需要维护两个连接
post_response = await client.post("/mcp", json=request)
# 还需要单独维护一个 SSE 流来接收服务端推送
sse_stream = await client.get("/mcp", headers={"Accept": "text/event-stream"})

# 新协议：只需一个 POST，SSE 是响应的一部分
response = await client.post("/mcp", json=request)
# 如果响应是流式的，Content-Type 会是 text/event-stream
# 但这是响应，不是独立的连接

2.4 变更四：Multi Round-Trip Requests（MRTR）替代双向流

这是新协议最精妙的设计。旧协议中，服务端可以通过双向流主动向客户端发起请求（如要求用户确认删除操作）。这种「服务端反向请求」天然依赖持续连接。

新协议用 MRTR 解决这个问题：

01. 客户端发起工具调用
    POST /mcp → tools/call {name: "delete_file", args: {path: "/tmp/important.txt"}}

02. 服务端返回"需要补充输入"
    {
      "resultType": "input_required",
      "question": "确认删除 /tmp/important.txt？此操作不可逆。",
      "options": ["确认删除", "取消"],
      "requestState": "abc123"  // 服务端保存的状态标识
    }

03. 客户端收集用户确认

04. 客户端携带输入和状态重新请求
    POST /mcp → tools/call {
      name: "delete_file",
      args: {path: "/tmp/important.txt"},
      inputResponses: {"confirmation": "确认删除"},
      requestState: "abc123"
    }

05. 任意服务端实例继续完成任务
    {"resultType": "complete", "result": "文件已删除"}

关键点： 第 5 步可以由任意实例处理——因为状态通过 requestState 显式传递，不再绑定到特定实例。

Python 实现 MRTR：

async def call_with_mitr(server_url: str, tool_name: str, args: dict) -> dict:
    """支持 MRTR 的工具调用（含人工确认）"""
    # 第一次调用
    response = await call_mcp_tool(server_url, tool_name, args)
    
    # 检查是否需要补充输入
    if response.get("resultType") == "input_required":
        question = response["question"]
        request_state = response["requestState"]
        
        # 交互式确认（可以是 CLI、Web UI、或其他方式）
        print(f"\n⚠️  {question}")
        answer = input("请输入确认: ").strip()
        
        # 携带确认信息重新请求（可以发到任意实例）
        response = await call_mcp_tool_with_state(
            server_url, tool_name, args,
            input_responses={"confirmation": answer},
            request_state=request_state
        )
    
    return response

2.5 变更五：server/discover 成为 MUST

新协议新增 server/discover 方法，服务端必须实现。客户端可以通过此方法发现服务端支持的协议版本和能力，而不需要先建立会话。

# 服务端发现
response = await call_mcp_tool(server_url, "server/discover", {})
# 返回:
{
  "protocolVersion": "2026-07-28",
  "capabilities": {
    "tools": True,
    "resources": True,
    "prompts": True,
    "apps": True,      # MCP Apps 扩展
    "tasks": True       # Tasks 扩展
  },
  "extensions": [
    {"name": "apps", "version": "1.0.0"},
    {"name": "tasks", "version": "1.0.0"}
  ]
}

2.6 变更六：MCP Apps 和 Tasks 成为正式扩展

新协议建立了带版本号的扩展框架。MCP Apps 和 Tasks 成为首批正式扩展：

MCP Apps： 服务端可以提供交互式 HTML 界面，由 Agent Host 在沙箱 iframe 中渲染。

# 服务端声明自己的 App
@app.mcp_app("database-explorer")
def database_explorer():
    return {
        "title": "数据库浏览器",
        "description": "交互式浏览数据库表结构和数据",
        "html": """
        <div id="app">
            <h2>数据库浏览器</h2>
            <select id="table-select"></select>
            <div id="data-grid"></div>
        </div>
        <script>
            // 前端交互逻辑
            fetch('/api/tables').then(r => r.json()).then(tables => {
                const select = document.getElementById('table-select');
                tables.forEach(t => {
                    const opt = document.createElement('option');
                    opt.value = t.name;
                    opt.textContent = t.name;
                    select.appendChild(opt);
                });
            });
        </script>
        """
    }

Tasks： 用任务句柄承载长时间异步操作。

# 提交异步任务
result = await call_mcp_tool(server, "tasks/submit", {
    "type": "data_export",
    "params": {"table": "users", "format": "csv"}
})
task_id = result["taskId"]

# 查询任务状态
status = await call_mcp_tool(server, "tasks/status", {
    "taskId": task_id
})
# {"status": "running", "progress": 0.6, "eta": "30s"}

# 取消任务
await call_mcp_tool(server, "tasks/cancel", {"taskId": task_id})

2.7 变更七：请求头标准化

Streamable HTTP 请求现在必须携带 Mcp-Method 和 Mcp-Name 头。API 网关、WAF、限流器和审计系统可以直接根据请求头判断调用的方法与工具，不必解析 JSON-RPC 请求体。

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Content-Type: application/json

{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "search", "arguments": {"query": "hello"}}}

缓存语义增强： 列表和资源读取结果新增 ttlMs 和 cacheScope：

{
  "tools": [...],
  "ttlMs": 300000,
  "cacheScope": "shared"
}

客户端由此知道结果可以缓存 5 分钟，且可以跨用户共享。配合稳定的工具列表顺序，MCP 服务可以减少重复发现和轮询开销，更容易命中大模型的 Prompt Cache。

2.8 变更八：OAuth 2.0 / OIDC 生产级适配

新规范进一步向企业身份系统靠拢：

• 客户端必须校验授权响应中的 iss（issuer），防止授权服务器混淆攻击
• 客户端凭据必须绑定签发它的授权服务器，不能跨 issuer 复用
• 动态客户端注册（DCR）进入废弃流程，推荐迁移到 Client ID Metadata Documents
• MCP Server 可以直接对接 Entra（微软）、Okta 等企业身份系统

# 旧写法：变通的鉴权方案
headers = {"Authorization": f"Bearer {custom_token}"}

# 新写法：标准 OAuth 2.0 + OIDC
# 服务端声明 OAuth 配置
{
  "authorization": {
    "issuer": "https://login.microsoftonline.com/{tenant-id}",
    "jwks_uri": "https://login.microsoftonline.com/{tenant-id}/discovery/v2.0/keys",
    "scopes_supported": ["mcp:tools.read", "mcp:tools.execute"]
  }
}

# 客户端标准 OAuth 2.0 流程
# 1. 发现授权端点
# 2. 重定向用户到授权页面
# 3. 获取 access_token
# 4. 携带 token 调用 MCP

2.9 变更九：Roots、Sampling、Logging 进入废弃流程

这三项能力在新协议中被标记为废弃，但有 12 个月的迁移窗口：

三、架构对比：从「管道模型」到「自包含请求」

3.1 旧架构：管道模型

┌──────────┐     initialize      ┌──────────┐
│  Client  │ ──────────────────→ │  Server  │
│          │ ←────────────────── │          │
│          │     Session-Id      │          │
│          │                     │          │
│          │ ←─── SSE Stream ──→ │          │  ← 双向流
│          │                     │          │
│          │ ── tools/call ────→ │          │
│          │ ←── result ──────── │          │
└──────────┘                     └──────────┘
      │                               │
      │  粘性路由（必须命中同一实例）     │
      └───────────────────────────────┘

特征：

• 连接是有状态的，必须维持到会话结束
• 双向流需要客户端和服务端同时在线
• 负载均衡需要粘性会话
• 故障迁移复杂

3.2 新架构：自包含请求模型

┌──────────┐                     ┌──────────┐
│  Client  │ ── POST /mcp ────→ │  Server  │
│          │ ←── result ──────── │ (任意实例)│
│          │                     └──────────┘
│          │                          ↑
│          │ ── POST /mcp ──────────→ │ ← 轮询负载均衡
│          │ ←── input_required ───── │
│          │                          │
│          │ ── POST /mcp ──────────→ │ ← 可以是不同实例
│          │ ←── complete ─────────── │
└──────────┘                     └──────────┘

      无状态 → 任意实例可处理任意请求

特征：

• 每个请求自包含所有上下文
• 无连接依赖，轮询负载均衡即可
• Serverless / 边缘节点直接部署
• 故障恢复简单（重试即可）

四、实战：构建一个 MCP 2026-07-28 Server

4.1 最小无状态 Server（Python + FastAPI）

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, StreamingResponse
import json
import uuid
from datetime import datetime

app = FastAPI()

# 模拟数据库（生产环境用 Redis/PostgreSQL）
TASK_STORE = {}

# 工具注册表
TOOLS = {
    "get_weather": {
        "description": "获取指定城市的天气信息",
        "inputSchema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"}
            },
            "required": ["city"]
        }
    },
    "search_docs": {
        "description": "搜索文档库",
        "inputSchema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "搜索关键词"},
                "limit": {"type": "integer", "description": "返回数量", "default": 10}
            },
            "required": ["query"]
        }
    }
}


@app.post("/mcp")
async def mcp_endpoint(request: Request):
    """MCP 2026-07-28 无状态端点"""
    # 从请求头读取元数据（无需会话）
    protocol_version = request.headers.get("MCP-Protocol-Version")
    method = request.headers.get("Mcp-Method")
    tool_name = request.headers.get("Mcp-Name")
    
    body = await request.json()
    request_id = body.get("id")
    params = body.get("params", {})
    meta = body.get("_meta", {})
    
    # 协议版本协商
    if protocol_version and protocol_version != "2026-07-28":
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32600,
                "message": f"Unsupported protocol version: {protocol_version}"
            }
        })
    
    # 路由到对应方法
    if method == "server/discover":
        return handle_discover(request_id)
    elif method == "tools/list":
        return handle_tools_list(request_id, meta)
    elif method == "tools/call":
        return await handle_tools_call(request_id, tool_name, params, meta)
    elif method == "tasks/submit":
        return handle_tasks_submit(request_id, params)
    elif method == "tasks/status":
        return handle_tasks_status(request_id, params)
    else:
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {"code": -32601, "message": f"Unknown method: {method}"}
        })


def handle_discover(request_id):
    """server/discover - MUST 实现"""
    return JSONResponse({
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "protocolVersion": "2026-07-28",
            "capabilities": {
                "tools": True,
                "resources": False,
                "prompts": False,
                "apps": False,
                "tasks": True
            },
            "extensions": [
                {"name": "tasks", "version": "1.0.0"}
            ]
        }
    })


def handle_tools_list(request_id, meta):
    """tools/list - 带缓存语义"""
    return JSONResponse({
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": [
                {
                    "name": name,
                    "description": tool["description"],
                    "inputSchema": tool["inputSchema"]
                }
                for name, tool in TOOLS.items()
            ],
            "ttlMs": 300000,  # 5 分钟缓存
            "cacheScope": "shared"
        }
    })


async def handle_tools_call(request_id, tool_name, params, meta):
    """tools/call - 无状态处理"""
    if tool_name == "get_weather":
        city = params.get("city", "北京")
        # 模拟天气数据
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "resultType": "complete",
                "content": [{
                    "type": "text",
                    "text": json.dumps({
                        "city": city,
                        "temperature": "28°C",
                        "condition": "晴",
                        "humidity": "45%",
                        "wind": "东北风3级"
                    }, ensure_ascii=False)
                }]
            }
        })
    
    elif tool_name == "search_docs":
        query = params.get("query", "")
        limit = params.get("limit", 10)
        # 模拟搜索结果
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "resultType": "complete",
                "content": [{
                    "type": "text",
                    "text": json.dumps({
                        "query": query,
                        "total": 42,
                        "results": [
                            {"title": f"文档 {i+1}", "score": 0.95 - i*0.05}
                            for i in range(min(limit, 5))
                        ]
                    }, ensure_ascii=False)
                }]
            }
        })
    
    else:
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"}
        })


def handle_tasks_submit(request_id, params):
    """tasks/submit - 异步任务提交"""
    task_id = str(uuid.uuid4())
    TASK_STORE[task_id] = {
        "status": "running",
        "progress": 0,
        "created_at": datetime.now().isoformat(),
        "params": params
    }
    
    return JSONResponse({
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "taskId": task_id,
            "status": "running"
        }
    })


def handle_tasks_status(request_id, params):
    """tasks/status - 查询任务状态"""
    task_id = params.get("taskId")
    task = TASK_STORE.get(task_id)
    
    if not task:
        return JSONResponse({
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {"code": -32602, "message": f"Task not found: {task_id}"}
        })
    
    return JSONResponse({
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "taskId": task_id,
            "status": task["status"],
            "progress": task["progress"]
        }
    })

4.2 Cloudflare Workers 部署示例

无状态化让 MCP Server 可以直接部署到边缘节点：

// worker.js - Cloudflare Workers
export default {
  async fetch(request, env) {
    if (request.method !== 'POST' || !request.url.endsWith('/mcp')) {
      return new Response('Not Found', { status: 404 });
    }

    const protocolVersion = request.headers.get('MCP-Protocol-Version');
    const method = request.headers.get('Mcp-Method');
    const toolName = request.headers.get('Mcp-Name');
    
    const body = await request.json();
    const { id: requestId, params, _meta } = body;

    // 无状态处理 - 每个请求独立
    switch (method) {
      case 'server/discover':
        return jsonResponse(requestId, {
          protocolVersion: '2026-07-28',
          capabilities: { tools: true, resources: false }
        });
      
      case 'tools/call':
        return await handleToolCall(requestId, toolName, params);
      
      default:
        return jsonResponse(requestId, null, {
          code: -32601,
          message: `Unknown method: ${method}`
        });
    }
  }
};

function jsonResponse(id, result, error = null) {
  const body = { jsonrpc: '2.0', id };
  if (error) body.error = error;
  else body.result = result;
  
  return new Response(JSON.stringify(body), {
    headers: { 'Content-Type': 'application/json' }
  });
}

部署命令：

wrangler deploy
# 输出: https://mcp-server.your-subdomain.workers.dev/mcp

五、迁移实战：从旧协议升级到新协议

5.1 迁移检查清单

5.2 五步迁移路线

Step 1：盘点协议状态

# 搜索代码中的旧协议依赖
grep -rn "initialize\|Mcp-Session-Id\|Session-Id" src/
grep -rn "sampling\|roots/list\|logging" src/

Step 2：外置业务状态

# 旧：状态在内存中
class McpServer:
    def __init__(self):
        self.sessions = {}  # session_id → state
    
    async def handle(self, session_id, request):
        state = self.sessions[session_id]
        # 处理请求...

# 新：状态在外部存储中
class McpServer:
    def __init__(self, redis_client):
        self.redis = redis_client
    
    async def handle(self, request):
        handle = request.get("handle")  # 显式句柄
        if handle:
            state = await self.redis.get(f"mcp:state:{handle}")
        # 处理请求...

Step 3：改造交互链路（MRTR）

# 旧：服务端主动推送确认
async def delete_file(self, path):
    # 通过双向流请求用户确认
    await self.send_to_client({
        "method": "confirmation/request",
        "params": {"message": f"确认删除 {path}？"}
    })
    response = await self.wait_for_client_response()

# 新：MRTR 返回 input_required
async def delete_file(self, path):
    # 返回需要补充输入
    return {
        "resultType": "input_required",
        "question": f"确认删除 {path}？此操作不可逆。",
        "options": ["确认删除", "取消"],
        "requestState": str(uuid.uuid4())
    }

Step 4：升级基础设施

# Nginx 网关配置更新
location /mcp {
    # 新协议：通过请求头路由
    if ($http_mcp_method = "tools/call") {
        proxy_pass http://mcp_backend;
    }
    
    # 旧协议：通过 JSON body 路由（兼容期保留）
    # proxy_pass http://mcp_backend_legacy;
}

Step 5：建立双版本测试

# 测试套件：同时测试新旧协议
import pytest

@pytest.mark.parametrize("protocol_version", ["2025-11-25", "2026-07-28"])
async def test_tool_call(protocol_version):
    if protocol_version == "2026-07-28":
        # 新协议：无会话
        result = await call_mcp_tool(server, "search", {"query": "test"})
    else:
        # 旧协议：需要初始化会话
        session = await mcp_client.initialize()
        result = await session.call_tool("search", {"query": "test"})
    
    assert result["resultType"] == "complete"

六、性能基准对比

6.1 延迟对比

在 Kubernetes 集群（3 节点）中测试，模拟 1000 并发工具调用：

6.2 Serverless 部署对比

七、生态影响：这次更新意味着什么？

7.1 对 MCP Server 开发者

好消息： 你的 MCP Server 现在可以像普通 HTTP 服务一样部署。扔到 Cloudflare Workers、Vercel Edge 或 Kubernetes 后，直接用轮询负载均衡，不用再为粘性路由多付钱。

坏消息： 你需要重新审视所有的状态管理逻辑。如果你的 Server 依赖协议层会话来维护浏览器实例、购物车、审批流程等跨调用状态，必须迁移到显式业务句柄。

7.2 对 MCP Client / AI 应用开发者

好消息： 客户端不再需要维护长连接和会话状态。代码更简单，故障恢复更可靠。

坏消息： 如果你依赖 sampling/createMessage 来让服务端调用模型，需要评估替代方案（MRTR 或直接接入模型 API）。

7.3 对 AI Agent 生态

这次更新的深远影响在于：MCP 从「AI 的 USB 接口」升级为「Agent 的迷你 SaaS 平台」。

一个 MCP 现在可以同时拥有：

• 工具（tools）
• 交互式界面（MCP Apps）
• 异步任务（Tasks）
• 企业级鉴权（OAuth 2.0 + OIDC）
• 可观测性（OpenTelemetry）

写一句 prompt，账号、界面、鉴权由 Agent 自己配齐。这不再是工具调用协议——这是 Agent 时代的「微服务」标准。

7.4 对企业部署

无状态化意味着 MCP Server 可以直接部署在企业内网的 Kubernetes 集群中，通过标准的负载均衡器分发请求。结合 OAuth 2.0 + OIDC 的企业身份集成，企业可以像部署普通微服务一样部署 MCP Server，享受标准的监控、审计和安全能力。

八、总结与展望

MCP 2026-07-28 规范的发布，标志着 AI 工具协议从「实验性原型」正式进入「生产级基础设施」阶段。9 项破坏性变更虽然带来了迁移成本，但每一项都指向同一个方向：让 MCP Server 像普通 HTTP 服务一样简单部署、水平扩展、企业接入。

核心要点回顾：

1. 无状态化是核心：移除 initialize 握手和 Mcp-Session-Id，每个请求自包含所有上下文
2. 显式句柄替代隐式会话：跨调用状态通过业务句柄传递，模型可以读写和组合
3. MRTR 替代双向流：服务端不再需要持续连接来反向请求客户端
4. 扩展框架独立演进：MCP Apps 和 Tasks 从核心协议分离，可独立版本化
5. 企业级就绪：OAuth 2.0 / OIDC + OpenTelemetry + JSON Schema 2020-12

迁移建议：

• 现有 MCP Server：先做依赖审计，按「盘点→外置状态→改造交互→升级基础设施→双版本测试」五步迁移
• 新项目：直接采用 2026-07-28 规范，享受无状态化的部署红利
• 迁移窗口：Roots、Sampling、Logging 等废弃能力有 12 个月过渡期，先停止新增依赖

这次更新最大的意义不是技术细节，而是它传递的信号：AI Agent 生态正在从「能用」走向「能用在生产环境」。 MCP 作为这个生态的通信协议，必须跟上这个步伐。2026-07-28 规范，就是这个步伐的起点。

本文基于 MCP 2026-07-28 官方规范、Anthropic 博客公告及社区实践整理。规范原文和 changelog 详见 https://spec.modelcontextprotocol.io/2026-07-28/。