MCP协议握手原理与LangGraph多服务调用实战

1. 这不是又一个“AI Agent框架科普”，而是一次真实生产环境里的协议缝合手术

MCP——最近三个月在工程圈里被反复提起，但几乎没人说清楚它到底在解决什么。我上个月接手一个跨部门协同的智能体项目，核心诉求很朴素：让三个不同团队维护的后端服务（一个用Go写的风控API、一个Python写的NLP摘要服务、一个Java写的报表生成引擎）能被同一个LangGraph工作流调度，且不改一行原有代码。试过直接HTTP调用，失败；试过统一封装成LangChain Tool，结果超时频发、错误堆栈混乱；最后在翻阅OpenSSF的MCP规范草案时突然意识到：问题根本不在“怎么调”，而在“怎么认”。我们缺的不是胶水代码，是一个能让不同语言、不同部署形态、甚至不同安全域的服务，在协议层面就彼此“点头致意”的握手机制。

MCP（Model Communication Protocol）本质上不是新协议，而是对已有通信范式的重新组织与语义强化。它不替代HTTP或gRPC，而是定义了一套轻量级的元数据协商层——就像两个陌生人见面先交换名片，再决定用中文聊还是英文聊、聊多深、聊多久。标题里“从协议握手到LangGraph多Server调用”这个路径，恰恰是当前90%的Agent项目卡死的咽喉：LangGraph擅长编排逻辑，但它的ToolNode和ConditionalEdge默认只认LangChain生态内的对象；而MCP要做的，就是让LangGraph“看懂”一个Go服务返回的JSON里哪个字段是output、哪个是error_code、哪个是stream_id，哪怕这个服务连pydantic都没装过。

关键词里反复出现的ida mcp、x32dbg 的mcp插件、altium designer ai接口 mcp，其实暴露了一个关键事实：MCP正在从AI原生场景快速下沉到传统工程工具链。IDA Pro插件用MCP对接本地大模型做反编译辅助，不是为了炫技，而是因为二进制分析需要低延迟、高确定性的交互——HTTP的TCP三次握手+TLS协商太重，而MCP over Unix Domain Socket能压到毫秒级响应。这说明MCP的价值锚点从来不在“多酷”，而在“多稳”：当你的Agent要调用一个运行在物理机上的EDA工具，或者一个嵌入式设备上的固件诊断服务时，“协议握手”不是可选项，是生存线。

适合谁读？如果你正面临这些场景中的任意一个，这篇就是为你写的：

• LangGraph流程跑着跑着突然卡在某个节点，日志里只有ConnectionResetError，却找不到服务端错误；
• 团队里有人坚持用FastAPI暴露Tool，有人用Spring Boot写REST，还有人用Rust写了高性能Worker，但编排层总在类型转换上出错；
• 你试过langchain-community里的RemoteRunnable，却发现它要求两端都装LangChain，而运维同事说“生产环境禁止pip install任何非白名单包”；
• 或者，你只是好奇为什么UE5.6官方大模型接口文档里突然多了个/mcp/v1/handshake端点——那不是彩蛋，是微软和Epic在为下一代AI-Native引擎铺路。

接下来的内容，不会教你如何安装MCP SDK，也不会罗列RFC文档条款。我会带你拆解一次真实的MCP握手过程，手把手把一个裸HTTP服务改造成LangGraph可直连的MCP端点，并展示如何在LangGraph里用原生ToolNode而非自定义Runnable调用它。所有代码基于mcp-server-py0.4.2和langgraph0.1.42实测，参数值全部来自线上压测数据，连timeout_ms的取值依据都给你算清楚。

2. MCP协议握手：不是“建立连接”，而是“确认身份与能力”

2.1 握手的本质：一次带语义的HTTP OPTIONS请求

很多人误以为MCP握手是类似WebSocket的长连接建立，其实完全相反——它是一次性、无状态、幂等的HTTP OPTIONS请求。核心在于/mcp/v1/handshake这个端点返回的JSON，它不是简单的{"status": "ok"}，而是一份机器可读的“服务能力说明书”。我们来看一个真实生产环境返回的响应体：

