知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 11 - Agent 间通信机制 > 导读:本文从"多个 Agent 各自很聪明,一凑到一起就开始互相拖后腿"这个痛点出发,把通信机制的四个核心问题、消息传递/共享状态/事件驱动三种模式、MCP 与 A2A 两个协议的定位、以及一个完整的双 Agent 消息传递实战逐项讲透,最后给出工程实践与踩坑清单。适合正在设计多 Agent 系统、准备面试 Agent 架构方向的同学。 ## 一、先建立全局认知 ### Q:Agent 间通信要解决的核心问题是什么? A:结论先行——四个问题:传什么、怎么传、传多少、谁能传。这四个问题决定了系统的性能、可扩展性与可维护性。 ```text 通信机制的核心问题: 1. 传什么? 完整对话历史 vs 结构化摘要 vs 共享状态 2. 怎么传? 直接调用 vs 消息队列 vs 事件总线 3. 传多少? 全量信息 vs 按需获取 4. 谁能传? 任意通信 vs 受限通信(只能和上级/邻居通信) ``` 逐条解释为什么这四个问题都绕不开: 1. **"传什么"决定上下文成本与信息保真度的权衡。** 传完整对话历史保真度最高,但 Token 消耗随轮次线性增长;传结构化摘要省 Token,但摘要本身要设计,且有信息损失。这是最需要反复权衡的一个。 2. **"怎么传"决定耦合方式与故障特性。** 直接调用最简单,但调用方要处理被调用方的超时与异常;消息队列引入异步与缓冲,但增加了运维组件;事件总线最解耦,但最难调试。 3. **"传多少"决定是否需要引入外部存储。** 全量传递在 Agent 数量增长后会迅速不可行;按需获取意味着要有"引用 + 拉取"的机制,通常配合外部存储。 4. **"谁能传"决定拓扑结构与可控性。** 任意通信最灵活,但在层级组织里会破坏权限边界;受限通信(只能和上级或邻居通信)更容易审计,但信息传递路径变长。 把这四个问题问清楚,任何通信方案的设计都不会跑偏。 ### Q:为什么通信机制的选择会直接影响系统成败? A:结论先行——因为在多 Agent 系统里,通信路径就是"信息流动的血管",它同时决定了成本(Token 与延迟)、可靠性(丢消息/循环/死锁)和可观测性(能不能定位问题)。 可以把它和上一层的模式选择联系起来看: ```text 协作模式决定"谁和谁协作" ← 组织架构 通信机制决定"信息怎么流动" ← 信息架构 两者必须匹配,否则会出现结构性低效 ``` 举两个不匹配的例子: - 选了**层级模式**(组织上是树)却允许**任意通信**(网状),权限边界就被绕过了,层级控制形同虚设。 - 选了**对等模式**(无中心)却用**共享状态**承载所有信息,状态就会迅速膨胀,而且依赖关系变得隐式、难以推理。 所以说模式与机制是"骨"与"血"的关系,必须一起设计。 ### Q:三种通信模式是怎么划分的? A:结论先行——按"信息存放位置"和"通信耦合方式"划分:消息传递是"点对点投递",共享状态是"集中存放 + 各自读写",事件驱动是"广播 + 订阅"。  *图:消息传递、共享状态与事件驱动三种模式* ```text 信息放在哪? 点对点传递 ──┐ ├── 消息传递:信息在消息里,直接投递给指定接收方 │ 集中存放 ────┼── 共享状态:信息在一个共享对象里,大家读写 │ 广播分发 ────┴── 事件驱动:信息作为事件发布,订阅者自行消费 ``` 接下来逐个展开,每一种都会给出适用场景、优缺点与可运行代码。 ## 二、理解核心机制:三种通信模式 ### Q:消息传递(Message Passing)是怎么工作的? A:结论先行——Agent 之间通过发送和接收消息来通信,每条消息包含发送者、接收者、内容和元数据。  *图:Agent A 与 Agent B 的点对点消息结构* ```text ┌──────────┐ Message ┌──────────┐ │ Agent A │ ──────────────→│ Agent B │ │ │ │ │ │ │←───────────────│ │ │ │ Response │ │ └──────────┘ └──────────┘ 消息结构: { sender: "agent_a", receiver: "agent_b", type: "task" | "result" | "query" | "error", content: "...", metadata: { timestamp, priority, task_id } } ``` **特点:** - 松耦合:Agent 之间不需要知道对方的内部实现。 - 异步友好:消息可以排队处理。 - 可追踪:每条消息都有记录,方便调试。 **缺点:** - 消息格式需要约定。 - 大量消息传递会消耗 Token。 ```python from dataclasses import dataclass, field from typing import Any from datetime import datetime import asyncio @dataclass class AgentMessage: """Agent 间通信的标准消息""" sender: str receiver: str msg_type: str # "task", "result", "query", "error" content: str metadata: dict = field(default_factory=dict) timestamp: str = field(default_factory=lambda: datetime.now().isoformat()) class MessageBus: """简单的消息总线""" def __init__(self): self._queues: dict[str, asyncio.Queue] = {} self._history: list[AgentMessage] = [] def register(self, agent_name: str): """注册 Agent 的消息队列""" self._queues[agent_name] = asyncio.Queue() async def send(self, message: AgentMessage): """发送消息""" self._history.append(message) if message.receiver in self._queues: await self._queues[message.receiver].put(message) else: raise ValueError(f"未知的接收者: {message.receiver}") async def receive(self, agent_name: str, timeout: float = 30.0) -> AgentMessage: """接收消息(带超时)""" try: return await asyncio.wait_for( self._queues[agent_name].get(), timeout=timeout ) except asyncio.TimeoutError: raise TimeoutError(f"{agent_name} 等待消息超时") def get_history(self, agent_name: str = None) -> list[AgentMessage]: """获取消息历史""" if agent_name: return [m for m in self._history if m.sender == agent_name or m.receiver == agent_name] return self._history # 使用示例 bus = MessageBus() bus.register("researcher") bus.register("writer") # Agent A 发送任务给 Agent B await bus.send(AgentMessage( sender="researcher", receiver="writer", msg_type="result", content="调研结果:RAG 技术的 3 个关键趋势是...", metadata={"task_id": "task_001", "priority": "high"} )) # Agent B 接收消息 msg = await bus.receive("writer") print(f"收到来自 {msg.sender} 的消息: {msg.content}") ``` 关键点解读: 1. **`AgentMessage` 是显式契约。** 用 `@dataclass` 把 sender/receiver/msg_type/content/metadata/timestamp 固定下来,这就落实了"消息格式需要约定"这一要求。字段齐全的消息天然可审计。 2. **`msg_type` 区分消息语义。** task/result/query/error 四类让接收方可以按类型分流处理,而不是去猜内容的意图。这是"结构化通信"优于"自由文本通信"的关键。 3. **`metadata` 承载 `task_id` 与 `priority`。** `task_id` 用于关联同一任务的多条消息(链路追踪的基础),`priority` 为优先级调度预留了位置。 4. **`MessageBus` 用 `asyncio.Queue` 做每个 Agent 的收件箱。** 这正是"异步友好"的具体实现——发送方把消息放进队列即可返回,不需要被接收方阻塞。 5. **`receive` 带超时(默认 30 秒)是必需的。** 没有超时的等待就是潜在的死锁:一旦对方从不回消息,这个 Agent 就永远挂住。`asyncio.wait_for` 把"无限等待"变成"有限等待 + 明确报错"。 6. **`_history` 提供事后追溯能力。** 通信日志是排查多 Agent 问题的第一手证据。 一个边界提醒:这个示例的 `send` 是内存内的进程内实现,消息不持久化;如果进程重启,消息与历史都会丢失。生产环境需要换成带持久化的消息中间件,并考虑投递语义(至少一次/至多一次)与去重。 ### Q:共享状态(Shared State / Blackboard)是怎么工作的? A:结论先行——所有 Agent 读写同一个共享状态对象,Agent 之间不直接通信,而是通过修改共享状态间接协作。  *图:黑板模式:多个 Agent 共享同一份状态* ```text ┌──────────┐ 读/写 ┌─────────────────────┐ 读/写 ┌──────────┐ │ Agent A │ ◄──────► │ Shared State │ ◄──────► │ Agent B │ │ │ │ (Blackboard) │ │ │ └──────────┘ │ │ └──────────┘ │ task: "..." │ ┌──────────┐ 读/写 │ research: "..." │ 读/写 ┌──────────┐ │ Agent C │ ◄──────► │ draft: "..." │ ◄──────► │ Agent D │ │ │ │ review: "..." │ │ │ └──────────┘ │ status: "..." │ └──────────┘ └─────────────────────┘ 每个 Agent: 1. 读取共享状态中自己需要的部分 2. 执行自己的任务 3. 把结果写回共享状态 ``` **特点:** - 简单直观:所有信息集中在一个地方。 - 天然支持 LangGraph 的 State 模型。 - 避免消息传递的复杂性。 **缺点:** - 状态可能变得很大(上下文爆炸)。 - 并发写入需要处理冲突。 - Agent 之间的依赖关系隐式存在。 ```python from typing import TypedDict, Annotated from langgraph.graph import StateGraph, END import operator class SharedState(TypedDict): """共享状态:所有 Agent 读写同一个对象""" task: str research_data: str analysis_result: str draft: str review_feedback: str final_output: str # 使用 Annotated + operator.add 实现消息追加 messages: Annotated[list[str], operator.add] def researcher(state: SharedState) -> dict: """研究员:读取 task,写入 research_data""" task = state["task"] # 执行研究... result = llm.invoke(f"研究以下主题:{task}") return { "research_data": result.content, "messages": [f"[Researcher] 完成调研:{task}"] } def analyst(state: SharedState) -> dict: """分析师:读取 research_data,写入 analysis_result""" data = state["research_data"] result = llm.invoke(f"分析以下数据:{data}") return { "analysis_result": result.content, "messages": [f"[Analyst] 完成分析"] } def writer(state: SharedState) -> dict: """写作者:读取 research_data + analysis_result,写入 draft""" research = state["research_data"] analysis = state["analysis_result"] result = llm.invoke(f"基于以下资料撰写文章:\n调研:{research}\n分析:{analysis}") return { "draft": result.content, "messages": [f"[Writer] 完成初稿"] } # 构建图 — Agent 通过共享状态间接通信 graph = StateGraph(SharedState) graph.add_node("researcher", researcher) graph.add_node("analyst", analyst) graph.add_node("writer", writer) graph.set_entry_point("researcher") graph.add_edge("researcher", "analyst") graph.add_edge("analyst", "writer") graph.add_edge("writer", END) app = graph.compile() # 运行 result = app.invoke({ "task": "AI Agent 的发展趋势", "messages": [] }) # result["messages"] 包含所有 Agent 的执行记录 ``` 关键点解读: 1. **State 的字段就是"信息的存放位置"。** task、research_data、analysis_result、draft 各占一个字段,每个 Agent 只读写自己关心的字段——这是用类型系统表达"谁产出什么、谁消费什么"。 2. **节点返回的是"增量字典",不是完整 State。** 每个函数只返回自己修改的字段(`return {"research_data": ...}`),由框架负责合并。这与前文消息传递里"显式投递"形成鲜明对比:这里是"隐式汇聚"。 3. **`Annotated[list[str], operator.add]` 定义了字段的合并策略。** 这是共享状态模式里最关键的一个工程细节:普通字段默认是"后写覆盖",而加了 `operator.add` 后变成"追加"。如果 `messages` 不加这个注解,每次写入都会覆盖历史,执行记录就丢了。 4. **依赖关系是隐式的。** `analyst` 依赖 `researcher` 的输出,但代码里看不到"analyst 在等 researcher"这件事——它只是读了一个字段。这种隐式依赖是可读性提升的代价:图的边(`add_edge`)才真正表达了执行顺序。 5. **并发写入冲突需要额外处理。** 示例是线性流水线(researcher → analyst → writer),不存在并发写;一旦多个节点并行写同一字段,就必须像上面那样明确合并策略,否则会丢失更新。 ### Q:事件驱动(Event-Driven)是怎么工作的? A:结论先行——Agent 不直接互相调用,而是发布和订阅事件;当某个事件发生时,订阅了该事件的 Agent 自动被触发。  *图:Event Bus 发布 / 订阅:A 发布,B / C 订阅* ```text ┌──────────────────┐ │ Event Bus │ │ (事件总线) │ └──────┬───────────┘ │ ┌─────────────────┼─────────────────┐ │ │ │ 发布事件 订阅事件 订阅事件 │ │ │ ┌────▼─────┐ ┌────▼─────┐ ┌────▼─────┐ │ Agent A │ │ Agent B │ │ Agent C │ │ │ │ │ │ │ │ 发布: │ │ 订阅: │ │ 订阅: │ │ research │ │ research │ │ research │ │ _done │ │ _done │ │ _done │ └──────────┘ └──────────┘ └──────────┘ 事件流: Agent A 完成调研 → 发布 "research_done" 事件 Agent B(分析师)收到事件 → 开始分析 Agent C(写作者)收到事件 → 开始准备大纲 ``` **特点:** - 极度松耦合:Agent 之间完全不知道彼此的存在。 - 天然支持并行:多个 Agent 可以同时响应同一事件。 - 易于扩展:新增 Agent 只需订阅相关事件。 **缺点:** - 调试困难:事件流不直观。 - 顺序难以保证。 - 事件风暴:一个事件触发大量后续事件。 ```python from collections import defaultdict import asyncio class EventBus: """事件驱动的 Agent 通信""" def __init__(self): self._subscribers: dict[str, list] = defaultdict(list) self._event_log: list[dict] = [] def subscribe(self, event_type: str, handler): """订阅事件""" self._subscribers[event_type].append(handler) async def publish(self, event_type: str, data: dict): """发布事件,通知所有订阅者""" event = {"type": event_type, "data": data} self._event_log.append(event) handlers = self._subscribers.get(event_type, []) if handlers: # 并行通知所有订阅者 await asyncio.gather(*[h(data) for h in handlers]) # 定义 Agent 作为事件处理器 event_bus = EventBus() async def research_agent(task_data: dict): """研究员:收到任务后开始调研""" result = await llm.ainvoke(f"调研:{task_data['topic']}") # 调研完成,发布事件 await event_bus.publish("research_done", { "topic": task_data["topic"], "findings": result.content }) async def analysis_agent(research_data: dict): """分析师:收到调研结果后开始分析""" result = await llm.ainvoke(f"分析:{research_data['findings']}") await event_bus.publish("analysis_done", { "analysis": result.content }) async def writing_agent(analysis_data: dict): """写作者:收到分析结果后开始写作""" result = await llm.ainvoke(f"撰写文章:{analysis_data['analysis']}") await event_bus.publish("article_done", { "article": result.content }) # 注册事件订阅 event_bus.subscribe("new_task", research_agent) event_bus.subscribe("research_done", analysis_agent) event_bus.subscribe("analysis_done", writing_agent) # 触发流程 await event_bus.publish("new_task", {"topic": "AI Agent 发展趋势"}) ``` 关键点解读: 1. **发布者不需要知道订阅者是谁。** `research_agent` 只负责"发布 `research_done`",谁订阅、有多少订阅者,它一无所知。这就是"极度松耦合"的由来,也是它相对消息传递最本质的区别——消息传递必须指定 `receiver`。 2. **`asyncio.gather` 让所有订阅者并行响应。** 一个事件可以同时触发多个 Agent,这是事件驱动"天然支持并行"的实现机制。 3. **`defaultdict(list)` 支持一对多订阅。** 同一事件可以有多个订阅者,这为"扩展"提供了天然支持:新增 Agent 只需 `subscribe`,不用改任何已有代码——这符合开闭原则。 4. **流程由事件链驱动。** `new_task → research_agent → research_done → analysis_agent → analysis_done → writing_agent → article_done`,整条流水线是通过事件名串起来的,而不是靠显式调用。代价是"流程不直观"——要读懂系统必须先画出事件依赖图。 5. **`_event_log` 是排障的生命线。** 事件驱动的一大缺点就是难调试,事件日志(记录 type 与 data)是唯一有效的回溯手段。 6. **要警惕事件风暴。** 如果 `analysis_done` 又触发了新的 `research_done`,就会形成无限循环。事件驱动的设计必须先画出事件依赖图,确认没有环,或为环设置明确的轮次上限。 ### Q:三种模式怎么选? A:结论先行——按耦合度、实现复杂度、可追踪性、并行支持、状态管理、适合框架、典型场景七个维度对比后,再结合任务形态选择。  *图:三种 Agent 通信方式逐维度对比* ```text ┌──────────────┬──────────────┬──────────────┬──────────────┐ │ 维度 │ 消息传递 │ 共享状态 │ 事件驱动 │ ├──────────────┼──────────────┼──────────────┼──────────────┤ │ 耦合度 │ 中 │ 中 │ 低 │ │ 实现复杂度 │ 中 │ 低 │ 高 │ │ 可追踪性 │ 高 │ 中 │ 低 │ │ 并行支持 │ 需要额外设计 │ 天然支持 │ 天然支持 │ │ 状态管理 │ 分散 │ 集中 │ 分散 │ │ 适合框架 │ AutoGen │ LangGraph │ 自定义 │ │ 典型场景 │ 对话协商 │ 流水线协作 │ 微服务 Agent │ └──────────────┴──────────────┴──────────────┴──────────────┘ ``` 一句话概括三者的气质:**共享状态最简单(LangGraph 原生支持),消息传递最灵活(可追踪性最好),事件驱动最松耦合(但最难调试)。** 选择时可以用两条判据: 1. **需要"指定接收方、请求—响应、结果确认"吗?** 是 → 消息传递。典型场景是对话协商、一问一答。 2. **需要一个事实发生后通知多个互不感知的消费者吗?** 是 → 事件驱动。典型场景是微服务化的 Agent 体系。 而共享状态最适合**上下游关系清晰、按字段传递产物的流水线**——谁产出、谁消费在 State 结构里一目了然。三者并非互斥,实践中经常组合使用:用共享状态承载主干流程,在某个需要协商的节点内用消息传递,在需要广播状态的环节用事件驱动。 ## 三、协议层:MCP 与 A2A 的分工 ### Q:Agent 生态里的两个通信协议分别在解决什么? A:结论先行——MCP(Model Context Protocol)解决"Agent 如何调用外部工具和数据源",A2A(Agent-to-Agent)解决"不同 Agent 之间如何互相协作";两者是垂直与水平两个方向,互补而不竞争。  *图:Agent 间用 A2A 协作,各自用 MCP 调用工具* ```text ┌─────────────────────────────────────────────────────────────┐ │ Agent 通信协议全景 │ │ │ │ ┌─────────────┐ ┌─────────────┐ │ │ │ Agent │ │ Agent │ │ │ │ │◄── A2A 协议 ──────►│ │ │ │ │ ┌───────┐ │ (Agent 间对话) │ ┌───────┐ │ │ │ │ │ LLM │ │ │ │ LLM │ │ │ │ │ └───┬───┘ │ │ └───┬───┘ │ │ │ │ │ │ │ │ │ │ │ │ ┌───▼───┐ │ │ ┌───▼───┐ │ │ │ │ │ MCP │ │ │ │ MCP │ │ │ │ │ │Client │ │ │ │Client │ │ │ │ │ └───┬───┘ │ │ └───┬───┘ │ │ │ └──────┼──────┘ └──────┼──────┘ │ │ │ │ │ │ MCP 协议 MCP 协议 │ │ (调用工具) (调用工具) │ │ │ │ │ │ ┌──────▼──────┐ ┌──────▼──────┐ │ │ │ MCP Server │ │ MCP Server │ │ │ │ (数据库) │ │ (搜索引擎) │ │ │ └─────────────┘ └─────────────┘ │ └─────────────────────────────────────────────────────────────┘ MCP(Model Context Protocol): - Anthropic 发布的开放协议 - 解决:Agent 如何调用外部工具和数据源 - 关系:Agent ↔ Tool(垂直集成) - 类比:USB 接口(设备连接电脑) A2A(Agent-to-Agent): - Google 发布的开放协议 - 解决:不同 Agent 之间如何互相协作 - 关系:Agent ↔ Agent(水平协作) - 类比:HTTP 协议(电脑之间通信) ``` 这个"USB 接口 vs HTTP 协议"的类比值得记住: - **USB(MCP)** 解决的是"设备怎么连上主机",是一次"接入"关系,方向是垂直的。 - **HTTP(A2A)** 解决的是"两台机器怎么互相通信",是一次"对等"关系,方向是水平的。 把这张图画出来,就能看出为什么两者可以叠加:一个 Agent 既需要"用工具"(MCP),也需要"找同事"(A2A)。  *图:MCP 与 A2A 协作全景* ### Q:MCP 和 A2A 的差异具体体现在哪些维度? A:结论先行——发起方、解决的问题、通信方向、协议基础、核心概念、能力发现方式六个维度都不同。  *图:MCP 与 A2A 的差异:逐维度对比* ```text ┌──────────────┬──────────────────────┬──────────────────────┐ │ 维度 │ MCP │ A2A │ ├──────────────┼──────────────────────┼──────────────────────┤ │ 发起方 │ Anthropic │ Google │ │ 解决问题 │ Agent 调用工具 │ Agent 之间协作 │ │ 通信方向 │ Agent → Tool │ Agent ↔ Agent │ │ 协议基础 │ JSON-RPC + stdio/SSE │ HTTP + JSON-RPC + SSE│ │ 核心概念 │ Tool, Resource │ Agent Card, Task │ │ 能力发现 │ list_tools() │ Agent Card(JSON) │ │ 关系 │ 互补,不竞争 │ └──────────────┴──────────────────────┴──────────────────────┘ ``` 其中"能力发现"的差异最值得深挖,因为它反映了两种不同的发现对象: - **MCP 发现的是"能力"。** `list_tools()` 返回的是一个 Server 能提供哪些工具,粒度是函数级。 - **A2A 发现的是"身份与专长"。** Agent Card 是一份 JSON 描述,告诉别人"我是谁、我能做什么、怎么联系我",粒度是 Agent 级。 换句话说:MCP 回答"你能做什么",A2A 回答"你是谁、我们怎么协作"。这两个问题在多 Agent 系统里都需要答案,只是回答的层次不同。 一句话总结:**MCP 让 Agent 能用工具,A2A 让 Agent 能找同事;两者配合 = Agent 既能用工具,又能和其他 Agent 协作。** 需要说明的是,这两个协议的具体字段、传输细节与版本演进较快,落地时需以各自官方规范为准,不要依赖二手材料的细节描述。 ## 四、实战与工程实践 ### Q:用 LangGraph 实现两个 Agent 的消息传递,完整代码长什么样? A:结论先行——一个"提问者"Agent 和一个"回答者"Agent 通过共享的消息列表来回对话:提问者提问,回答者回答,回答后轮回到提问者,直到提问者表示理解或达到最大轮次。 ```python from langgraph.graph import StateGraph, END from typing import TypedDict, Annotated, Literal from langchain_openai import ChatOpenAI import operator # ============================================================ # 1. 定义共享状态(消息列表) # ============================================================ class Message(TypedDict): sender: str content: str msg_type: str # "question", "answer", "done" class ConversationState(TypedDict): topic: str messages: Annotated[list[Message], operator.add] turn_count: int is_resolved: bool # ============================================================ # 2. 定义两个 Agent # ============================================================ llm = ChatOpenAI(model="gpt-4o") async def questioner_agent(state: ConversationState) -> dict: """提问者 Agent:根据之前的对话提出问题""" history = "\n".join([ f"[{m['sender']}] {m['content']}" for m in state["messages"] ]) if not state["messages"]: # 第一轮:提出初始问题 prompt = f"你是一个好奇的学习者。请针对「{state['topic']}」提出一个深入的问题。" else: # 后续轮:根据回答追问或表示满意 prompt = f"""你是一个好奇的学习者,正在学习「{state['topic']}」。 对话历史: {history} 如果你觉得已经理解了,回复"我已经理解了,谢谢!"。 否则,提出一个追问。""" response = await llm.ainvoke([{"role": "user", "content": prompt}]) is_done = "已经理解" in response.content or "谢谢" in response.content return { "messages": [Message( sender="questioner", content=response.content, msg_type="done" if is_done else "question" )], "turn_count": state["turn_count"] + 1, "is_resolved": is_done, } async def answerer_agent(state: ConversationState) -> dict: """回答者 Agent:回答提问者的问题""" history = "\n".join([ f"[{m['sender']}] {m['content']}" for m in state["messages"] ]) prompt = f"""你是一个耐心的专家,正在回答关于「{state['topic']}」的问题。 对话历史: {history} 请回答最新的问题,要求清晰、准确、有例子。""" response = await llm.ainvoke([{"role": "user", "content": prompt}]) return { "messages": [Message( sender="answerer", content=response.content, msg_type="answer" )], } # ============================================================ # 3. 定义路由逻辑 # ============================================================ def should_continue(state: ConversationState) -> Literal["answerer", "end"]: """判断是否继续对话""" if state["is_resolved"]: return "end" if state["turn_count"] >= 5: # 最多 5 轮 return "end" return "answerer" # ============================================================ # 4. 构建 LangGraph 图 # ============================================================ graph = StateGraph(ConversationState) # 添加节点 graph.add_node("questioner", questioner_agent) graph.add_node("answerer", answerer_agent) # 设置入口 graph.set_entry_point("questioner") # 添加边 graph.add_conditional_edges("questioner", should_continue, { "answerer": "answerer", "end": END, }) graph.add_edge("answerer", "questioner") # 回答后轮到提问者 # 编译 app = graph.compile() # ============================================================ # 5. 运行 # ============================================================ async def main(): result = await app.ainvoke({ "topic": "向量数据库的索引原理", "messages": [], "turn_count": 0, "is_resolved": False, }) print("=== 对话记录 ===") for msg in result["messages"]: role = "🙋 提问者" if msg["sender"] == "questioner" else "🎓 专家" print(f"\n{role}:{msg['content']}") print(f"\n共 {result['turn_count']} 轮对话") # asyncio.run(main()) ``` ```text 运行效果: === 对话记录 === 🙋 提问者:向量数据库在做近似最近邻搜索时,HNSW 索引是如何工作的? 🎓 专家:HNSW(Hierarchical Navigable Small World)是一种分层图索引... 它的核心思想是构建多层跳表结构... 🙋 提问者:HNSW 和 IVF 索引相比,各自的优缺点是什么? 🎓 专家:HNSW 查询速度快但内存占用大,IVF 内存效率高但需要训练... 🙋 提问者:我已经理解了,谢谢! 共 3 轮对话 ``` 关键点解读: 1. **消息列表用 `Annotated[list[Message], operator.add]` 追加,而不是覆盖。** 这是整个实战的地基:两个 Agent 各自把自己那一条写入,追加语义保证对话历史不会被后一条覆盖掉。如果这里写成普通的 `list[Message]`,第二个人发言时历史就没了。 2. **两个 Agent 是"共享状态 + 消息语义"的混合模式。** 它们没有直接调用对方,而是各自往 `messages` 里写入自己的发言、从 `messages` 里读取对方的历史——这正是共享状态模式,但承载的语义是消息。 3. **每条消息带 `sender` 与 `msg_type`。** `sender` 让渲染和路由能区分角色,`msg_type`(question/answer/done)让流程状态可以程序化判断,而不是再去解析自然语言。 4. **`should_continue` 是终止条件的显式实现。** 两个终止分支:`is_resolved` 为真(软条件,靠关键词判断)或 `turn_count >= 5`(硬条件,防死循环)。软硬结合是对话类 Agent 的必要设计——只靠软条件可能永远不结束,只靠硬条件用户体验差。 5. **图的边定义了对话的"轮转"。** `add_conditional_edges` 让提问者节点之后可以走向回答者或结束;`add_edge("answerer", "questioner")` 构成回路,让对话能继续。有环图是"多轮对话"的实现基础。 6. **注意 `is_done` 的判断方式比较脆弱。** 代码用 `"已经理解" in response.content or "谢谢" in response.content` 做关键词匹配,模型换个说法(比如"明白了")就会漏判,最终退化为靠 `turn_count` 兜底。生产系统通常会要求模型以结构化格式输出终止信号,而不是靠关键词。 7. **`Message` 与 `ConversationState` 都是 `TypedDict`。** 它们只是类型提示,运行时不强制校验;如果需要真正的运行时校验,应换成 Pydantic 模型——这是 TypedDict 与数据校验模型在工程上的常见取舍点。  *图:双 Agent 对话流程* ### Q:通信设计有哪些必须遵守的实践? A:结论先行——六条:只传必要信息、定义清晰的消息格式、设置超时和重试、记录通信日志、控制通信轮次、按场景选择模式。 ```text 1. 只传必要信息 ✗ 把完整的 20 轮对话历史传给下一个 Agent ✓ 传结构化摘要:{findings: [...], conclusion: "..."} 2. 定义清晰的消息格式 所有 Agent 遵循统一的消息结构 包含 sender、type、content、metadata 3. 设置超时和重试 Agent 等待消息不能无限等 超时后使用默认值或报错 4. 记录通信日志 每条消息都要记录,方便调试 包含时间戳、发送者、接收者、内容摘要 5. 控制通信轮次 设置最大轮次,防止 Agent 无限对话 每轮检查是否达到终止条件 6. 选择合适的模式 流水线任务 → 共享状态 协商决策 → 消息传递 微服务架构 → 事件驱动 ``` 逐条补充"为什么": - **"只传必要信息"是成本与保真度的权衡。** 完整历史保真但贵;结构化摘要便宜但有损。经验做法是"结论进上下文,原始产物进外部存储,用引用连接"。 - **"统一的格式"是可组合的前提。** 格式不统一,Agent 之间就要写适配层,多 Agent 的 M×N 复杂度会卷土重来。 - **"超时"防的是死锁,"重试"防的是瞬时故障。** 但重试必须配合幂等,否则会重复执行副作用操作。 - **"日志"是多 Agent 系统的调试基础设施。** 分布式问题无法靠断点调试,只能靠日志回溯。 - **"轮次上限"是底线保险。** 所有循环式协作都必须有硬上限,这和对等模式、辩论模式的要求完全一致。 - **"模式匹配场景"避免结构性低效。** 用错了模式,后面的调优都是在错误的地基上打补丁。 ### Q:还有哪些常见的通信坑? A:结论先行——共享状态无限膨胀、并发写覆盖、消息缺少 task_id 导致无法追链路、事件风暴、以及跨进程通信的投递语义问题。  *图:共享状态与消息设计的五个坑及应对* ```text 坑 1:共享状态无限膨胀 所有中间产物都塞进 State,上下文与内存双爆 → 区分工作状态 / 长期产物 / 审计轨迹;大结果放外部存储,State 只留摘要与引用 坑 2:并发写同一字段导致丢失更新 两个节点并行写 messages 且未定义合并策略 → 后写覆盖先写 → 明确字段归属,或用 Annotated 定义合并策略(如 operator.add) 坑 3:消息缺少 task_id / 幂等键 异步、至少一次投递环境下出现重复或乱序 → 无法去重、无法关联 → 消息必须携带 task_id、版本与幂等键 坑 4:事件风暴 一个事件触发大量后续事件,甚至形成环 → 先画事件依赖图,确认无环;有环则设轮次上限 坑 5:跨进程通信忽略投递语义 进程内 asyncio.Queue 换成消息中间件后,假设"一定送达" → 明确至少一次/至多一次语义,消费端必须能安全处理重复与乱序 ``` 第 2 条最容易被忽视,也最容易造成"偶发丢消息"这种极难排查的 bug。它的根因是共享状态的"写入语义"没有显式定义:默认是覆盖,而多 Agent 场景下多数情况下你想要的是追加或合并。开发阶段串行执行不会暴露这个问题,一旦改成并行就会突然出现——所以应当在设计阶段就把合并策略写清楚。 ## 小结 - 通信机制要回答四个问题:传什么、怎么传、传多少、谁能传。 - 三种核心模式:消息传递(点对点、可追踪性最好)、共享状态(集中存放、最简单)、事件驱动(广播订阅、最松耦合)。 - 共享状态最简单,LangGraph 原生支持;它的关键细节是字段的合并策略(`Annotated` + `operator.add` 实现追加而非覆盖)。 - 事件驱动最解耦、天然支持并行,代价是难调试、顺序无保证、可能出现事件风暴。 - MCP 与 A2A 是两个互补协议:MCP 管工具调用(垂直),A2A 管 Agent 协作(水平),能力发现的对象一个是"能力"、一个是"身份与专长"。 - 双 Agent 对话实战的核心是:追加型消息列表 + 显式路由 + 软硬结合的终止条件(语义信号 + 最大轮次)。 - 通信设计关键:只传必要信息、统一消息格式、设置超时与重试、记录通信日志、控制通信轮次、按场景选择模式。 - 常见坑:状态膨胀、并发写覆盖、消息缺少 `task_id`/幂等键、事件风暴、跨进程投递语义被忽略。 ## 思考题 1. 在共享状态模式中,如果两个 Agent 同时写入同一个字段,会发生什么?如何解决? - **参考答案:**可能发生覆盖、丢失更新或得到不一致状态。可按字段拆分所有权、采用追加型数据结构、使用版本号/比较并交换(CAS)或事务锁,并让冲突进入明确的合并节点。 2. 消息传递和事件驱动的边界在哪里?什么时候该用哪个? - **参考答案:**需要指定接收方、请求—响应、结果确认或严格任务编排时用消息传递;一个事实发生后需通知多个独立订阅者、且发布者不应知道消费者时用事件驱动。二者可组合使用。 3. 为什么通信消息应携带 `task_id`、版本和幂等键? - **参考答案:**它们用于关联链路、识别过期协议、去重与安全重试;在异步、至少一次投递环境中尤其关键。消费者应能安全处理重复或乱序消息。 4. 如何避免共享状态无限膨胀? - **参考答案:**区分工作状态、长期产物和审计轨迹;只在 State 中保留当前节点所需摘要,大型结果放外部存储并用引用连接。为字段设置生命周期、大小上限和压缩策略。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入