{ "metadata": { "id": "ch08", "title": "第8章：多Agent协作", "volume": "vol3", "volume_title": "进阶篇", "word_count": 2810, "difficulty": "intermediate", "prerequisites": [ "ch04", "ch06" ], "key_concepts": [ "为什么需要多Agent？", "单Agent vs 多Agent", "何时选择多Agent", "多Agent架构模式", "层级式架构（Hierarchical）", "对等式架构（Peer-to-Peer）", "黑板式架构（Blackboard）", "Agent间通信协议", "消息格式标准化", "通信模式", "任务分配与负载均衡", "静态分配 vs 动态分配", "能力匹配分配器", "多Agent框架实战", "AutoGen" ], "learning_objectives": [], "estimated_tokens": 1686, "source_file": "vol3/ch08_多Agent协作.md" }, "overview": "", "sections": [ { "id": "8.1", "title": "8.1 为什么需要多Agent？", "level": 2, "content": "单个 Agent 的能力受限于其底层模型的上下文窗口、推理能力和工具集。当面对以下场景时，多 Agent 协作成为更好的选择：\n\n1. **复杂任务分解**：需要不同专业领域知识的任务\n2. **并行处理**：可拆分为独立子任务以提升效率\n3. **冗余验证**：关键决策需要多方确认\n4. **专家协作**：模拟真实团队中不同角色的协同", "subsections": [ { "id": "8.1.1", "title": "8.1.1 单Agent vs 多Agent", "content": "" }, { "id": "8.1.2", "title": "8.1.2 何时选择多Agent", "content": "**适合多Agent的场景：**\n- 需要不同领域专业知识（如代码审查 + 安全审计 + 性能优化）\n- 任务可自然分解为独立子任务\n- 需要冗余验证或交叉检查\n- 模拟多方对话或辩论\n\n**不适合多Agent的场景：**\n- 简单的单步任务（杀鸡用牛刀）\n- 严格顺序依赖、无法并行的流程\n- 实时性要求极高的场景（Agent间通信开销）\n- 成本敏感场景（每次Agent调用都有LLM成本）\n\n---" } ] }, { "id": "8.2", "title": "8.2 多Agent架构模式", "level": 2, "content": "", "subsections": [ { "id": "8.2.1", "title": "8.2.1 层级式架构（Hierarchical）", "content": "层级式架构中，存在明确的上下级关系，顶层 Agent 负责任务分配和结果汇总，底层 Agent 执行具体任务。\n\n\n**优势：**\n- 控制流清晰，易于调试\n- 适合需要全局视角的任务编排\n- 容易实现优先级和依赖管理\n\n**劣势：**\n- 协调者成为性能瓶颈\n- 顶层Agent需要理解全局，上下文压力大\n- 缺乏底层间的直接协作\n\n**代码实现：**" }, { "id": "8.2.2", "title": "8.2.2 对等式架构（Peer-to-Peer）", "content": "对等式架构中没有中央协调者，所有 Agent 地位平等，通过直接通信进行协作。\n\n\n**优势：**\n- 去中心化，无单点故障\n- Agent间可灵活协作\n- 适合开放式探索任务\n\n**劣势：**\n- 缺乏全局协调，可能出现混乱\n- 消息传递可能形成循环\n- 一致性保证困难\n\n**代码实现：**" }, { "id": "8.2.3", "title": "8.2.3 黑板式架构（Blackboard）", "content": "黑板式架构中，Agent 通过共享的\"黑板\"（Blackboard）进行间接通信。黑板是一个结构化的共享存储空间。\n\n\n**优势：**\n- 解耦——Agent不需要知道彼此的存在\n- 灵活——Agent可以随时加入/退出\n- 可追溯——黑板上的所有变更都有记录\n\n**劣势：**\n- 黑板可能成为性能瓶颈\n- 信息过载——Agent需要筛选相关信息\n- 冲突解决复杂——多个Agent同时写入同一区域\n\n**代码实现：**\n\n\n---" } ] }, { "id": "8.3", "title": "8.3 Agent间通信协议", "level": 2, "content": "", "subsections": [ { "id": "8.3.1", "title": "8.3.1 消息格式标准化", "content": "在多 Agent 系统中，统一的通信协议至关重要。以下是推荐的标准化消息格式：" }, { "id": "8.3.2", "title": "8.3.2 通信模式", "content": "---" } ] }, { "id": "8.4", "title": "8.4 任务分配与负载均衡", "level": 2, "content": "", "subsections": [ { "id": "8.4.1", "title": "8.4.1 静态分配 vs 动态分配", "content": "| 维度 | 静态分配 | 动态分配 |\n|------|---------|---------|\n| 分配时机 | 任务开始前确定 | 运行时根据状态调整 |\n| 灵活性 | 低 | 高 |\n| 开销 | 小 | 较大（需要状态监控） |\n| 适用场景 | 任务类型固定 | 任务类型多变 |" }, { "id": "8.4.2", "title": "8.4.2 能力匹配分配器", "content": "---" } ] }, { "id": "8.5", "title": "8.5 多Agent框架实战", "level": 2, "content": "", "subsections": [ { "id": "8.5.1", "title": "8.5.1 AutoGen", "content": "Microsoft 的 AutoGen 是目前最流行的多 Agent 框架之一，以对话为核心进行 Agent 协作。\n\n\n**AutoGen 核心概念：**\n\n| 概念 | 说明 |\n|------|------|\n| `UserProxyAgent` | 用户代理，可执行代码 |\n| `AssistantAgent` | LLM驱动的Agent |\n| `GroupChat` | 多Agent群聊 |\n| `GroupChatManager` | 群聊管理器，决定谁发言 |\n| `max_round` | 最大对话轮次限制 |" }, { "id": "8.5.2", "title": "8.5.2 CrewAI", "content": "CrewAI 采用了\"角色扮演\"的方式组织多 Agent 协作，每个 Agent 都有明确的角色、目标和工具。\n\n\n**CrewAI vs AutoGen 对比：**\n\n| 维度 | AutoGen | CrewAI |\n|------|---------|--------|\n| **协作模式** | 自由对话 | 角色扮演 |\n| **流程控制** | GroupChatManager 管理 | Task 链式编排 |\n| **任务定义** | 对话驱动 | 显式 Task 定义 |\n| **工具集成** | 内置代码执行 | 自定义 @tool |\n| **适用场景** | 开放式探索 | 结构化流水线 |\n| **学习曲线** | 低 | 中 |" }, { "id": "8.5.3", "title": "8.5.3 LangGraph", "content": "LangGraph 用图（Graph）的方式建模 Agent 的工作流，特别适合需要条件分支和循环的复杂场景。\n\n\n---" } ] }, { "id": "8.6", "title": "8.6 冲突解决与共识机制", "level": 2, "content": "", "subsections": [ { "id": "8.6.1", "title": "8.6.1 常见冲突类型", "content": "| 冲突类型 | 描述 | 示例 |\n|---------|------|------|\n| **结果冲突** | 多个Agent产生矛盾的结果 | AgentA说用方案A，AgentB说用方案B |\n| **资源冲突** | 多个Agent争抢同一资源 | 两个Agent同时修改同一文件 |\n| **顺序冲突** | Agent执行顺序不当 | 测试Agent在编码Agent完成前运行 |\n| **权限冲突** | Agent执行了越权操作 | 开发Agent尝试部署到生产环境 |" }, { "id": "8.6.2", "title": "8.6.2 冲突解决策略", "content": "" }, { "id": "8.6.3", "title": "8.6.3 共识协议：Raft-inspired Agent Consensus", "content": "---" } ] }, { "id": "8.7", "title": "8.7 最佳实践与常见陷阱", "level": 2, "content": "", "subsections": [ { "id": "8.7.1", "title": "8.7.1 最佳实践", "content": "1. **从简单开始**：先用单Agent验证核心逻辑，确认需要多Agent后再扩展\n2. **定义清晰的接口**：每个Agent的输入/输出格式要标准化\n3. **设置合理的超时**：Agent间调用必须有超时机制，防止无限等待\n4. **实现优雅降级**：当某个Agent失败时，系统不应完全崩溃\n5. **记录一切**：完整的消息日志是调试多Agent系统的关键\n6. **控制成本**：多Agent意味着多次LLM调用，要监控Token消耗" }, { "id": "8.7.2", "title": "8.7.2 常见陷阱", "content": "" }, { "id": "8.7.3", "title": "8.7.3 生产环境检查清单", "content": "---" } ] }, { "id": "8.8", "title": "8.8 小结", "level": 2, "content": "本章系统介绍了多 Agent 协作的核心模式和实践方法：\n\n- **三种架构模式**：层级式适合需要全局协调的场景，对等式适合开放式探索，黑板式适合解耦协作\n- **通信协议**：标准化的消息格式和通信模式是多Agent系统稳定运行的基石\n- **任务分配**：基于能力匹配的智能分配器能显著提升系统效率\n- **主流框架**：AutoGen 适合对话驱动、CrewAI 适合角色扮演、LangGraph 适合复杂流程\n- **冲突解决**：多种策略各有适用场景，关键是提前定义好解决机制\n\n**下一章预告：** 第9章将深入探讨 Agent 的推理与规划能力，从 ReAct 到 Graph-of-Thought，揭示 Agent 如何\"思考\"。\n\n---\n\n*第8章 · 多Agent协作* | *Agent 编程：从原理到生产级实践 · 卷三 · 进阶篇*", "subsections": [] } ], "code_blocks": [ { "id": "code-1", "language": "text", "description": "4. 专家协作：模拟真实团队中不同角色的协同", "code": "┌─────────────────────────────────────────────────────────┐\n│ 单 Agent 架构 │\n│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │\n│ │ 感知层 │ → │ 推理层 │ → │ 行动层 │ │\n│ └─────────┘ └─────────┘ └─────────┘ │\n│ ↓ ↓ ↓ │\n│ 输入/工具 LLM 推理 输出/调用 │\n└─────────────────────────────────────────────────────────┘\n\n┌─────────────────────────────────────────────────────────┐\n│ 多 Agent 架构 │\n│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │\n│ │协调者 │←→│专家A │←→│专家B │←→│专家C │ │\n│ └──┬───┘ └──────┘ └──────┘ └──────┘ │\n│ │ │\n│ ┌──┴──────────────────────────────────┐ │\n│ │ 共享消息总线 / 黑板 │ │\n│ └─────────────────────────────────────┘ │\n└─────────────────────────────────────────────────────────┘", "section_ref": "8.1.1", "runnable": false, "dependencies": [] }, { "id": "code-2", "language": "text", "description": "层级式架构中，存在明确的上下级关系，顶层 Agent 负责任务分配和结果汇总，底层 Agent 执行具体任务。", "code": " ┌──────────────┐\n │ 协调者 Agent │\n │ (Orchestrator) │\n └──┬───┬───┬────┘\n │ │ │\n ┌─────┘ │ └─────┐\n ↓ ↓ ↓\n┌─────────┐┌─────────┐┌─────────┐\n│ 专家A ││ 专家B ││ 专家C │\n│ (代码) ││ (安全) ││ (测试) │\n└─────────┘└─────────┘└─────────┘", "section_ref": "8.2.1", "runnable": false, "dependencies": [] }, { "id": "code-3", "language": "python", "description": "代码实现：", "code": "from typing import Protocol, Any\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nimport asyncio\n\n\nclass AgentRole(Enum):\n ORCHESTRATOR = \"orchestrator\"\n CODER = \"coder\"\n REVIEWER = \"reviewer\"\n TESTER = \"tester\"\n SECURITY = \"security\"\n\n\n@dataclass\nclass Task:\n \"\"\"任务定义\"\"\"\n id: str\n description: str\n assigned_to: AgentRole | None = None\n result: Any = None\n dependencies: list[str] = field(default_factory=list)\n status: str = \"pending\" # pending, in_progress, completed, failed\n\n\n@dataclass\nclass Message:\n \"\"\"Agent间消息\"\"\"\n from_agent: AgentRole\n to_agent: AgentRole\n content: str\n task_id: str | None = None\n metadata: dict = field(default_factory=dict)\n\n\nclass Agent(Protocol):\n \"\"\"Agent协议\"\"\"\n async def receive(self, message: Message) -> None: ...\n async def execute(self, task: Task) -> Any: ...\n @property\n def role(self) -> AgentRole: ...\n\n\nclass HierarchicalOrchestrator:\n \"\"\"层级式协调者\"\"\"\n \n def __init__(self, agents: dict[AgentRole, Agent]):\n self.agents = agents\n self.task_queue: list[Task] = []\n self.completed_tasks: dict[str, Any] = {}\n \n async def submit_task(self, task: Task) -> Any:\n \"\"\"提交任务并等待完成\"\"\"\n # 1. 分析任务，确定需要哪些Agent\n plan = await self._plan_task(task)\n \n # 2. 按计划分配子任务\n for sub_task in plan:\n self.task_queue.append(sub_task)\n \n # 3. 执行任务链\n results = {}\n for sub_task in self.task_queue:\n # 检查依赖\n for dep_id in sub_task.dependencies:\n if dep_id not in self.completed_tasks:\n raise RuntimeError(f\"依赖任务 {dep_id} 未完成\")\n \n # 分配给对应Agent\n agent = self.agents[sub_task.assigned_to]\n message = Message(\n from_agent=AgentRole.ORCHESTRATOR,\n to_agent=sub_task.assigned_to,\n content=sub_task.description,\n task_id=sub_task.id\n )\n await agent.receive(message)\n \n # 执行并收集结果\n result = await agent.execute(sub_task)\n self.completed_tasks[sub_task.id] = result\n results[sub_task.id] = result\n \n # 4. 汇总结果\n return await self._aggregate_results(task, results)\n \n async def _plan_task(self, task: Task) -> list[Task]:\n \"\"\"将大任务分解为子任务链\"\"\"\n # 在实际系统中，这里会调用LLM进行任务规划\n return [\n Task(id=f\"{task.id}_code\", description=f\"实现: {task.description}\",\n assigned_to=AgentRole.CODER),\n Task(id=f\"{task.id}_review\", description=f\"审查上述代码\",\n assigned_to=AgentRole.REVIEWER,\n dependencies=[f\"{task.id}_code\"]),\n Task(id=f\"{task.id}_test\", description=f\"编写测试用例\",\n assigned_to=AgentRole.TESTER,\n dependencies=[f\"{task.id}_code\"]),\n Task(id=f\"{task.id}_security\", description=f\"安全审计\",\n assigned_to=AgentRole.SECURITY,\n dependencies=[f\"{task.id}_code\"]),\n ]\n \n async def _aggregate_results(self, task: Task, results: dict) -> Any:\n \"\"\"汇总各Agent的结果\"\"\"\n return {\n \"original_task\": task.description,\n \"code\": results.get(f\"{task.id}_code\"),\n \"review\": results.get(f\"{task.id}_review\"),\n \"tests\": results.get(f\"{task.id}_test\"),\n \"security_audit\": results.get(f\"{task.id}_security\"),\n }", "section_ref": "8.2.1", "runnable": true, "dependencies": [] }, { "id": "code-4", "language": "text", "description": "对等式架构中没有中央协调者，所有 Agent 地位平等，通过直接通信进行协作。", "code": "┌─────────┐ ┌─────────┐ ┌─────────┐\n│ AgentA │ ←→ │ AgentB │ ←→ │ AgentC │\n│ (前端) │ │ (后端) │ │ (数据) │\n└────┬────┘ └────┬────┘ └────┬────┘\n │ │ │\n └───────────────┼───────────────┘\n │\n ┌────────┴────────┐\n │ 消息总线 │\n │ (Message Bus) │\n └─────────────────┘", "section_ref": "8.2.2", "runnable": false, "dependencies": [] }, { "id": "code-5", "language": "python", "description": "代码实现：", "code": "import asyncio\nfrom collections import defaultdict\nfrom typing import Callable\n\n\nclass MessageBus:\n \"\"\"Agent间消息总线\"\"\"\n \n def __init__(self):\n self.subscribers: dict[AgentRole, list[Callable]] = defaultdict(list)\n self.message_log: list[Message] = []\n \n def subscribe(self, role: AgentRole, handler: Callable):\n \"\"\"订阅特定角色的消息\"\"\"\n self.subscribers[role].append(handler)\n \n async def publish(self, message: Message):\n \"\"\"发布消息\"\"\"\n self.message_log.append(message)\n handlers = self.subscribers.get(message.to_agent, [])\n for handler in handlers:\n await handler(message)\n \n async def broadcast(self, from_agent: AgentRole, content: str):\n \"\"\"广播消息给所有Agent\"\"\"\n for role in self.subscribers:\n message = Message(\n from_agent=from_agent,\n to_agent=role,\n content=content\n )\n await self.publish(message)\n\n\nclass PeerAgent:\n \"\"\"对等Agent实现\"\"\"\n \n def __init__(self, role: AgentRole, expertise: str, message_bus: MessageBus):\n self.role = role\n self.expertise = expertise\n self.bus = message_bus\n self.knowledge_base: list[str] = []\n self.bus.subscribe(role, self._on_message)\n \n async def _on_message(self, message: Message):\n \"\"\"收到消息的处理\"\"\"\n print(f\"[{self.role.value}] 收到来自 {message.from_agent.value} 的消息: {message.content[:50]}...\")\n \n # 如果不是我能处理的，转发给其他合适的Agent\n if not self._can_handle(message.content):\n await self._forward_message(message)\n \n def _can_handle(self, content: str) -> bool:\n \"\"\"判断是否能处理该消息\"\"\"\n # 实际中这里会调用LLM判断\n keywords = {\n \"前端\": [\"HTML\", \"CSS\", \"React\", \"UI\", \"组件\"],\n \"后端\": [\"API\", \"数据库\", \"服务\", \"接口\", \"认证\"],\n \"数据\": [\"数据\", \"分析\", \"模型\", \"特征\", \"统计\"],\n }\n expertise_keywords = keywords.get(self.expertise, [])\n return any(kw in content for kw in expertise_keywords)\n \n async def _forward_message(self, message: Message):\n \"\"\"转发消息\"\"\"\n for role in [AgentRole.CODER, AgentRole.TESTER, AgentRole.SECURITY]:\n if role != self.role:\n forward = Message(\n from_agent=self.role,\n to_agent=role,\n content=f\"[转发] {message.content}\",\n task_id=message.task_id\n )\n await self.bus.publish(forward)\n \n async def execute(self, task: Task) -> Any:\n \"\"\"执行任务\"\"\"\n # 广播自己的工作状态\n await self.bus.broadcast(\n self.role,\n f\"开始处理任务: {task.description}\"\n )\n \n # 实际执行（此处模拟）\n result = f\"[{self.expertise}] 处理完成: {task.description}\"\n self.knowledge_base.append(result)\n \n return result\n\n\nasync def demo_peer_to_peer():\n \"\"\"演示对等式多Agent\"\"\"\n bus = MessageBus()\n \n agents = {\n AgentRole.CODER: PeerAgent(AgentRole.CODER, \"前端\", bus),\n AgentRole.TESTER: PeerAgent(AgentRole.TESTER, \"后端\", bus),\n AgentRole.SECURITY: PeerAgent(AgentRole.SECURITY, \"数据\", bus),\n }\n \n task = Task(id=\"demo_1\", description=\"实现一个用户登录页面，包含前端UI和后端API\")\n \n # 所有Agent并行尝试处理\n results = await asyncio.gather(*[\n agent.execute(task) for agent in agents.values()\n ])\n \n return results", "section_ref": "8.2.2", "runnable": true, "dependencies": [] }, { "id": "code-6", "language": "text", "description": "黑板式架构中，Agent 通过共享的\"黑板\"（Blackboard）进行间接通信。黑板是一个结构化的共享存储空间。", "code": "┌────────────────────────────────────────────────────┐\n│ 黑板 (Blackboard) │\n│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │\n│ │ 需求区域 │ │ 代码区域 │ │ 测试区域 │ │\n│ └──────────┘ └──────────┘ └──────────┘ │\n│ ┌──────────┐ ┌──────────┐ │\n│ │ 审查区域 │ │ 安全区域 │ │\n│ └──────────┘ └──────────┘ │\n└──────────┬──────────┬──────────┬───────────────────┘\n │ │ │\n ┌────┴────┐┌───┴────┐┌───┴────┐\n │ 读取/写入 ││ 读取/写入││ 读取/写入│\n └─────────┘└────────┘└────────┘\n ┌─────────┐┌────────┐┌────────┐\n │ AgentA ││ AgentB ││ AgentC │\n └─────────┘└────────┘└────────┘", "section_ref": "8.2.3", "runnable": false, "dependencies": [] }, { "id": "code-7", "language": "python", "description": "代码实现：", "code": "from datetime import datetime\nimport threading\nfrom typing import Any\n\n\nclass BlackboardSection:\n \"\"\"黑板分区\"\"\"\n \n def __init__(self, name: str):\n self.name = name\n self.entries: list[dict] = []\n self.lock = threading.Lock()\n self._change_callbacks: list[Callable] = []\n \n def write(self, author: str, content: Any, tags: list[str] = None):\n \"\"\"写入黑板\"\"\"\n with self.lock:\n entry = {\n \"author\": author,\n \"content\": content,\n \"tags\": tags or [],\n \"timestamp\": datetime.now().isoformat(),\n }\n self.entries.append(entry)\n \n # 通知观察者\n for callback in self._change_callbacks:\n callback(entry)\n \n return entry\n \n def read(self, tags: list[str] = None, author: str = None) -> list[dict]:\n \"\"\"读取黑板\"\"\"\n with self.lock:\n entries = self.entries.copy()\n \n if tags:\n entries = [\n e for e in entries\n if any(t in e.get(\"tags\", []) for t in tags)\n ]\n \n if author:\n entries = [e for e in entries if e[\"author\"] == author]\n \n return entries\n \n def on_change(self, callback: Callable):\n \"\"\"注册变更回调\"\"\"\n self._change_callbacks.append(callback)\n\n\nclass Blackboard:\n \"\"\"共享黑板\"\"\"\n \n def __init__(self):\n self.sections: dict[str, BlackboardSection] = {}\n \n def create_section(self, name: str) -> BlackboardSection:\n \"\"\"创建分区\"\"\"\n section = BlackboardSection(name)\n self.sections[name] = section\n return section\n \n def get_section(self, name: str) -> BlackboardSection:\n \"\"\"获取分区\"\"\"\n return self.sections.get(name, self.create_section(name))\n\n\nclass BlackboardAgent:\n \"\"\"黑板式Agent\"\"\"\n \n def __init__(self, name: str, blackboard: Blackboard, \n watch_sections: list[str]):\n self.name = name\n self.blackboard = blackboard\n self.watch_sections = watch_sections\n \n # 注册对感兴趣分区的监听\n for section_name in watch_sections:\n section = self.blackboard.get_section(section_name)\n section.on_change(self._on_blackboard_update)\n \n def _on_blackboard_update(self, entry: dict):\n \"\"\"黑板更新时的回调\"\"\"\n if entry[\"author\"] == self.name:\n return # 忽略自己写入的内容\n \n # 检查是否需要响应\n if self._should_respond(entry):\n self._respond(entry)\n \n def _should_respond(self, entry: dict) -> bool:\n \"\"\"判断是否需要响应\"\"\"\n # 实际中这里会调用LLM判断\n return True\n \n def _respond(self, entry: dict):\n \"\"\"对黑板更新做出响应\"\"\"\n # 实际中这里会执行具体工作\n print(f\"[{self.name}] 响应黑板更新: {str(entry['content'])[:50]}...\")\n \n def write_to(self, section_name: str, content: Any, \n tags: list[str] = None):\n \"\"\"写入黑板\"\"\"\n section = self.blackboard.get_section(section_name)\n return section.write(self.name, content, tags)\n\n\n# 使用示例\ndef demo_blackboard():\n bb = Blackboard()\n bb.create_section(\"requirements\")\n bb.create_section(\"code\")\n bb.create_section(\"reviews\")\n \n pm_agent = BlackboardAgent(\"PM\", bb, [\"code\", \"reviews\"])\n coder_agent = BlackboardAgent(\"Coder\", bb, [\"requirements\"])\n reviewer_agent = BlackboardAgent(\"Reviewer\", bb, [\"code\"])\n \n # PM写入需求\n pm_agent.write_to(\"requirements\", \"用户需要登录功能\", [\"feature\", \"auth\"])\n \n # Coder看到需求，写入代码\n coder_agent.write_to(\"code\", \"def login(user, pwd): ...\", [\"auth\", \"backend\"])\n \n # Reviewer看到代码，写入审查意见\n reviewer_agent.write_to(\"reviews\", \"建议添加输入验证\", [\"security\"])", "section_ref": "8.2.3", "runnable": true, "dependencies": [ "threading" ] }, { "id": "code-8", "language": "python", "description": "在多 Agent 系统中，统一的通信协议至关重要。以下是推荐的标准化消息格式：", "code": "from pydantic import BaseModel, Field\nfrom typing import Literal, Any\nfrom datetime import datetime\n\n\nclass AgentMessage(BaseModel):\n \"\"\"标准化Agent消息\"\"\"\n \n # 消息标识\n message_id: str = Field(default_factory=lambda: str(uuid4()))\n conversation_id: str # 关联的对话/任务ID\n parent_message_id: str | None = None # 回复的消息ID\n \n # 发送者与接收者\n sender: str # Agent标识\n receiver: str # 目标Agent标识或\"broadcast\"\n \n # 消息类型与内容\n msg_type: Literal[\n \"task_request\", # 任务请求\n \"task_result\", # 任务结果\n \"query\", # 查询\n \"response\", # 响应\n \"notification\", # 通知\n \"error\", # 错误\n \"status_update\", # 状态更新\n ]\n content: str\n structured_data: dict[str, Any] = Field(default_factory=dict)\n \n # 元信息\n priority: Literal[\"low\", \"normal\", \"high\", \"critical\"] = \"normal\"\n requires_response: bool = False\n timeout_seconds: int | None = None\n created_at: str = Field(default_factory=lambda: datetime.now().isoformat())\n\n\nclass MessageProtocol:\n \"\"\"消息协议处理\"\"\"\n \n @staticmethod\n def create_task_request(\n sender: str, receiver: str,\n task_description: str, task_id: str,\n priority: str = \"normal\"\n ) -> AgentMessage:\n return AgentMessage(\n conversation_id=task_id,\n sender=sender,\n receiver=receiver,\n msg_type=\"task_request\",\n content=task_description,\n structured_data={\"task_id\": task_id},\n priority=priority,\n requires_response=True,\n timeout_seconds=300,\n )\n \n @staticmethod\n def create_task_result(\n sender: str, receiver: str,\n result: Any, original_request: AgentMessage,\n status: str = \"success\"\n ) -> AgentMessage:\n return AgentMessage(\n conversation_id=original_request.conversation_id,\n parent_message_id=original_request.message_id,\n sender=sender,\n receiver=original_request.sender,\n msg_type=\"task_result\",\n content=f\"任务完成: {status}\",\n structured_data={\n \"result\": result,\n \"status\": status,\n \"original_task_id\": original_request.structured_data.get(\"task_id\"),\n },\n )", "section_ref": "8.3.1", "runnable": true, "dependencies": [ "pydantic" ] }, { "id": "code-9", "language": "python", "description": "", "code": "class CommunicationPattern:\n \"\"\"通信模式\"\"\"\n \n # 1. 请求-响应（Request-Response）\n # 最基本的模式，同步等待结果\n async def request_response(self, sender, receiver, message, timeout=30):\n future = asyncio.get_event_loop().create_future()\n self._pending_requests[message.message_id] = future\n await self._send(message)\n try:\n return await asyncio.wait_for(future, timeout=timeout)\n except asyncio.TimeoutError:\n return {\"error\": \"timeout\", \"message_id\": message.message_id}\n \n # 2. 发布-订阅（Pub-Sub）\n # Agent订阅感兴趣的主题\n async def publish(self, topic: str, message: AgentMessage):\n subscribers = self._subscriptions.get(topic, [])\n for subscriber in subscribers:\n await self._deliver(subscriber, message)\n \n def subscribe(self, topic: str, agent_id: str, handler: Callable):\n if topic not in self._subscriptions:\n self._subscriptions[topic] = []\n self._subscriptions[topic].append((agent_id, handler))\n \n # 3. 流水线（Pipeline）\n # Agent A → Agent B → Agent C 顺序处理\n async def pipeline(self, agents: list, initial_message: AgentMessage):\n current_message = initial_message\n results = []\n \n for agent in agents:\n result = await agent.process(current_message)\n results.append(result)\n current_message = self._create_pipeline_message(\n agent.role, result\n )\n \n return results", "section_ref": "8.3.2", "runnable": true, "dependencies": [] }, { "id": "code-10", "language": "python", "description": "| 适用场景 | 任务类型固定 | 任务类型多变 |", "code": "from dataclasses import dataclass\n\n\n@dataclass\nclass AgentCapability:\n \"\"\"Agent能力描述\"\"\"\n agent_id: str\n expertise_areas: list[str] # 专业领域\n max_concurrent: int = 3 # 最大并发数\n current_load: int = 0 # 当前负载\n avg_response_time: float = 0.0 # 平均响应时间\n success_rate: float = 1.0 # 成功率\n\n\nclass CapabilityBasedDispatcher:\n \"\"\"基于能力匹配的任务分配器\"\"\"\n \n def __init__(self):\n self.agents: dict[str, AgentCapability] = {}\n \n def register_agent(self, capability: AgentCapability):\n self.agents[capability.agent_id] = capability\n \n def dispatch(self, task_description: str) -> str | None:\n \"\"\"为任务选择最合适的Agent\"\"\"\n # 1. 提取任务关键词\n task_keywords = self._extract_keywords(task_description)\n \n # 2. 计算每个Agent的匹配分数\n scores = {}\n for agent_id, cap in self.agents.items():\n # 跳过已满载的Agent\n if cap.current_load >= cap.max_concurrent:\n continue\n \n # 计算匹配度 (0-1)\n expertise_match = self._calculate_expertise_match(\n task_keywords, cap.expertise_areas\n )\n \n # 负载惩罚 (负载越高分数越低)\n load_factor = 1.0 - (cap.current_load / cap.max_concurrent * 0.5)\n \n # 速度奖励\n speed_factor = 1.0 / (1.0 + cap.avg_response_time / 10.0)\n \n # 质量奖励\n quality_factor = cap.success_rate\n \n # 综合分数\n scores[agent_id] = (\n expertise_match * 0.5 +\n load_factor * 0.2 +\n speed_factor * 0.15 +\n quality_factor * 0.15\n )\n \n if not scores:\n return None\n \n # 3. 返回最高分的Agent\n return max(scores, key=scores.get)\n \n def _extract_keywords(self, text: str) -> list[str]:\n \"\"\"提取关键词（简化版）\"\"\"\n # 实际中可以使用 NLP 工具或 LLM\n stop_words = {\"的\", \"了\", \"是\", \"在\", \"和\", \"请\", \"帮我\", \"我\", \"要\"}\n words = [w for w in text.split() if w not in stop_words and len(w) > 1]\n return words\n \n def _calculate_expertise_match(\n self, task_keywords: list[str], \n expertise: list[str]\n ) -> float:\n \"\"\"计算任务与Agent专业领域的匹配度\"\"\"\n if not task_keywords:\n return 0.1 # 无关键词时给一个基础分\n \n matches = sum(\n 1 for kw in task_keywords \n for area in expertise \n if kw in area or area in kw\n )\n return min(matches / len(task_keywords), 1.0)", "section_ref": "8.4.2", "runnable": true, "dependencies": [] }, { "id": "code-11", "language": "python", "description": "Microsoft 的 AutoGen 是目前最流行的多 Agent 框架之一，以对话为核心进行 Agent 协作。", "code": "import autogen\n\n# 配置LLM\nllm_config = {\n \"model\": \"gpt-4\",\n \"temperature\": 0,\n \"api_key\": \"your-api-key\",\n}\n\n# 定义Agent\nuser_proxy = autogen.UserProxyAgent(\n name=\"User\",\n human_input_mode=\"NEVER\",\n max_consecutive_auto_reply=5,\n code_execution_config={\n \"work_dir\": \"coding\",\n \"use_docker\": False,\n },\n)\n\ncoder = autogen.AssistantAgent(\n name=\"Coder\",\n llm_config=llm_config,\n system_message=\"\"\"你是一个高级Python开发工程师。\n 负责根据需求编写高质量的代码。\n 遵循PEP8规范，编写类型注解和文档字符串。\n 完成后请 reviewer 审查。\"\"\",\n)\n\nreviewer = autogen.AssistantAgent(\n name=\"Reviewer\",\n llm_config=llm_config,\n system_message=\"\"\"你是一个严格的代码审查员。\n 检查代码的：安全性、性能、可读性、错误处理。\n 如果发现问题，请明确提出并给出修改建议。\n 如果代码没有问题，回复 APPROVED。\"\"\",\n)\n\ntester = autogen.AssistantAgent(\n name=\"Tester\",\n llm_config=llm_config,\n system_message=\"\"\"你是一个测试工程师。\n 根据代码编写单元测试和集成测试。\n 使用 pytest 框架。\n 确保覆盖边界情况和异常路径。\"\"\",\n)\n\n# 创建群聊\ngroupchat = autogen.GroupChat(\n agents=[user_proxy, coder, reviewer, tester],\n messages=[],\n max_round=15,\n)\n\nmanager = autogen.GroupChatManager(\n groupchat=groupchat,\n llm_config=llm_config,\n)\n\n# 启动协作\nuser_proxy.initiate_chat(\n manager,\n message=\"请实现一个线程安全的LRU缓存类，支持TTL过期和统计功能。\",\n)", "section_ref": "8.5.1", "runnable": true, "dependencies": [ "autogen" ] }, { "id": "code-12", "language": "python", "description": "CrewAI 采用了\"角色扮演\"的方式组织多 Agent 协作，每个 Agent 都有明确的角色、目标和工具。", "code": "from crewai import Agent, Task, Crew, Process\nfrom crewai.tools import tool\n\n\n# 定义自定义工具\n@tool(\"Search Codebase\")\ndef search_codebase(query: str) -> str:\n \"\"\"在代码库中搜索相关代码\"\"\"\n # 实际实现...\n return f\"搜索结果: {query}\"\n\n\n@tool(\"Run Tests\")\ndef run_tests(test_file: str) -> str:\n \"\"\"运行测试文件\"\"\"\n import subprocess\n result = subprocess.run(\n [\"pytest\", test_file, \"-v\"],\n capture_output=True, text=True\n )\n return result.stdout\n\n\n# 定义Agent角色\narchitect = Agent(\n role=\"系统架构师\",\n goal=\"设计最优的技术方案\",\n backstory=\"\"\"你是一位经验丰富的系统架构师，拥有15年分布式系统设计经验。\n 你擅长将复杂需求拆解为清晰的架构方案，总是考虑可扩展性和可维护性。\n 你使用C4模型进行架构设计，输出Mermaid图表。\"\"\",\n tools=[search_codebase],\n verbose=True,\n allow_delegation=False,\n)\n\ndeveloper = Agent(\n role=\"高级开发工程师\",\n goal=\"编写高质量、可维护的代码\",\n backstory=\"\"\"你是一位追求代码卓越的开发工程师。\n 你遵循SOLID原则，注重代码的可读性和性能。\n 你总是先写测试再写实现（TDD）。\"\"\",\n tools=[search_codebase, run_tests],\n verbose=True,\n allow_delegation=True,\n)\n\nreviewer = Agent(\n role=\"代码审查专家\",\n goal=\"确保代码质量和安全性\",\n backstory=\"\"\"你是一位严格的代码审查员，曾在多个大型项目担任技术负责人。\n 你对代码质量有极高的标准，尤其关注安全漏洞和性能问题。\n 你使用Checklist进行系统性审查。\"\"\",\n tools=[search_codebase],\n verbose=True,\n allow_delegation=False,\n)\n\n# 定义任务\ndesign_task = Task(\n description=\"分析需求文档，设计一个RESTful API的微服务架构。\"\n \"包括服务划分、API设计、数据模型和部署方案。\",\n agent=architect,\n expected_output=\"Mermaid架构图 + API设计文档\",\n)\n\ndevelop_task = Task(\n description=\"根据架构设计文档，实现核心API端点。\"\n \"包括用户认证、CRUD操作和错误处理。\",\n agent=developer,\n expected_output=\"完整的Python代码实现\",\n)\n\nreview_task = Task(\n description=\"审查代码实现，检查：1)安全性 2)性能 3)可维护性 4)测试覆盖率\",\n agent=reviewer,\n expected_output=\"审查报告，包含发现的问题和修改建议\",\n)\n\n# 组建团队\ncrew = Crew(\n agents=[architect, developer, reviewer],\n tasks=[design_task, develop_task, review_task],\n process=Process.sequential, # 顺序执行\n verbose=True,\n)\n\n# 执行\nresult = crew.kickoff()\nprint(f\"最终结果:\\n{result}\")", "section_ref": "8.5.2", "runnable": true, "dependencies": [ "crewai" ] }, { "id": "code-13", "language": "python", "description": "LangGraph 用图（Graph）的方式建模 Agent 的工作流，特别适合需要条件分支和循环的复杂场景。", "code": "from langgraph.graph import StateGraph, END\nfrom langgraph.graph.message import add_messages\nfrom typing import TypedDict, Annotated, Literal\nfrom langchain_core.messages import HumanMessage, AIMessage\n\n\nclass AgentState(TypedDict):\n \"\"\"共享状态\"\"\"\n messages: Annotated[list, add_messages]\n current_agent: str\n task_description: str\n code: str\n review_result: str\n iteration: int\n max_iterations: int\n\n\ndef router_agent(state: AgentState) -> dict:\n \"\"\"路由Agent：决定下一步谁来处理\"\"\"\n iteration = state.get(\"iteration\", 0)\n max_iter = state.get(\"max_iterations\", 3)\n \n if iteration == 0:\n return {\"current_agent\": \"coder\", \"iteration\": iteration + 1}\n elif state.get(\"review_result\", \"\") == \"APPROVED\":\n return {\"current_agent\": END}\n elif iteration >= max_iter:\n return {\"current_agent\": END}\n else:\n return {\"current_agent\": \"coder\", \"iteration\": iteration + 1}\n\n\ndef coder_node(state: AgentState) -> dict:\n \"\"\"编码Agent节点\"\"\"\n # 调用LLM生成/修改代码\n code = f\"# 第{state['iteration']}次迭代\\n# {state['task_description']}\\ndef solve():\\n pass\"\n return {\"code\": code}\n\n\ndef reviewer_node(state: AgentState) -> dict:\n \"\"\"审查Agent节点\"\"\"\n # 调用LLM审查代码\n review = \"APPROVED\" if state[\"iteration\"] >= 2 else \"需要改进\"\n return {\"review_result\": review}\n\n\ndef should_review(state: AgentState) -> Literal[\"reviewer\", \"router\"]:\n \"\"\"条件边：判断是否需要审查\"\"\"\n if state.get(\"code\"):\n return \"reviewer\"\n return \"router\"\n\n\n# 构建图\nworkflow = StateGraph(AgentState)\n\n# 添加节点\nworkflow.add_node(\"router\", router_agent)\nworkflow.add_node(\"coder\", coder_node)\nworkflow.add_node(\"reviewer\", reviewer_node)\n\n# 设置入口\nworkflow.set_entry_point(\"router\")\n\n# 添加边\nworkflow.add_conditional_edges(\"router\", lambda s: s[\"current_agent\"], {\n \"coder\": \"coder\",\n END: END,\n})\nworkflow.add_conditional_edges(\"coder\", should_review, {\n \"reviewer\": \"reviewer\",\n \"router\": \"router\",\n})\nworkflow.add_edge(\"reviewer\", \"router\")\n\n# 编译\napp = workflow.compile()\n\n# 执行\nresult = app.invoke({\n \"messages\": [],\n \"task_description\": \"实现快速排序算法\",\n \"max_iterations\": 3,\n})\n\nprint(f\"最终代码:\\n{result['code']}\")\nprint(f\"审查结果: {result['review_result']}\")", "section_ref": "8.5.3", "runnable": true, "dependencies": [ "langgraph", "langchain_core" ] }, { "id": "code-14", "language": "python", "description": "| 权限冲突 | Agent执行了越权操作 | 开发Agent尝试部署到生产环境 |", "code": "from enum import Enum\n\n\nclass ConflictResolution(Enum):\n MAJORITY_VOTE = \"majority_vote\" # 多数投票\n WEIGHTED_VOTE = \"weighted_vote\" # 加权投票\n PRIORITY_BASED = \"priority_based\" # 优先级决定\n NEGOTIATION = \"negotiation\" # 协商解决\n ESCALATION = \"escalation\" # 上报人工\n MERGE = \"merge\" # 合并方案\n\n\nclass ConflictResolver:\n \"\"\"冲突解决器\"\"\"\n \n def __init__(self, strategy: ConflictResolution):\n self.strategy = strategy\n self.agent_weights: dict[str, float] = {}\n self.agent_priorities: dict[str, int] = {}\n \n def resolve(self, conflict: dict) -> Any:\n \"\"\"解决冲突\"\"\"\n match self.strategy:\n case ConflictResolution.MAJORITY_VOTE:\n return self._majority_vote(conflict)\n case ConflictResolution.WEIGHTED_VOTE:\n return self._weighted_vote(conflict)\n case ConflictResolution.PRIORITY_BASED:\n return self._priority_based(conflict)\n case ConflictResolution.NEGOTIATION:\n return self._negotiation(conflict)\n case ConflictResolution.ESCALATION:\n return self._escalation(conflict)\n case ConflictResolution.MERGE:\n return self._merge(conflict)\n \n def _majority_vote(self, conflict: dict) -> Any:\n \"\"\"多数投票\"\"\"\n from collections import Counter\n votes = conflict[\"proposals\"]\n counter = Counter(votes)\n return counter.most_common(1)[0][0]\n \n def _weighted_vote(self, conflict: dict) -> Any:\n \"\"\"加权投票\"\"\"\n proposals = conflict[\"proposals\"]\n weights = conflict.get(\"agent_weights\", {})\n \n scores: dict[Any, float] = {}\n for agent, proposal in proposals.items():\n weight = weights.get(agent, 1.0)\n scores[proposal] = scores.get(proposal, 0) + weight\n \n return max(scores, key=scores.get)\n \n def _priority_based(self, conflict: dict) -> Any:\n \"\"\"优先级决定\"\"\"\n proposals = conflict[\"proposals\"]\n priorities = conflict.get(\"agent_priorities\", {})\n \n # 选择优先级最高的Agent的方案\n sorted_agents = sorted(\n proposals.keys(),\n key=lambda a: priorities.get(a, 0),\n reverse=True\n )\n return proposals[sorted_agents[0]]\n \n def _negotiation(self, conflict: dict) -> Any:\n \"\"\"协商解决 - 通过LLM调解\"\"\"\n proposals = conflict[\"proposals\"]\n \n # 构建协商Prompt\n prompt = f\"\"\"\n 多个Agent提出了不同的方案，请作为调解者选出最佳方案：\n \n {self._format_proposals(proposals)}\n \n 请分析每个方案的优劣，然后给出最终建议。\n \"\"\"\n # 调用LLM进行调解\n # return llm.invoke(prompt)\n return \"negotiated_result\"\n \n def _escalation(self, conflict: dict) -> Any:\n \"\"\"上报人工\"\"\"\n return {\n \"status\": \"escalated\",\n \"conflict\": conflict,\n \"message\": \"需要人工介入解决冲突\",\n }\n \n def _merge(self, conflict: dict) -> Any:\n \"\"\"合并方案 - 取各方案之长\"\"\"\n proposals = conflict[\"proposals\"]\n \n prompt = f\"\"\"\n 请将以下不同Agent的方案合并为一个综合方案，\n 保留每个方案的优势：\n \n {self._format_proposals(proposals)}\n \"\"\"\n # return llm.invoke(prompt)\n return \"merged_result\"\n \n def _format_proposals(self, proposals: dict) -> str:\n return \"\\n\".join(\n f\"- {agent}: {proposal}\" \n for agent, proposal in proposals.items()\n )", "section_ref": "8.6.2", "runnable": true, "dependencies": [] }, { "id": "code-15", "language": "python", "description": "", "code": "class AgentConsensus:\n \"\"\"灵感来自Raft的Agent共识协议\"\"\"\n \n PHASES = [\"propose\", \"vote\", \"commit\"]\n \n def __init__(self, agents: list[str], quorum: int):\n self.agents = agents\n self.quorum = quorum # 法定人数\n self.current_proposal = None\n self.votes: dict[str, bool] = {}\n self.phase = \"idle\"\n \n async def propose(self, proposer: str, proposal: Any) -> dict:\n \"\"\"提出提案\"\"\"\n self.current_proposal = proposal\n self.phase = \"propose\"\n self.votes = {proposer: True} # 提案者自动同意\n \n # 广播提案给所有Agent\n votes_received = {proposer: True}\n \n for agent in self.agents:\n if agent == proposer:\n continue\n # 实际中这里会发送消息给Agent，Agent进行评估\n # vote = await self._request_vote(agent, proposal)\n vote = True # 模拟\n votes_received[agent] = vote\n \n self.phase = \"vote\"\n self.votes = votes_received\n \n # 检查是否达到法定人数\n if sum(votes_received.values()) >= self.quorum:\n self.phase = \"commit\"\n return {\n \"status\": \"consensus_reached\",\n \"proposal\": proposal,\n \"votes\": votes_received,\n }\n else:\n self.phase = \"idle\"\n return {\n \"status\": \"consensus_failed\",\n \"proposal\": proposal,\n \"votes\": votes_received,\n \"reason\": \"未达到法定人数\",\n }", "section_ref": "8.6.3", "runnable": true, "dependencies": [] }, { "id": "code-16", "language": "python", "description": "6. 控制成本：多Agent意味着多次LLM调用，要监控Token消耗", "code": "# ❌ 陷阱1：无限对话循环\n# 没有设置max_round限制，Agent可能无限对话\ngroupchat = autogen.GroupChat(\n agents=[agent_a, agent_b],\n messages=[],\n # max_round=10, # 必须设置！\n)\n\n# ✅ 正确：设置最大轮次\ngroupchat = autogen.GroupChat(\n agents=[agent_a, agent_b],\n messages=[],\n max_round=10, # 限制对话轮次\n)\n\n\n# ❌ 陷阱2：忘记设置超时\nresult = await agent.execute(task) # 可能永远挂起\n\n# ✅ 正确：使用asyncio.wait_for\ntry:\n result = await asyncio.wait_for(\n agent.execute(task), timeout=60\n )\nexcept asyncio.TimeoutError:\n logger.error(f\"Agent {agent.role} 执行超时\")\n\n\n# ❌ 陷阱3：共享可变状态\nshared_state = {\"data\": []} # 多个Agent同时修改\n\n# ✅ 正确：使用线程安全的数据结构\nfrom threading import Lock\nshared_state = {\"data\": [], \"lock\": Lock()}\n\n\n# ❌ 陷阱4：Agent职责不清\n# 所有Agent都能做所有事 → 角色混乱\ndeveloper = Agent(\n role=\"开发者\",\n goal=\"做任何事\", # 太模糊！\n)\n\n# ✅ 正确：明确职责边界\ndeveloper = Agent(\n role=\"后端开发工程师\",\n goal=\"根据API设计文档，使用Python/FastAPI实现后端接口\",\n allow_delegation=False, # 不允许将任务委托给其他Agent\n)", "section_ref": "8.7.2", "runnable": true, "dependencies": [ "threading" ] }, { "id": "code-17", "language": "text", "description": "", "code": "多Agent系统上线前检查清单：\n├── [ ] 每个Agent有明确的职责描述和边界\n├── [ ] 消息格式已标准化（使用Schema/Protocol）\n├── [ ] 所有Agent间调用设置了超时\n├── [ ] 实现了失败重试机制（指数退避）\n├── [ ] 有熔断机制防止级联故障\n├── [ ] 消息日志完整可追溯\n├── [ ] Token消耗有预算限制和告警\n├── [ ] 冲突解决策略已定义\n├── [ ] 有降级方案（单Agent回退）\n├── [ ] 性能基准测试已通过\n├── [ ] 安全权限已配置（最小权限原则）\n└── [ ] 监控指标已配置（延迟、成功率、成本）", "section_ref": "8.7.3", "runnable": false, "dependencies": [] } ], "tables": [ { "headers": [ "维度", "静态分配", "动态分配" ], "data": [ [ "分配时机", "任务开始前确定", "运行时根据状态调整" ], [ "灵活性", "低", "高" ], [ "开销", "小", "较大（需要状态监控）" ], [ "适用场景", "任务类型固定", "任务类型多变" ] ] }, { "headers": [ "概念", "说明" ], "data": [ [ "`UserProxyAgent`", "用户代理，可执行代码" ], [ "`AssistantAgent`", "LLM驱动的Agent" ], [ "`GroupChat`", "多Agent群聊" ], [ "`GroupChatManager`", "群聊管理器，决定谁发言" ], [ "`max_round`", "最大对话轮次限制" ] ] }, { "headers": [ "维度", "AutoGen", "CrewAI" ], "data": [ [ "**协作模式**", "自由对话", "角色扮演" ], [ "**流程控制**", "GroupChatManager 管理", "Task 链式编排" ], [ "**任务定义**", "对话驱动", "显式 Task 定义" ], [ "**工具集成**", "内置代码执行", "自定义 @tool" ], [ "**适用场景**", "开放式探索", "结构化流水线" ], [ "**学习曲线**", "低", "中" ] ] }, { "headers": [ "冲突类型", "描述", "示例" ], "data": [ [ "**结果冲突**", "多个Agent产生矛盾的结果", "AgentA说用方案A，AgentB说用方案B" ], [ "**资源冲突**", "多个Agent争抢同一资源", "两个Agent同时修改同一文件" ], [ "**顺序冲突**", "Agent执行顺序不当", "测试Agent在编码Agent完成前运行" ], [ "**权限冲突**", "Agent执行了越权操作", "开发Agent尝试部署到生产环境" ] ] } ], "key_takeaways": [ "三种架构模式：层级式适合需要全局协调的场景，对等式适合开放式探索，黑板式适合解耦协作", "通信协议：标准化的消息格式和通信模式是多Agent系统稳定运行的基石", "任务分配：基于能力匹配的智能分配器能显著提升系统效率", "主流框架：AutoGen 适合对话驱动、CrewAI 适合角色扮演、LangGraph 适合复杂流程", "冲突解决：多种策略各有适用场景，关键是提前定义好解决机制" ], "common_pitfalls": [], "related_chapters": [ "ch04", "ch06", "ch26", "ch30", "ch32", "ch33" ] }