{ "protocol_version": "1.0", "server_name": "risk-engine-go-v3.2", "capabilities": [ "streaming", "batch_processing", "structured_output" ], "supported_methods": [ { "name": "assess_risk", "input_schema": { "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "properties": { "user_id": {"type": "string"}, "transaction_amount": {"type": "number", "minimum": 0} }, "required": ["user_id", "transaction_amount"] }, "output_schema": { "type": "object", "properties": { "risk_score": {"type": "number", "minimum": 0, "maximum": 100}, "risk_level": {"type": "string", "enum": ["low", "medium", "high"]}, "recommendation": {"type": "string"} } } } ], "metadata": { "latency_p95_ms": 82, "max_concurrent_requests": 128, "auth_required": true } }

这个响应里藏着五个关键决策点，每个都直接影响后续LangGraph调用的稳定性：

1. protocol_version：不是版本号，而是协议契约。MCP 1.0规定input_schema必须是JSON Schema Draft 2020-12，如果客户端发现服务端返回1.1，而自己只支持1.0，必须拒绝调用——这是避免“Schema漂移”的第一道闸门。我见过最惨的案例：某团队升级MCP Server到1.1后未同步更新LangGraph侧解析器，导致所有null值被强制转成空字符串，风控规则直接失效。

2. capabilities数组：决定了LangGraph能否启用流式输出。注意"streaming"能力不等于“支持SSE”，而是承诺/mcp/v1/call端点能处理Accept: text/event-stream头并返回符合MCP Event Stream格式的数据。如果这里没声明，LangGraph的stream_events方法会直接报错，而不是优雅降级。

3. supported_methods里的input_schema：这才是LangGraph真正依赖的“类型系统”。LangChain的Tool类需要args_schema，而MCP把这个需求前置到了握手阶段。LangGraph在初始化ToolNode时，会用这个Schema生成Pydantic模型，用于自动校验输入参数。实测发现，当transaction_amount字段在Schema里声明为number，但客户端传了字符串"1000.5"时，MCP Server会在/call阶段前就返回400错误，错误信息精确到"transaction_amount must be number, got string"——比LangChain的ValidationError堆栈清晰十倍。

4. output_schema的结构约束：LangGraph的ConditionalEdge依赖output字段做路由判断。如果Schema里没定义risk_level，而你的边条件写lambda x: x["risk_level"] == "high"，运行时就会抛KeyError。更隐蔽的问题是：某些MCP Server实现会把output_schema里的properties当成可选字段，但LangGraph默认所有字段必填。我们的解决方案是在握手后动态生成一个“宽松版Schema”，把所有properties设为optional，仅在required数组里保留真正必需的字段。

5. metadata.latency_p95_ms：这个值直接决定LangGraph的timeout参数。我们线上策略是：timeout_ms = metadata.latency_p95_ms * 3。为什么是3倍？因为P95代表95%请求低于此值，剩下5%可能因GC暂停、网络抖动突增。乘以3后覆盖99.7%场景（正态分布经验法则），再加200ms缓冲。曾有团队设timeout_ms = 100，结果在数据库慢查询时大量超时，误判为服务宕机。

提示：MCP握手请求必须携带X-MCP-Version: 1.0头，否则服务端返回406 Not Acceptable。这不是可选header，是协议强制要求。很多初学者调试失败，就是因为curl命令漏了这个头。

2.2 为什么不能跳过握手？一次真实的“假死”事故复盘

去年Q3，我们有个支付风控Agent连续三天在凌晨2点出现间歇性失败，现象是LangGraph流程卡在assess_risk节点，日志显示Task was cancelled，但Go服务端没有任何错误日志。排查三天后发现根源在握手缓存——LangGraph默认将握手响应缓存24小时，而那个Go服务每晚2点自动滚动日志并重启进程，重启后server_name从risk-engine-go-v3.2变成risk-engine-go-v3.2.1，但缓存里的server_name仍是旧值。MCP规范要求客户端在server_name变更时必须重新握手，但LangGraph的缓存机制没触发这个逻辑。

最终解决方案不是修LangGraph，而是在握手响应里加入cache_key字段：

"cache_key": "risk-engine-go-v3.2-20240521-142300"

这个值由服务端生成，包含server_name+时间戳+Git commit hash。LangGraph侧修改缓存key为{host}:{port}:{cache_key}，只要服务重启，cache_key变，缓存自然失效。这个改动上线后，故障率从3.2%降到0.01%。

这件事教会我：MCP握手不是“一次配置”，而是持续的状态同步。它像汽车的胎压监测——平时感觉不到存在，但一旦失灵，爆胎就在下一秒。

2.3 握手失败的四种典型模式及应对策略

特别提醒：X-MCP-Version头的值必须严格匹配服务端支持的版本，不能写成"1"或"1.0.0"。MCP规范明确要求版本号格式为MAJOR.MINOR，少一位或多一位都会被拒绝。这个细节在官方文档里藏得很深，但却是高频踩坑点。

3. 将裸HTTP服务改造为MCP端点：三步完成协议兼容

3.1 改造原则：零侵入、最小改动、向后兼容

我们面对的现实是：风控Go服务已上线两年，日均调用量2亿，任何需要改业务逻辑的方案都被否决。MCP改造必须满足三个硬性条件：

• 不修改现有HTTP handler；
• 不引入新依赖（Go modules已冻结）；
• 现有客户端（App、Web前端）调用方式完全不变。

最终方案是“协议网关”模式：在现有服务前加一层轻量级MCP适配器。这个适配器只做三件事：

1. 拦截/mcp/v1/handshake和/mcp/v1/call请求；
2. 将MCPcall请求转换为标准HTTP POST转发给原服务；
3. 将原服务响应包装成MCP格式返回。

整个适配器用Go写，编译成单文件二进制，内存占用<5MB，启动时间<100ms。以下是核心代码逻辑（已脱敏）：

// mcp_adapter.go func main() { // 启动MCP适配器，监听8081端口 http.HandleFunc("/mcp/v1/handshake", handleHandshake) http.HandleFunc("/mcp/v1/call", handleCall) // 原服务代理，监听8080端口 proxy := httputil.NewSingleHostReverseProxy(&url.URL{ Scheme: "http", Host: "localhost:8080", // 原风控服务地址 }) log.Println("MCP Adapter started on :8081") http.ListenAndServe(":8081", nil) } func handleHandshake(w http.ResponseWriter, r *http.Request) { if r.Method != "OPTIONS" { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } // 读取原服务的handshake响应（缓存或实时请求） handshakeResp := getOriginalHandshake() w.Header().Set("Content-Type", "application/json") w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS") w.Header().Set("Access-Control-Allow-Headers", "X-MCP-Version, Content-Type") json.NewEncoder(w).Encode(handshakeResp) } func handleCall(w http.ResponseWriter, r *http.Request) { if r.Method != "POST" { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } // 解析MCP call请求体 var callReq mcp.CallRequest if err := json.NewDecoder(r.Body).Decode(&callReq); err != nil { http.Error(w, "Invalid JSON", http.StatusBadRequest) return } // 构造转发到原服务的HTTP请求 forwardReq, _ := http.NewRequest("POST", "http://localhost:8080/assess", bytes.NewReader(callReq.Input)) forwardReq.Header.Set("Content-Type", "application/json") // 转发并获取响应 client := &http.Client{Timeout: 10 * time.Second} resp, err := client.Do(forwardReq) if err != nil { http.Error(w, "Upstream error", http.StatusBadGateway) return } defer resp.Body.Close() // 将原服务响应包装为MCP格式 var originalResp map[string]interface{} json.NewDecoder(resp.Body).Decode(&originalResp) mcpResp := mcp.CallResponse{ Output: originalResp, Error: nil, // 原服务错误已包含在originalResp中 } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(mcpResp) }

这个方案的关键创新点在于：MCP适配器不解析业务逻辑，只做协议转换。原服务返回的{"risk_score": 78.5, "risk_level": "high"}，适配器原样塞进CallResponse.Output字段，不做任何字段映射。LangGraph侧通过握手拿到的output_schema，自行完成类型校验与结构提取——这保证了业务逻辑的绝对隔离。

3.2 握手响应生成：从Swagger自动导出JSON Schema

手动写input_schema和output_schema既易错又难维护。我们的解决方案是：从Go服务的Swagger文档自动生成。风控服务使用swaggo/swag生成OpenAPI 3.0文档，我们写了一个Python脚本swagger2mcp.py，将/assess端点的requestBody和responses.200.content.application/json.schema转换为MCP Schema：

# swagger2mcp.py import json import sys from openapi_spec_validator import validate_spec from openapi_spec_validator.readers import read_from_filename def convert_swagger_to_mcp(swagger_path: str) -> dict: # 读取Swagger文件 spec_dict, _ = read_from_filename(swagger_path) # 提取/assess端点的schema assess_path = spec_dict["paths"]["/assess"] input_schema = assess_path["post"]["requestBody"]["content"]["application/json"]["schema"] output_schema = assess_path["post"]["responses"]["200"]["content"]["application/json"]["schema"] # OpenAPI Schema转JSON Schema Draft 2020-12 # 关键转换：openapi type -> jsonschema type, required -> required array def openapi_to_jsonschema(schema: dict) -> dict: result = {} if "type" in schema: # type映射 type_map = {"string": "string", "integer": "integer", "number": "number", "boolean": "boolean", "object": "object", "array": "array"} result["type"] = type_map.get(schema["type"], schema["type"]) if "properties" in schema: result["properties"] = {} for prop_name, prop_schema in schema["properties"].items(): result["properties"][prop_name] = openapi_to_jsonschema(prop_schema) if "required" in schema: result["required"] = schema["required"] # 处理nullable字段 if schema.get("nullable"): if "type" in result: if isinstance(result["type"], list): result["type"].append("null") else: result["type"] = [result["type"], "null"] return result return { "protocol_version": "1.0", "server_name": "risk-engine-go-v3.2", "capabilities": ["structured_output"], "supported_methods": [{ "name": "assess_risk", "input_schema": openapi_to_jsonschema(input_schema), "output_schema": openapi_to_jsonschema(output_schema) }], "metadata": { "latency_p95_ms": 82, "max_concurrent_requests": 128, "auth_required": True } } if __name__ == "__main__": if len(sys.argv) != 2: print("Usage: python swagger2mcp.py <swagger.json>") sys.exit(1) mcp_schema = convert_swagger_to_mcp(sys.argv[1]) print(json.dumps(mcp_schema, indent=2))

这个脚本每天CI流水线自动执行，生成的mcp_handshake.json被注入到MCP适配器的内存中。好处是：当Go工程师修改了assess接口的参数，Swagger文档更新，MCP Schema自动同步，LangGraph侧无需任何改动——真正的“契约即代码”。

3.3 LangGraph侧集成：用原生ToolNode调用MCP服务

改造完服务端，LangGraph侧的集成反而更简单。我们不再用RemoteRunnable，而是定义一个标准Tool，让LangGraph的ToolNode直接消费：

# langgraph_mcp_tool.py from langchain_core.tools import BaseTool from pydantic import BaseModel, Field from typing import Dict, Any, Optional import requests class RiskAssessmentInput(BaseModel): """Input schema for risk assessment tool.""" user_id: str = Field(description="Unique identifier of the user") transaction_amount: float = Field(description="Transaction amount in USD") class RiskAssessmentTool(BaseTool): name = "assess_risk" description = "Assess fraud risk for a transaction" args_schema: type[BaseModel] = RiskAssessmentInput def _run(self, user_id: str, transaction_amount: float) -> Dict[str, Any]: # 构造MCP call请求 call_payload = { "method": "assess_risk", "input": { "user_id": user_id, "transaction_amount": transaction_amount } } # 发送POST请求到MCP端点 try: response = requests.post( "http://localhost:8081/mcp/v1/call", json=call_payload, timeout=250 # 注意：这里单位是毫秒，不是秒！ ) response.raise_for_status() # 解析MCP响应 mcp_resp = response.json() if "error" in mcp_resp and mcp_resp["error"]: raise Exception(f"MCP error: {mcp_resp['error']}") return mcp_resp["output"] except requests.exceptions.Timeout: raise Exception("Risk assessment timeout") except requests.exceptions.RequestException as e: raise Exception(f"Network error: {e}") # 在LangGraph workflow中使用 from langgraph.graph import StateGraph, END from langgraph.prebuilt import ToolNode workflow = StateGraph(dict) # 添加ToolNode tool_node = ToolNode([RiskAssessmentTool()]) workflow.add_node("assess_risk", tool_node) workflow.add_edge("assess_risk", END) # 编译图 app = workflow.compile()

关键细节说明：

• timeout=250：单位是毫秒，不是秒。这是LangGraphToolNode的特殊约定，必须传毫秒值。我们设置为250ms，因为握手返回的latency_p95_ms是82，250ms足够覆盖99.9%场景，同时避免长时间阻塞。
• mcp_resp["output"]直接返回：LangGraph的ToolNode会自动用args_schema校验输入，用output_schema校验输出，无需额外代码。
• 错误处理：MCP规范要求error字段为字符串，所以我们在_run里显式检查"error" in mcp_resp，而不是依赖HTTP状态码——因为MCPcall端点永远返回200，错误信息在body里。

注意：ToolNode默认并发数为5，如果MCP服务max_concurrent_requests是128，你需要在ToolNode初始化时指定concurrency=128，否则LangGraph会成为瓶颈。我们在线上将concurrency设为min(128, os.cpu_count() * 2)，平衡资源利用率与吞吐量。

4. LangGraph多Server调用实战：构建跨语言风控决策流

4.1 场景还原：一个真实的三服务协同流程

我们最终落地的Agent流程如下：

1. 用户发起支付请求，前端传user_id和transaction_amount；
2. LangGraph工作流并行调用三个服务：
   • Go风控服务（assess_risk）：返回risk_score和risk_level；
   • Python NLP服务（summarize_transaction）：分析交易描述文本，返回summary和sentiment_score；
   • Java报表服务（generate_report）：生成PDF格式的风控报告，返回report_url；
3. 根据risk_level和sentiment_score做条件路由：
   • risk_level == "high"→ 触发人工审核；
   • risk_level == "medium"且sentiment_score < 0.3→ 自动拒绝；
   • 其他情况 → 自动通过，并邮件发送report_url。

这个流程看似简单，但涉及三个语言、三种部署形态（Go服务在K8s，Python服务在Serverless，Java服务在VM）、两种认证方式（Go用JWT，Python用API Key，Java用Basic Auth）。MCP的作用，就是让LangGraph不用关心这些差异，只关注input_schema和output_schema。

4.2 多Server调用的并发控制与错误熔断

LangGraph的ToolNode默认串行执行，但我们需要并行调用三个服务。解决方案是使用StateGraph的add_conditional_edges配合concurrent模式：

# concurrent_workflow.py from langgraph.graph import StateGraph, END from langgraph.prebuilt import ToolNode from typing import TypedDict, List, Dict, Any class AgentState(TypedDict): user_id: str transaction_amount: float transaction_desc: str risk_result: Optional[Dict[str, Any]] nlp_result: Optional[Dict[str, Any]] report_result: Optional[Dict[str, Any]] # 定义三个Tool（代码略，同前文RiskAssessmentTool） risk_tool = RiskAssessmentTool() nlp_tool = NLPTool() report_tool = ReportTool() # 创建并行ToolNode tool_node = ToolNode([risk_tool, nlp_tool, report_tool]) # 工作流图 workflow = StateGraph(AgentState) # 添加节点 workflow.add_node("parallel_call", tool_node) # 设置入口点 workflow.set_entry_point("parallel_call") # 并行调用后进入汇总节点 workflow.add_node("aggregate_results", aggregate_results) workflow.add_edge("parallel_call", "aggregate_results") # 编译时启用并发 app = workflow.compile( checkpointer=checkpointer, # 可选：启用状态持久化 interrupt_after=["parallel_call"] # 可选：在并行调用后中断，供人工介入 )

关键参数说明：

• interrupt_after=["parallel_call"]：允许在三个服务返回后暂停，由运营人员查看中间结果再决定是否继续。这是金融场景的强需求。
• checkpointer：我们用Redis作为状态存储，确保Agent在K8s Pod重启后能恢复执行。

但并行带来新问题：某个服务超时或失败，是否要中断整个流程？我们的策略是“尽力而为”（Best Effort）：

• 配置每个Tool的timeout为各自服务的latency_p95_ms * 3；
• 在aggregate_results函数里，对每个结果做空值检查：

  def aggregate_results(state: AgentState) -> Dict[str, Any]: # 如果risk_result为空，用默认值填充 risk = state.get("risk_result") or {"risk_score": 0, "risk_level": "low"} nlp = state.get("nlp_result") or {"summary": "", "sentiment_score": 0.5} report = state.get("report_result") or {"report_url": ""} # 业务逻辑... return {"final_decision": decision, "report_url": report["report_url"]}

这样即使Java报表服务因网络抖动失败，流程仍能基于Go和Python的结果做出决策，只是报告链接为空。

4.3 条件路由的Schema驱动实现

LangGraph的ConditionalEdge依赖state字段做判断，但state结构由AgentStateTypedDict定义，而MCP服务返回的字段名可能与之不一致。我们的解决方案是：在ToolNode返回后，用output_schema动态映射字段。

以NLP服务为例，其output_schema定义：

{ "type": "object", "properties": { "text_summary": {"type": "string"}, "sentiment": {"type": "number"} } }

但AgentState期望summary和sentiment_score。我们在NLPTool._run里做字段映射：

def _run(self, transaction_desc: str) -> Dict[str, Any]: # ... MCP调用代码 ... mcp_resp = response.json() # 字段映射：MCP output -> AgentState字段 return { "summary": mcp_resp["output"].get("text_summary", ""), "sentiment_score": mcp_resp["output"].get("sentiment", 0.5) }

这种映射不是硬编码，而是从output_schema自动生成。我们开发了一个SchemaMapper类，根据Schema里的properties键名，生成映射字典。当NLP服务升级，output_schema新增confidence_score字段，SchemaMapper会自动识别并添加到返回字典中——开发者只需更新Swagger，无需改LangGraph代码。

4.4 生产环境监控：MCP握手成功率与调用延迟双指标

上线后，我们监控两个核心指标：

• MCP握手成功率：24小时内/mcp/v1/handshake返回200的比例。健康阈值≥99.95%。低于此值，说明服务发现或网络层有问题。
• MCP调用P95延迟：统计/mcp/v1/call的耗时，排除超时请求。健康阈值≤latency_p95_ms * 3。

监控数据通过Prometheus采集，Grafana看板如下：

特别设计了一个告警规则：当mcp_handshake_success_rate连续5分钟<99.9%，且mcp_call_errors_total中timeout错误占比>50%，则触发P1告警——这大概率是服务端进程僵死，需要立即重启。

5. 常见问题与避坑指南：来自27个生产项目的血泪总结

5.1 “MCP握手成功，但调用返回404” —— 路径拼写陷阱

现象：curl -X OPTIONS http://localhost:8081/mcp/v1/handshake -H "X-MCP-Version: 1.0"返回200，但curl -X POST http://localhost:8081/mcp/v1/call -H "Content-Type: application/json" -d '{"method":"assess_risk","input":{}}'返回404。

原因：MCP规范要求/mcp/v1/call必须是小写，但某些Web框架（如Express.js）默认将路由转为小写，而Go的net/http严格区分大小写。我们的Go适配器里写的是/mcp/v1/call，但前端调用时写了/MCP/V1/CALL。

解决方案：在适配器里统一路径标准化：

// Go适配器中添加路径规范化 http.HandleFunc("/mcp/v1/handshake", func(w http.ResponseWriter, r *http.Request) { if strings.ToLower(r.URL.Path) != "/mcp/v1/handshake" { http.Redirect(w, r, "/mcp/v1/handshake", http.StatusMovedPermanently) return } handleHandshake(w, r) })

5.2 “LangGraph报错：Field required” —— Schema required字段缺失

现象：MCP握手返回的input_schema里"required": ["user_id", "transaction_amount"]，但LangGraph调用时传{"user_id": "u123"}，报错Field required: transaction_amount。

原因：LangChain的BaseTool在_run前会用args_schema校验输入，而校验是严格的——即使transaction_amount在业务逻辑里是可选的，只要Schema声明为required，就必须传。

解决方案：在生成MCP Schema时，区分“业务必需”和“协议必需”。我们的做法是：Swagger里标记为required: true的字段，才放入MCP Schema的required数组；其他字段一律不放，由服务端做默认值填充。例如transaction_amount在Swagger里是required: false，则MCP Schema里不声明required，服务端收到null时默认为0。

5.3 “流式输出卡住” —— Event Stream格式不合规

现象：启用stream_events=True后，LangGraph只收到第一个event，然后阻塞。

原因：MCP Event Stream要求每个event以data:开头，以\n\n结尾，且必须有event:前缀。常见错误：

• 服务端返回data: {"chunk": "hello"}\n（缺少第二个\n）；
• 返回{"event": "chunk", "data": "hello"}（JSON格式，非SSE格式）。

正确格式：

event: chunk data: {"chunk": "hello"} event: chunk data: {"chunk": "world"} event: done data: {"status": "success"}

解决方案：用github.com/alexellis/go-http-serve库生成SSE响应，它自动处理格式。不要手写fmt.Fprintf。

5.4 “多Server调用顺序错乱” —— LangGraph状态覆盖

现象：并行调用三个服务，但state里只保存了最后一个服务的结果。

原因：ToolNode默认将所有Tool的返回值合并到state，如果多个Tool返回同名字段（如都返回risk_level），后执行的会覆盖先执行的。

解决方案：在每个Tool的_run里，返回值用服务