🌟 系列导读：当单个Agent的能力达到瓶颈，我们开始思考：如果让多个Agent像人类团队一样协作，会产生怎样的化学反应？本文将深入探讨多智能体系统中的协作模式、对抗博弈以及那些令人惊叹的涌现行为。
📑 目录
- [1. 引言：从单体到群体的范式跃迁](#1. 引言：从单体到群体的范式跃迁)
- [2. 多智能体系统基础理论](#2. 多智能体系统基础理论)
- [2.1 什么是多智能体系统](#2.1 什么是多智能体系统)
- [2.2 分布式人工智能的演进](#2.2 分布式人工智能的演进)
- [2.3 LLM时代的多智能体新范式](#2.3 LLM时代的多智能体新范式)
- [3. CAMEL：角色扮演驱动的协作框架](#3. CAMEL：角色扮演驱动的协作框架)
- [3.1 CAMEL的核心思想](#3.1 CAMEL的核心思想)
- [3.2 Inception Prompting机制](#3.2 Inception Prompting机制)
- [3.3 代码实战：构建CAMEL对话](#3.3 代码实战：构建CAMEL对话)
- [4. ChatDev：虚拟软件公司](#4. ChatDev：虚拟软件公司)
- [4.1 ChatDev的设计哲学](#4.1 ChatDev的设计哲学)
- [4.2 Chat Chain与阶段化开发](#4.2 Chat Chain与阶段化开发)
- [4.3 代码实战：ChatDev项目实践](#4.3 代码实战：ChatDev项目实践)
- [5. AgentVerse：动态组队的智能体宇宙](#5. AgentVerse：动态组队的智能体宇宙)
- [5.1 AgentVerse架构解析](#5.1 AgentVerse架构解析)
- [5.2 专家招募与动态协作](#5.2 专家招募与动态协作)
- [5.3 代码实战：AgentVerse应用](#5.3 代码实战：AgentVerse应用)
- [6. 多智能体协作模式大全](#6. 多智能体协作模式大全)
- [6.1 中心化协调模式](#6.1 中心化协调模式)
- [6.2 去中心化自组织模式](#6.2 去中心化自组织模式)
- [6.3 层级化管理模式](#6.3 层级化管理模式)
- [6.4 流水线协作模式](#6.4 流水线协作模式)
- [6.5 广播与订阅模式](#6.5 广播与订阅模式)
- [7. 对抗与博弈：多智能体的竞争面](#7. 对抗与博弈：多智能体的竞争面)
- [7.1 辩论式推理](#7.1 辩论式推理)
- [7.2 红蓝对抗模式](#7.2 红蓝对抗模式)
- [7.3 博弈论视角下的Agent交互](#7.3 博弈论视角下的Agent交互)
- [8. 涌现行为：1+1>2的奥秘](#8. 涌现行为：1+1>2的奥秘)
- [8.1 什么是涌现行为](#8.1 什么是涌现行为)
- [8.2 多智能体系统中的涌现现象](#8.2 多智能体系统中的涌现现象)
- [8.3 涌现的条件与设计原则](#8.3 涌现的条件与设计原则)
- [9. 通信协议与消息传递](#9. 通信协议与消息传递)
- [9.1 Agent间通信机制](#9.1 Agent间通信机制)
- [9.2 共享记忆与黑板模式](#9.2 共享记忆与黑板模式)
- [9.3 代码实战：构建通信层](#9.3 代码实战：构建通信层)
- [10. 实战项目：构建多智能体研究团队](#10. 实战项目：构建多智能体研究团队)
- [10.1 项目设计与架构](#10.1 项目设计与架构)
- [10.2 完整代码实现](#10.2 完整代码实现)
- [10.3 运行效果与分析](#10.3 运行效果与分析)
- [11. 挑战与前沿探索](#11. 挑战与前沿探索)
- [11.1 当前面临的挑战](#11.1 当前面临的挑战)
- [11.2 前沿研究方向](#11.2 前沿研究方向)
- [12. 总结与展望](#12. 总结与展望)
- 参考文献
1. 引言：从单体到群体的范式跃迁
在过去的几年里，大型语言模型（LLM）的能力突飞猛进，单个基于LLM的Agent已经能够完成许多令人印象深刻的任务------从撰写代码到回答复杂问题，从数据分析到内容创作。然而，随着我们对AI系统期望的不断提高，一个核心问题浮现出来：
💡 思考：单个Agent的能力边界在哪里？当任务复杂到需要多种专业知识、多角度思考、甚至需要相互检验时，单个Agent还能胜任吗？
🤔 解答：答案是否定的。正如人类社会通过分工协作创造了远超个体能力的成就，AI Agent同样需要走向"社会化"。多智能体系统（Multi-Agent System, MAS）正是这一理念的实现------让多个具有不同能力、知识和角色的Agent协同工作，共同解决复杂问题。
┌─────────────────────────────────────────────────────────────────┐
│ AI Agent 演进路线图 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────────┐ ┌──────────────────┐ │
│ │ LLM │ -> │ Single Agent│ -> │ Multi-Agent │ │
│ │(静态问答)│ │ (ReAct/CoT) │ │ System (协作涌现) │ │
│ └─────────┘ └─────────────┘ └──────────────────┘ │
│ │ │ │ │
│ v v v │
│ "一问一答" "思考+行动" "分工+协作+涌现" │
│ │
│ 能力边界： 能力边界： 能力边界： │
│ • 无记忆 • 单一视角 • 多视角审视 │
│ • 无工具 • 认知负载有限 • 专业化分工 │
│ • 无规划 • 难以自我纠错 • 相互校验 │
│ • 涌现新能力 │
└─────────────────────────────────────────────────────────────────┘多智能体系统的魅力不仅在于"分工"带来的效率提升，更在于"涌现"------当多个Agent以特定方式组织和交互时，整个系统可能展现出单个Agent所不具备的能力。这就像蚁群中的单只蚂蚁智能有限，但整个蚁群却能完成令人惊叹的工程奇迹。
本文将深入探讨当前最具影响力的多智能体框架（CAMEL、ChatDev、AgentVerse），剖析各种协作模式与对抗机制，并揭示涌现行为的奥秘。让我们一起踏上这段从"单体"到"群体"的探索之旅。
2. 多智能体系统基础理论
2.1 什么是多智能体系统
多智能体系统（Multi-Agent System, MAS）是由多个相互作用的智能体组成的系统，这些智能体可以是协作的、竞争的，或者两者兼有。每个智能体都具有一定程度的自主性，能够感知环境、做出决策并采取行动。
💡 思考：多智能体系统与分布式系统有什么区别？
🤔 解答 ：虽然两者都涉及多个计算单元，但关键区别在于自主性 和智能性。分布式系统中的节点通常执行预定义的算法，而多智能体系统中的Agent具有自主决策能力，能够根据环境变化和目标自主调整行为。在LLM时代，这种自主性和智能性更是得到了前所未有的增强。
多智能体系统的核心特征包括：
┌─────────────────────────────────────────────────────────────┐
│ 多智能体系统核心特征 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 自主性 │ │ 社会性 │ │ 反应性 │ │
│ │ Autonomy │ │ Sociality │ │ Reactivity │ │
│ ├───────────────┤ ├───────────────┤ ├───────────────┤ │
│ │ Agent独立 │ │ Agent之间 │ │ Agent感知 │ │
│ │ 做出决策, │ │ 通过通信 │ │ 环境变化, │ │
│ │ 不受外部 │ │ 协议进行 │ │ 及时做出 │ │
│ │ 直接控制 │ │ 交互协作 │ │ 响应调整 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 主动性 │ │ 异构性 │ │ 适应性 │ │
│ │ Proactivity │ │ Heterogeneity │ │ Adaptability │ │
│ ├───────────────┤ ├───────────────┤ ├───────────────┤ │
│ │ Agent主动 │ │ 不同Agent │ │ Agent能够 │ │
│ │ 采取行动, │ │ 可以拥有 │ │ 从经验中 │ │
│ │ 追求目标, │ │ 不同能力 │ │ 学习并改 │ │
│ │ 而非被动等待 │ │ 和专业知识 │ │ 进自身行为 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘2.2 分布式人工智能的演进
多智能体系统的研究可以追溯到20世纪80年代的分布式人工智能（DAI）领域。让我们回顾这段演进历程：
┌─────────────────────────────────────────────────────────────────────┐
│ 多智能体系统演进时间线 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 1980s 1990s 2000s 2010s 2020s │
│ │ │ │ │ │ │
│ v v v v v │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │ DAI │ --> │ MAS │ --> │Agent │ --> │ DRL │ --> │ LLM │ │
│ │研究 │ │理论 │ │平台 │ │多智体│ │Agents│ │
│ │起步 │ │成熟 │ │兴起 │ │博弈 │ │协作 │ │
│ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │
│ │ │ │ │ │ │
│ 黑板系统 BDI架构 JADE/FIPA OpenAI Five CAMEL │
│ 契约网络 博弈论 Web Services AlphaStar ChatDev │
│ 通信协议 多智能体RL AgentVerse│
│ │
└─────────────────────────────────────────────────────────────────────┘早期阶段（1980s-1990s）：研究者开始探索如何让多个AI系统协同工作。这一时期的代表性成果包括：
- 黑板系统（Blackboard System）：多个知识源通过共享黑板进行协作
- 契约网络协议（Contract Net Protocol）：模拟市场机制的任务分配方法
- BDI架构：Belief-Desire-Intention模型为Agent提供了认知框架
发展阶段（2000s-2010s）：随着互联网和分布式计算的发展，多智能体系统进入工程化阶段：
- JADE、FIPA标准：为Agent通信提供了标准化协议
- Web Services集成：Agent开始与网络服务交互
- 深度强化学习多智能体：OpenAI Five、AlphaStar展示了多Agent协作/对抗的惊人能力
LLM时代（2023-至今）：大型语言模型的突破为多智能体系统带来了新的可能：
- Agent获得了强大的自然语言理解和生成能力
- 复杂的协作可以通过自然语言对话实现
- 角色扮演和专业化分工成为可能
- CAMEL、ChatDev、AgentVerse等框架相继涌现
2.3 LLM时代的多智能体新范式
LLM为多智能体系统带来了革命性的变化。传统MAS需要手工设计复杂的通信协议和协调机制，而基于LLM的多智能体系统可以通过自然语言进行交互，大大降低了系统设计的复杂度。
┌────────────────────────────────────────────────────────────────────┐
│ 传统MAS vs LLM-based MAS 对比 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 传统 MAS LLM-based MAS │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ • 预定义通信协议 │ │ • 自然语言通信 │ │
│ │ • 固定角色和行为 │ │ • 动态角色扮演 │ │
│ │ • 规则驱动的协调 │ │ • 语义理解的协调 │ │
│ │ • 有限的适应性 │ │ • 强大的泛化能力 │ │
│ │ • 需要大量工程 │ │ • Prompt工程为主 │ │
│ └─────────────────────┘ └─────────────────────┘ │
│ │
│ 典型应用： 典型应用： │
│ • 机器人协作 • 软件开发（ChatDev） │
│ • 交通控制 • 科学研究（AI Scientist） │
│ • 资源调度 • 创意写作 │
│ • 复杂问题求解 │
│ │
└────────────────────────────────────────────────────────────────────┘LLM-based MAS的核心优势：
- 自然语言接口：Agent之间通过自然语言交流，无需设计复杂的消息格式
- 角色扮演能力：LLM可以通过prompt扮演不同角色，实现专业化分工
- 上下文理解：LLM能够理解复杂的上下文，做出合理的决策
- 知识整合：LLM内置了大量世界知识，可以在多个领域发挥作用
- 灵活适应：无需重新训练，通过调整prompt即可适应新任务
💡 思考：LLM-based MAS是否完全取代了传统MAS？
🤔 解答：并非如此。传统MAS在实时性要求高、需要确定性保证的场景（如工业控制、自动驾驶）仍有优势。LLM-based MAS更适合需要创造性、复杂推理和自然语言交互的场景。两者是互补关系，未来可能会看到更多混合架构。
3. CAMEL：角色扮演驱动的协作框架
3.1 CAMEL的核心思想
CAMEL（Communicative Agents for "Mind" Exploration of Large Language Model Society）是由KAUST（阿卜杜拉国王科技大学）的研究团队在2023年提出的开创性框架。它的核心洞见是：通过让两个LLM扮演不同角色进行对话，可以自主完成复杂任务。
┌────────────────────────────────────────────────────────────────────┐
│ CAMEL 核心架构 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ Task Specifier │ │
│ │ (任务明确器) │ │
│ └────────┬────────┘ │
│ │ │
│ v │
│ ┌────────────────────────────────┐ │
│ │ Task Description │ │
│ │ (具体任务描述) │ │
│ └────────────────┬───────────────┘ │
│ │ │
│ ┌─────────────────┴─────────────────┐ │
│ │ │ │
│ v v │
│ ┌───────────────┐ ┌───────────────┐ │
│ │ AI Assistant │ <-- 对话 --> │ AI User │ │
│ │ (助手角色) │ │ (用户角色) │ │
│ ├───────────────┤ ├───────────────┤ │
│ │ • 接收指令 │ │ • 提出需求 │ │
│ │ • 执行任务 │ │ • 检查结果 │ │
│ │ • 提供解决方案 │ │ • 提供反馈 │ │
│ └───────────────┘ └───────────────┘ │
│ │ │ │
│ └─────────────────┬─────────────────┘ │
│ │ │
│ v │
│ ┌─────────────────┐ │
│ │ Task Solution │ │
│ │ (任务解决方案) │ │
│ └─────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘CAMEL框架的设计灵感来自于人类社会的角色分工。在真实世界中，当我们需要完成一项任务时，通常会有：
- 需求方：明确知道需要什么，负责提出要求和验收
- 执行方：具备完成任务的技能，负责实际执行
CAMEL将这种模式应用到AI Agent上，创建了"AI User"（模拟需求方）和"AI Assistant"（模拟执行方）两个角色，让它们通过对话协作完成任务。
3.2 Inception Prompting机制
CAMEL的一个关键创新是"Inception Prompting"（初始提示）机制。这个机制通过精心设计的系统提示，让Agent保持其角色身份，避免在对话中"出戏"。
┌────────────────────────────────────────────────────────────────────┐
│ Inception Prompting 机制 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ AI User System Prompt │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ 你是一个{user_role}。你正在与{assistant_role}协作完成任务。 │ │
│ │ │ │
│ │ 任务：{task_description} │ │
│ │ │ │
│ │ 你的职责： │ │
│ │ 1. 将任务分解为具体的、可执行的子任务 │ │
│ │ 2. 向AI Assistant提供清晰的指令 │ │
│ │ 3. 检查AI Assistant的输出是否满足要求 │ │
│ │ 4. 提供反馈和进一步指导 │ │
│ │ │ │
│ │ 规则： │ │
│ │ - 必须给出具体指令，不能泛泛而谈 │ │
│ │ - 每次只给一个指令 │ │
│ │ - 当任务完成时，回复 <CAMEL_TASK_DONE> │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ AI Assistant System Prompt │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ 你是一个{assistant_role}。你正在帮助{user_role}完成任务。 │ │
│ │ │ │
│ │ 任务：{task_description} │ │
│ │ │ │
│ │ 你的职责： │ │
│ │ 1. 理解AI User的指令 │ │
│ │ 2. 提供高质量的解决方案 │ │
│ │ 3. 如果指令不清晰，请求澄清 │ │
│ │ │ │
│ │ 规则： │ │
│ │ - 始终尽最大努力完成指令 │ │
│ │ - 提供具体、可执行的方案，而非泛泛的建议 │ │
│ │ - 保持专业和礼貌 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘Inception Prompting的关键设计原则：
- 角色锚定：明确告诉LLM它扮演的角色和合作对象
- 任务上下文：提供完整的任务背景信息
- 行为规范：定义Agent应该遵循的规则和约束
- 终止条件：明确任务完成的标志
💡 思考：为什么需要Inception Prompting？直接让两个LLM对话不行吗？
🤔 解答：没有Inception Prompting，LLM容易出现以下问题：
- 角色混淆：忘记自己的角色，开始扮演对方
- 任务偏移：对话逐渐偏离原始任务
- 空洞应答：给出泛泛而谈的回复，缺乏实质内容
- 无限循环 ：无法判断任务何时完成
Inception Prompting通过系统性的约束解决了这些问题。
3.3 代码实战：构建CAMEL对话
让我们通过代码来实现一个简化版的CAMEL框架：
python
"""
CAMEL-style Multi-Agent Collaboration Framework
简化版CAMEL框架实现
"""
import os
from dataclasses import dataclass
from typing import List, Optional
from openai import OpenAI
# 初始化OpenAI客户端
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
@dataclass
class Message:
"""消息类"""
role: str # "user" 或 "assistant"
content: str
@dataclass
class AgentConfig:
"""Agent配置"""
name: str
role_name: str
role_description: str
system_prompt: str
class CAMELAgent:
"""CAMEL Agent实现"""
def __init__(self, config: AgentConfig, model: str = "gpt-4"):
self.config = config
self.model = model
self.conversation_history: List[Message] = []
def get_system_prompt(self) -> str:
"""获取系统提示"""
return self.config.system_prompt
def chat(self, user_message: str) -> str:
"""与Agent对话"""
# 添加用户消息到历史
self.conversation_history.append(Message(role="user", content=user_message))
# 构建API请求的消息列表
messages = [
{"role": "system", "content": self.get_system_prompt()},
]
for msg in self.conversation_history:
messages.append({"role": msg.role, "content": msg.content})
# 调用API
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=2000
)
assistant_message = response.choices[0].message.content
# 添加助手回复到历史
self.conversation_history.append(Message(role="assistant", content=assistant_message))
return assistant_message
def reset(self):
"""重置对话历史"""
self.conversation_history = []
class CAMELRolePlayingSession:
"""CAMEL角色扮演会话"""
TASK_DONE_SIGNAL = "<CAMEL_TASK_DONE>"
def __init__(
self,
task: str,
user_role: str,
assistant_role: str,
model: str = "gpt-4"
):
self.task = task
self.user_role = user_role
self.assistant_role = assistant_role
self.model = model
# 创建AI User Agent
self.ai_user = self._create_ai_user()
# 创建AI Assistant Agent
self.ai_assistant = self._create_ai_assistant()
def _create_ai_user(self) -> CAMELAgent:
"""创建AI User Agent"""
system_prompt = f"""你是一个{self.user_role}。
你正在与一个{self.assistant_role}协作完成以下任务：
任务：{self.task}
你的职责：
1. 将任务分解为具体的、可执行的子任务
2. 向AI Assistant提供清晰、具体的指令
3. 检查AI Assistant的输出是否满足要求
4. 提供反馈和进一步指导
重要规则：
- 每次只给出一个具体的指令
- 指令必须明确、可执行，不能泛泛而谈
- 如果AI Assistant完成得很好，给予肯定并提出下一步
- 当所有子任务都完成，整个任务达成时，在消息末尾添加 {self.TASK_DONE_SIGNAL}
你的消息格式：
指令：<你的具体指令>
"""
config = AgentConfig(
name="AI_User",
role_name=self.user_role,
role_description=f"负责分解任务并指导{self.assistant_role}完成工作",
system_prompt=system_prompt
)
return CAMELAgent(config, self.model)
def _create_ai_assistant(self) -> CAMELAgent:
"""创建AI Assistant Agent"""
system_prompt = f"""你是一个{self.assistant_role}。
你正在帮助一个{self.user_role}完成以下任务：
任务：{self.task}
你的职责：
1. 仔细理解{self.user_role}的指令
2. 提供高质量、具体的解决方案
3. 如果指令不清晰，礼貌地请求澄清
4. 展示你的专业能力
重要规则：
- 始终尽最大努力完成指令
- 提供具体的、可执行的方案，而非泛泛的建议
- 如果涉及代码，提供完整、可运行的代码
- 保持专业和礼貌
你的消息格式：
解决方案：<你的具体方案>
"""
config = AgentConfig(
name="AI_Assistant",
role_name=self.assistant_role,
role_description=f"负责执行{self.user_role}的指令",
system_prompt=system_prompt
)
return CAMELAgent(config, self.model)
def run(self, max_turns: int = 10) -> List[dict]:
"""
运行角色扮演会话
Args:
max_turns: 最大对话轮数
Returns:
对话记录列表
"""
conversation_log = []
# AI User发起第一条指令
initial_prompt = f"任务已明确：{self.task}\n请开始给出第一个指令。"
user_message = self.ai_user.chat(initial_prompt)
print(f"\n{'='*60}")
print(f"🎭 CAMEL Role-Playing Session Started")
print(f"{'='*60}")
print(f"📋 Task: {self.task}")
print(f"👤 AI User Role: {self.user_role}")
print(f"🤖 AI Assistant Role: {self.assistant_role}")
print(f"{'='*60}\n")
for turn in range(max_turns):
print(f"\n--- Turn {turn + 1} ---\n")
# 记录AI User的消息
print(f"👤 [{self.user_role}]:\n{user_message}\n")
conversation_log.append({
"turn": turn + 1,
"role": "AI_User",
"role_name": self.user_role,
"content": user_message
})
# 检查任务是否完成
if self.TASK_DONE_SIGNAL in user_message:
print(f"\n✅ Task completed after {turn + 1} turns!")
break
# AI Assistant响应
assistant_message = self.ai_assistant.chat(user_message)
print(f"🤖 [{self.assistant_role}]:\n{assistant_message}\n")
conversation_log.append({
"turn": turn + 1,
"role": "AI_Assistant",
"role_name": self.assistant_role,
"content": assistant_message
})
# AI User给出下一个指令
user_message = self.ai_user.chat(assistant_message)
else:
print(f"\n⚠️ Max turns ({max_turns}) reached. Session ended.")
return conversation_log
def main():
"""主函数：演示CAMEL框架"""
# 定义任务
task = "开发一个Python命令行工具，可以统计指定目录下所有代码文件的行数"
# 创建会话
session = CAMELRolePlayingSession(
task=task,
user_role="软件项目经理",
assistant_role="Python开发工程师",
model="gpt-4"
)
# 运行会话
conversation_log = session.run(max_turns=8)
# 保存对话记录
print(f"\n{'='*60}")
print("📝 Conversation Summary")
print(f"{'='*60}")
print(f"Total turns: {len(conversation_log)}")
return conversation_log
if __name__ == "__main__":
main()代码解析：
- AgentConfig数据类：存储Agent的配置信息，包括名称、角色和系统提示
- CAMELAgent类：封装了与LLM交互的逻辑，维护对话历史
- CAMELRolePlayingSession类：核心类，管理两个Agent的协作过程
- TASK_DONE_SIGNAL：任务完成的标志，AI User在确认任务完成后发送此信号
运行这段代码，你会看到类似这样的输出：
============================================================
🎭 CAMEL Role-Playing Session Started
============================================================
📋 Task: 开发一个Python命令行工具，可以统计指定目录下所有代码文件的行数
👤 AI User Role: 软件项目经理
🤖 AI Assistant Role: Python开发工程师
============================================================
--- Turn 1 ---
👤 [软件项目经理]:
指令：首先，请设计这个命令行工具的整体架构，包括主要模块和功能划分。
请列出需要实现的核心功能点。
🤖 [Python开发工程师]:
解决方案：以下是命令行工具的整体架构设计：
1. 核心模块划分：
- cli.py: 命令行参数解析模块
- scanner.py: 文件扫描模块
- counter.py: 行数统计模块
- reporter.py: 结果报告模块
2. 核心功能点：
- 支持指定目录路径
- 支持过滤特定文件类型（.py, .js, .java等）
- 递归扫描子目录
- 统计代码行数、空行数、注释行数
- 输出格式化的统计报告
...💡 思考：CAMEL框架的对话为什么能够有效推进？不会陷入重复或空转吗？
🤔 解答：CAMEL的有效性来自几个关键设计：
- 角色分离：AI User负责"提问"，AI Assistant负责"回答"，角色清晰
- 指令约束：要求AI User每次只给一个具体指令，避免信息过载
- 进度追踪：AI User需要检查上一步的完成情况才给出下一步指令
- 终止机制：有明确的任务完成信号，避免无限循环
4. ChatDev：虚拟软件公司
4.1 ChatDev的设计哲学
ChatDev是清华大学NLP实验室在2023年推出的多智能体软件开发框架。它的设计理念是：模拟一家完整的软件公司，通过多个角色的协作来完成软件开发的全流程。
┌────────────────────────────────────────────────────────────────────┐
│ ChatDev 虚拟软件公司 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ CEO │ │
│ │ 首席执行官 │ │
│ └──────┬──────┘ │
│ │ │
│ ┌─────────────────────┼─────────────────────┐ │
│ │ │ │ │
│ v v v │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ CPO │ │ CTO │ │ CFO │ │
│ │ 首席产品官 │ │ 首席技术官 │ │ 首席财务官 │ │
│ └──────┬───────┘ └──────┬───────┘ └──────────────┘ │
│ │ │ │
│ v v │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Designer │ │ Programmer │ │
│ │ 设计师 │ │ 程序员 │ │
│ └──────────────┘ └──────┬───────┘ │
│ │ │
│ v │
│ ┌──────────────┐ │
│ │ Reviewer │ │
│ │ 代码审查员 │ │
│ └──────┬───────┘ │
│ │ │
│ v │
│ ┌──────────────┐ │
│ │ Tester │ │
│ │ 测试工程师 │ │
│ └──────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘ChatDev的核心哲学：
- 瀑布式流程：将软件开发分解为设计、编码、测试、文档等阶段
- 角色专业化：每个Agent扮演特定角色，拥有专业知识和职责
- 对话驱动：阶段内的工作通过角色间的对话推进
- Chat Chain：阶段之间通过预定义的流程串联
💡 思考：为什么ChatDev选择模拟软件公司，而不是其他组织形式？
🤔 解答：软件开发是一个非常适合多智能体协作的场景：
- 流程清晰：软件开发有成熟的方法论（瀑布、敏捷等）
- 角色明确：产品经理、设计师、程序员、测试等角色职责分明
- 输出可验证：代码可以运行、测试，结果可以客观评估
- LLM擅长：代码生成是LLM的强项之一
4.2 Chat Chain与阶段化开发
ChatDev引入了"Chat Chain"（聊天链）的概念，将软件开发过程组织为一系列顺序执行的阶段，每个阶段由特定的Agent对话完成。
┌────────────────────────────────────────────────────────────────────────┐
│ ChatDev Chat Chain │
├────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 1: Designing │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ CEO │ <─────────────────> │ CPO │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: 产品需求文档(PRD)、模态定义(GUI/CLI) │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 2: Coding │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ CTO │ <─────────────────> │ Programmer │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: 源代码文件 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 3: Art Designing │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ CPO │ <─────────────────> │ Designer │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: UI设计、图像资源描述 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 4: Code Review │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ Programmer │ <─────────────────> │ Reviewer │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: 审查后的优化代码 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 5: Testing │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ Programmer │ <─────────────────> │ Tester │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: 测试报告、修复后的代码 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Phase 6: Documenting │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ 对话 ┌─────────────┐ │ │
│ │ │ CPO │ <─────────────────> │ Programmer │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 输出: README.md、用户手册 │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌─────────────┐ │
│ │ 完整软件 │ │
│ │ Package │ │
│ └─────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────────┘Chat Chain的设计特点：
- 阶段隔离：每个阶段有明确的输入和输出
- 角色配对：每个阶段由两个特定角色对话完成
- 状态传递：前一阶段的输出成为后一阶段的输入
- 可配置性：可以根据项目需求调整阶段和角色
4.3 代码实战：ChatDev项目实践
让我们实现一个简化版的ChatDev框架：
python
"""
ChatDev-style Software Development Framework
简化版ChatDev框架实现
"""
import os
import json
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Callable
from enum import Enum
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
class Role(Enum):
"""公司角色枚举"""
CEO = "CEO"
CPO = "CPO (Chief Product Officer)"
CTO = "CTO (Chief Technology Officer)"
PROGRAMMER = "Programmer"
REVIEWER = "Code Reviewer"
TESTER = "Software Tester"
DESIGNER = "UI/UX Designer"
@dataclass
class PhaseConfig:
"""阶段配置"""
name: str
description: str
assistant_role: Role
user_role: Role
output_key: str # 输出存储的键名
@dataclass
class ChatDevProject:
"""ChatDev项目状态"""
task: str
artifacts: Dict[str, str] = field(default_factory=dict)
conversation_logs: List[Dict] = field(default_factory=list)
class ChatDevAgent:
"""ChatDev Agent实现"""
ROLE_PROMPTS = {
Role.CEO: """你是一家软件公司的CEO。你的职责是：
- 理解客户需求
- 把控产品方向
- 做出战略决策
你需要与其他高管协作，确保产品成功交付。""",
Role.CPO: """你是一家软件公司的CPO（首席产品官）。你的职责是：
- 将需求转化为产品规格
- 设计产品功能和用户体验
- 确保产品满足用户需求
你擅长产品思维，能够平衡用户需求和技术可行性。""",
Role.CTO: """你是一家软件公司的CTO（首席技术官）。你的职责是：
- 技术架构设计
- 技术选型决策
- 指导开发团队
你有丰富的技术经验，能够做出合理的技术决策。""",
Role.PROGRAMMER: """你是一名资深程序员。你的职责是：
- 编写高质量的代码
- 实现产品功能
- 修复bug
你精通多种编程语言，代码风格清晰，注重可维护性。
编写代码时，请提供完整、可运行的代码，使用markdown代码块格式。""",
Role.REVIEWER: """你是一名代码审查员。你的职责是：
- 审查代码质量
- 发现潜在问题
- 提出改进建议
你有敏锐的代码嗅觉，能发现细微的问题和改进空间。""",
Role.TESTER: """你是一名软件测试工程师。你的职责是：
- 设计测试用例
- 执行测试
- 报告bug
你有丰富的测试经验，善于发现边界情况和潜在问题。""",
Role.DESIGNER: """你是一名UI/UX设计师。你的职责是：
- 设计用户界面
- 优化用户体验
- 创建视觉规范
你有优秀的审美和用户同理心，设计既美观又实用。"""
}
def __init__(self, role: Role, model: str = "gpt-4"):
self.role = role
self.model = model
self.conversation_history: List[Dict] = []
def get_system_prompt(self, task: str, phase_context: str = "") -> str:
"""获取系统提示"""
base_prompt = self.ROLE_PROMPTS[self.role]
return f"""{base_prompt}
当前项目任务：{task}
{phase_context}
请始终保持专业，提供具体、有价值的输出。"""
def chat(self, message: str, task: str, phase_context: str = "") -> str:
"""与Agent对话"""
self.conversation_history.append({"role": "user", "content": message})
messages = [
{"role": "system", "content": self.get_system_prompt(task, phase_context)},
*self.conversation_history
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=3000
)
assistant_message = response.choices[0].message.content
self.conversation_history.append({"role": "assistant", "content": assistant_message})
return assistant_message
def reset(self):
"""重置对话历史"""
self.conversation_history = []
class ChatDevPhase:
"""ChatDev开发阶段"""
def __init__(self, config: PhaseConfig, model: str = "gpt-4"):
self.config = config
self.assistant_agent = ChatDevAgent(config.assistant_role, model)
self.user_agent = ChatDevAgent(config.user_role, model)
def run(self, project: ChatDevProject, max_turns: int = 5) -> str:
"""
运行阶段
Args:
project: 项目状态
max_turns: 最大对话轮数
Returns:
阶段输出
"""
print(f"\n{'='*60}")
print(f"📌 Phase: {self.config.name}")
print(f"📝 {self.config.description}")
print(f"👤 {self.config.user_role.value} <-> 🤖 {self.config.assistant_role.value}")
print(f"{'='*60}\n")
# 构建阶段上下文
phase_context = self._build_phase_context(project)
# User Agent发起对话
initial_prompt = self._get_initial_prompt(project)
user_message = self.user_agent.chat(
f"你需要指导{self.config.assistant_role.value}完成{self.config.name}阶段的工作。\n\n{initial_prompt}",
project.task,
phase_context
)
conversation_log = []
final_output = ""
for turn in range(max_turns):
print(f"--- Turn {turn + 1} ---")
print(f"👤 [{self.config.user_role.value}]:\n{user_message[:500]}...\n")
conversation_log.append({
"turn": turn + 1,
"role": self.config.user_role.value,
"content": user_message
})
# Assistant Agent响应
assistant_response = self.assistant_agent.chat(
user_message,
project.task,
phase_context
)
print(f"🤖 [{self.config.assistant_role.value}]:\n{assistant_response[:500]}...\n")
conversation_log.append({
"turn": turn + 1,
"role": self.config.assistant_role.value,
"content": assistant_response
})
final_output = assistant_response
# 检查是否达成一致
if self._check_consensus(user_message, assistant_response):
print(f"✅ Consensus reached at turn {turn + 1}")
break
# User Agent继续对话
user_message = self.user_agent.chat(
assistant_response,
project.task,
phase_context
)
# 保存对话日志
project.conversation_logs.append({
"phase": self.config.name,
"log": conversation_log
})
# 保存阶段输出
project.artifacts[self.config.output_key] = final_output
return final_output
def _build_phase_context(self, project: ChatDevProject) -> str:
"""构建阶段上下文"""
context_parts = []
for key, value in project.artifacts.items():
context_parts.append(f"[{key}]\n{value[:1000]}...") # 截断以避免太长
if context_parts:
return "已有的项目产出：\n" + "\n\n".join(context_parts)
return ""
def _get_initial_prompt(self, project: ChatDevProject) -> str:
"""获取初始提示"""
prompts = {
"Designing": f"我们需要为以下任务设计产品：\n{project.task}\n请开始讨论产品需求和设计。",
"Coding": f"基于产品设计，我们需要开始编码实现。请开始编写代码。",
"CodeReview": "代码已完成初版，请进行代码审查并提出改进建议。",
"Testing": "代码已通过审查，请设计测试用例并执行测试。",
"Documenting": "软件已完成开发和测试，请编写项目文档。"
}
return prompts.get(self.config.name, "请开始本阶段的工作。")
def _check_consensus(self, user_msg: str, assistant_msg: str) -> bool:
"""检查是否达成一致"""
# 简化的共识检查逻辑
positive_indicators = ["同意", "认可", "很好", "没问题", "可以", "完成", "LGTM", "approved"]
return any(indicator in user_msg.lower() or indicator in assistant_msg.lower()
for indicator in positive_indicators)
class ChatDevPipeline:
"""ChatDev开发流水线"""
DEFAULT_PHASES = [
PhaseConfig(
name="Designing",
description="产品设计阶段：定义需求和产品规格",
assistant_role=Role.CPO,
user_role=Role.CEO,
output_key="product_design"
),
PhaseConfig(
name="Coding",
description="编码阶段：实现产品功能",
assistant_role=Role.PROGRAMMER,
user_role=Role.CTO,
output_key="source_code"
),
PhaseConfig(
name="CodeReview",
description="代码审查阶段：审查和优化代码",
assistant_role=Role.REVIEWER,
user_role=Role.PROGRAMMER,
output_key="reviewed_code"
),
PhaseConfig(
name="Testing",
description="测试阶段：测试软件功能",
assistant_role=Role.TESTER,
user_role=Role.PROGRAMMER,
output_key="test_report"
),
PhaseConfig(
name="Documenting",
description="文档阶段：编写项目文档",
assistant_role=Role.PROGRAMMER,
user_role=Role.CPO,
output_key="documentation"
)
]
def __init__(self, phases: Optional[List[PhaseConfig]] = None, model: str = "gpt-4"):
self.phases = phases or self.DEFAULT_PHASES
self.model = model
def run(self, task: str) -> ChatDevProject:
"""
运行完整的开发流水线
Args:
task: 项目任务描述
Returns:
完成的项目
"""
project = ChatDevProject(task=task)
print(f"\n{'#'*60}")
print(f"🏢 ChatDev Software Development Pipeline")
print(f"{'#'*60}")
print(f"📋 Project Task: {task}")
print(f"📊 Total Phases: {len(self.phases)}")
print(f"{'#'*60}\n")
for i, phase_config in enumerate(self.phases, 1):
print(f"\n[{i}/{len(self.phases)}] Starting {phase_config.name}...")
phase = ChatDevPhase(phase_config, self.model)
phase.run(project)
print(f"\n{'#'*60}")
print(f"🎉 Project Completed!")
print(f"{'#'*60}")
print(f"Artifacts generated: {list(project.artifacts.keys())}")
return project
def main():
"""主函数：演示ChatDev框架"""
# 定义项目任务
task = """
开发一个命令行番茄钟应用（Pomodoro Timer）：
- 支持设置工作时长和休息时长
- 倒计时显示
- 计时结束时发出提示音
- 统计今日完成的番茄数
"""
# 创建并运行流水线
pipeline = ChatDevPipeline(model="gpt-4")
project = pipeline.run(task)
# 输出生成的代码
print("\n" + "="*60)
print("📄 Generated Source Code:")
print("="*60)
if "source_code" in project.artifacts:
print(project.artifacts["source_code"][:2000])
return project
if __name__ == "__main__":
main()代码解析：
- Role枚举：定义公司中的各种角色
- PhaseConfig：配置每个开发阶段的参数
- ChatDevAgent：每个角色对应的Agent，包含角色特定的系统提示
- ChatDevPhase：实现单个开发阶段的协作逻辑
- ChatDevPipeline：串联所有阶段，运行完整的开发流程
💡 思考：ChatDev的分阶段设计有什么优势？
🤔 解答：
- 降低复杂度：将复杂任务分解为可管理的小阶段
- 专业化分工：每个阶段由最适合的角色完成
- 质量保证：代码审查和测试阶段提供质量检查
- 可追溯性：每个阶段的产出都被记录，便于回溯
- 灵活配置：可以根据项目需求添加或跳过某些阶段
5. AgentVerse：动态组队的智能体宇宙
5.1 AgentVerse架构解析
AgentVerse是由清华大学和微软研究院联合推出的多智能体协作框架。与CAMEL的双Agent固定配对和ChatDev的固定流程不同，AgentVerse的核心特点是动态组队------根据任务需求动态招募合适的Agent专家。
┌────────────────────────────────────────────────────────────────────┐
│ AgentVerse 架构概览 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Expert Recruitment │ │
│ │ (专家招募层) │ │
│ │ │ │
│ │ Task ──> ┌──────────────┐ ──> Selected Experts │ │
│ │ │ Recruiter │ │ │
│ │ │ Agent │ │ │
│ │ └──────────────┘ │ │
│ │ │ │ │
│ │ v │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │Expert 1│ │Expert 2│ │Expert 3│ │Expert N│ ... │ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Collaborative Decision Making │ │
│ │ (协作决策层) │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │Discussion│ -> │ Debate │ -> │ Voting/ │ │ │
│ │ │ (讨论) │ │ (辩论) │ │ Consensus│ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Action Execution │ │
│ │ (行动执行层) │ │
│ │ │ │
│ │ Decision ──> ┌──────────────┐ ──> Result │ │
│ │ │ Executor │ │ │
│ │ │ Agent │ │ │
│ │ └──────────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Evaluation & Feedback │ │
│ │ (评估反馈层) │ │
│ │ │ │
│ │ Result ──> ┌──────────────┐ ──> Updated State │ │
│ │ │ Evaluator │ │ │
│ │ │ Agent │ │ │
│ │ └──────────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘AgentVerse的四层架构：
-
专家招募层（Expert Recruitment）
- 分析任务需求
- 从专家池中选择合适的Agent
- 动态组建团队
-
协作决策层（Collaborative Decision Making）
- 组织多Agent讨论
- 支持辩论和投票
- 形成共识或最终决策
-
行动执行层（Action Execution）
- 将决策转化为具体行动
- 执行工具调用或代码运行
-
评估反馈层（Evaluation & Feedback）
- 评估执行结果
- 提供反馈以改进后续迭代
5.2 专家招募与动态协作
AgentVerse的"专家招募"机制是其最大的创新点。系统维护一个专家池，每个专家有特定的技能和知识领域。当新任务到来时，招募器会根据任务描述选择最合适的专家组合。
┌────────────────────────────────────────────────────────────────────┐
│ Expert Pool (专家池) │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 🧮 数学家 │ │ 💻 程序员 │ │ 📊 数据分析师│ │ 🎨 设计师 │ │
│ │ │ │ │ │ │ │ │ │
│ │Skills: │ │Skills: │ │Skills: │ │Skills: │ │
│ │• 数学推理 │ │• Python │ │• 统计分析 │ │• UI设计 │ │
│ │• 逻辑证明 │ │• 算法 │ │• 可视化 │ │• 用户体验 │ │
│ │• 优化问题 │ │• 系统设计 │ │• 机器学习 │ │• 图形处理 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 📝 作家 │ │ 🔬 科学家 │ │ 💼 商业顾问 │ │ 🔧 工程师 │ │
│ │ │ │ │ │ │ │ │ │
│ │Skills: │ │Skills: │ │Skills: │ │Skills: │ │
│ │• 创意写作 │ │• 实验设计 │ │• 市场分析 │ │• 硬件设计 │ │
│ │• 文案撰写 │ │• 论文阅读 │ │• 战略规划 │ │• 嵌入式 │ │
│ │• 故事构建 │ │• 科学方法 │ │• 财务分析 │ │• 系统集成 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
├────────────────────────────────────────────────────────────────────┤
│ Recruitment Process (招募流程) │
├────────────────────────────────────────────────────────────────────┤
│ │
│ Task: "分析用户行为数据并设计个性化推荐算法" │
│ │
│ ┌─────────────┐ │
│ │ Recruiter │ │
│ │ Agent │ │
│ └──────┬──────┘ │
│ │ │
│ 分析任务所需技能: │
│ • 数据分析 ✓ │
│ • 算法设计 ✓ │
│ • 用户体验 ✓ │
│ │ │
│ v │
│ ┌──────────────────────┼──────────────────────┐ │
│ │ │ │ │
│ v v v │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │📊数据分析师│ │ 💻 程序员 │ │ 🎨 设计师 │ │
│ │ Selected │ │ Selected │ │ Selected │ │
│ └───────────┘ └───────────┘ └───────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘招募策略可以基于：
- 技能匹配：根据任务关键词匹配专家技能
- 历史表现：优先选择在类似任务中表现优秀的专家
- 多样性：确保团队具有不同的视角和专业知识
- 协作兼容性：考虑专家之间的协作历史
5.3 代码实战：AgentVerse应用
让我们实现一个简化版的AgentVerse框架：
python
"""
AgentVerse-style Dynamic Multi-Agent Collaboration Framework
简化版AgentVerse框架实现
"""
import os
import json
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Set
from enum import Enum
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
@dataclass
class Expert:
"""专家定义"""
id: str
name: str
title: str
skills: List[str]
description: str
system_prompt: str
@dataclass
class ExpertOpinion:
"""专家意见"""
expert_id: str
expert_name: str
opinion: str
confidence: float # 0-1
supporting_points: List[str]
@dataclass
class ConsensusResult:
"""共识结果"""
final_decision: str
supporting_experts: List[str]
dissenting_experts: List[str]
confidence_score: float
reasoning: str
class ExpertPool:
"""专家池"""
BUILTIN_EXPERTS = [
Expert(
id="mathematician",
name="Dr. Math",
title="数学家",
skills=["数学推理", "逻辑证明", "优化问题", "统计学"],
description="擅长数学分析、逻辑推理和优化问题",
system_prompt="""你是一位资深数学家。你擅长：
- 严谨的数学推理和证明
- 优化问题的建模和求解
- 统计分析和概率计算
你的风格是严谨、精确，注重逻辑性。"""
),
Expert(
id="programmer",
name="Alex Code",
title="软件工程师",
skills=["Python", "算法", "系统设计", "代码优化", "调试"],
description="擅长软件开发和算法实现",
system_prompt="""你是一位资深软件工程师。你擅长：
- 多种编程语言，尤其是Python
- 算法设计和优化
- 系统架构设计
- 代码调试和性能优化
你的代码风格清晰，注重可维护性。"""
),
Expert(
id="data_scientist",
name="Dr. Data",
title="数据科学家",
skills=["数据分析", "机器学习", "可视化", "特征工程", "模型评估"],
description="擅长数据分析和机器学习",
system_prompt="""你是一位资深数据科学家。你擅长：
- 数据探索和清洗
- 机器学习模型选择和训练
- 数据可视化
- 实验设计和A/B测试
你注重数据驱动的决策。"""
),
Expert(
id="product_manager",
name="PM Pro",
title="产品经理",
skills=["需求分析", "用户研究", "产品规划", "优先级排序"],
description="擅长产品规划和需求管理",
system_prompt="""你是一位资深产品经理。你擅长：
- 用户需求调研和分析
- 产品功能规划
- 优先级排序和路线图制定
- 跨团队协调
你以用户为中心，平衡业务目标和用户需求。"""
),
Expert(
id="security_expert",
name="SecureShield",
title="安全专家",
skills=["安全审计", "漏洞分析", "加密", "合规"],
description="擅长信息安全和风险评估",
system_prompt="""你是一位资深安全专家。你擅长：
- 安全漏洞识别和修复
- 加密算法和安全协议
- 安全架构设计
- 合规性评估
你对安全风险保持高度警觉。"""
),
Expert(
id="ux_designer",
name="UX Master",
title="用户体验设计师",
skills=["UI设计", "用户研究", "原型设计", "可用性测试"],
description="擅长用户体验和界面设计",
system_prompt="""你是一位资深用户体验设计师。你擅长：
- 用户研究和需求洞察
- 交互设计和原型制作
- 可用性测试
- 设计系统建立
你追求简洁、直观的用户体验。"""
),
Expert(
id="business_analyst",
name="Biz Insight",
title="商业分析师",
skills=["市场分析", "商业模式", "ROI分析", "竞争分析"],
description="擅长商业分析和战略规划",
system_prompt="""你是一位资深商业分析师。你擅长：
- 市场调研和竞争分析
- 商业模式设计
- 财务分析和ROI计算
- 战略规划
你从商业价值角度思考问题。"""
),
Expert(
id="critic",
name="Critical Eye",
title="批判性思考者",
skills=["逻辑分析", "问题发现", "风险识别", "反面论证"],
description="擅长批判性思考和风险识别",
system_prompt="""你是一位批判性思考者。你擅长：
- 发现方案中的漏洞和问题
- 提出反面论证
- 识别潜在风险
- 逻辑谬误检测
你的角色是建设性的批评者，帮助团队完善方案。"""
)
]
def __init__(self):
self.experts = {e.id: e for e in self.BUILTIN_EXPERTS}
def get_expert(self, expert_id: str) -> Optional[Expert]:
"""获取专家"""
return self.experts.get(expert_id)
def search_by_skill(self, skill: str) -> List[Expert]:
"""根据技能搜索专家"""
result = []
skill_lower = skill.lower()
for expert in self.experts.values():
if any(skill_lower in s.lower() for s in expert.skills):
result.append(expert)
return result
def list_all(self) -> List[Expert]:
"""列出所有专家"""
return list(self.experts.values())
class ExpertAgent:
"""专家Agent"""
def __init__(self, expert: Expert, model: str = "gpt-4"):
self.expert = expert
self.model = model
def generate_opinion(self, task: str, context: str = "") -> ExpertOpinion:
"""生成专家意见"""
messages = [
{"role": "system", "content": self.expert.system_prompt},
{"role": "user", "content": f"""作为{self.expert.title}，请对以下任务/问题发表你的专业意见：
任务：{task}
{f"背景信息：{context}" if context else ""}
请提供：
1. 你的专业分析和观点
2. 支持你观点的关键论据（3-5点）
3. 你对自己观点的置信度（0-100%）
请以JSON格式回复：
{{
"opinion": "你的详细观点",
"supporting_points": ["论据1", "论据2", ...],
"confidence": 85
}}
"""}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=1500
)
try:
content = response.choices[0].message.content
# 尝试解析JSON
if "```json" in content:
content = content.split("```json")[1].split("```")[0]
elif "```" in content:
content = content.split("```")[1].split("```")[0]
data = json.loads(content)
return ExpertOpinion(
expert_id=self.expert.id,
expert_name=self.expert.name,
opinion=data.get("opinion", content),
confidence=data.get("confidence", 70) / 100,
supporting_points=data.get("supporting_points", [])
)
except (json.JSONDecodeError, IndexError):
# 如果JSON解析失败，返回原始内容
return ExpertOpinion(
expert_id=self.expert.id,
expert_name=self.expert.name,
opinion=response.choices[0].message.content,
confidence=0.7,
supporting_points=[]
)
def respond_to_debate(self, task: str, other_opinions: List[ExpertOpinion]) -> str:
"""对其他专家的观点进行回应"""
opinions_text = "\n\n".join([
f"[{op.expert_name}的观点]\n{op.opinion}"
for op in other_opinions if op.expert_id != self.expert.id
])
messages = [
{"role": "system", "content": self.expert.system_prompt},
{"role": "user", "content": f"""任务：{task}
其他专家的观点：
{opinions_text}
作为{self.expert.title}，请对其他专家的观点进行回应：
1. 你同意哪些观点？为什么？
2. 你不同意哪些观点？为什么？
3. 综合考虑后，你的最终建议是什么？
请提供建设性的讨论。"""}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=1500
)
return response.choices[0].message.content
class Recruiter:
"""专家招募器"""
def __init__(self, expert_pool: ExpertPool, model: str = "gpt-4"):
self.expert_pool = expert_pool
self.model = model
def recruit(self, task: str, max_experts: int = 4) -> List[Expert]:
"""根据任务招募专家"""
all_experts = self.expert_pool.list_all()
experts_info = "\n".join([
f"- {e.id}: {e.title} - 技能: {', '.join(e.skills)}"
for e in all_experts
])
messages = [
{"role": "system", "content": "你是一个专家招募助手，负责为任务选择最合适的专家团队。"},
{"role": "user", "content": f"""任务：{task}
可用专家：
{experts_info}
请选择最适合这个任务的{max_experts}位专家。
考虑因素：
1. 专家技能与任务的匹配度
2. 团队的多样性和互补性
3. 任务的各个方面是否都有专家覆盖
请以JSON格式回复选中的专家ID列表：
{{"selected_experts": ["expert_id_1", "expert_id_2", ...]}}
"""}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.3,
max_tokens=500
)
try:
content = response.choices[0].message.content
if "```json" in content:
content = content.split("```json")[1].split("```")[0]
elif "```" in content:
content = content.split("```")[1].split("```")[0]
data = json.loads(content)
selected_ids = data.get("selected_experts", [])
selected_experts = []
for eid in selected_ids[:max_experts]:
expert = self.expert_pool.get_expert(eid)
if expert:
selected_experts.append(expert)
return selected_experts
except (json.JSONDecodeError, KeyError):
# 如果解析失败，返回前N个专家
return all_experts[:max_experts]
class ConsensusMaker:
"""共识形成器"""
def __init__(self, model: str = "gpt-4"):
self.model = model
def synthesize(self, task: str, opinions: List[ExpertOpinion]) -> ConsensusResult:
"""综合各专家意见形成共识"""
opinions_text = "\n\n".join([
f"[{op.expert_name}] (置信度: {op.confidence*100:.0f}%)\n"
f"观点: {op.opinion}\n"
f"论据: {'; '.join(op.supporting_points)}"
for op in opinions
])
messages = [
{"role": "system", "content": "你是一个决策综合专家，负责整合多位专家的意见并形成最终决策。"},
{"role": "user", "content": f"""任务：{task}
各专家意见：
{opinions_text}
请综合以上所有专家意见，形成最终决策：
1. 识别共识点（多数专家同意的观点）
2. 识别分歧点（专家意见不一致的地方）
3. 权衡各方观点，形成最终建议
4. 解释决策理由
请以JSON格式回复：
{{
"final_decision": "最终决策/建议的详细描述",
"supporting_experts": ["支持此决策的专家名单"],
"dissenting_experts": ["持不同意见的专家名单"],
"confidence_score": 85,
"reasoning": "决策理由"
}}
"""}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.5,
max_tokens=2000
)
try:
content = response.choices[0].message.content
if "```json" in content:
content = content.split("```json")[1].split("```")[0]
elif "```" in content:
content = content.split("```")[1].split("```")[0]
data = json.loads(content)
return ConsensusResult(
final_decision=data.get("final_decision", ""),
supporting_experts=data.get("supporting_experts", []),
dissenting_experts=data.get("dissenting_experts", []),
confidence_score=data.get("confidence_score", 70) / 100,
reasoning=data.get("reasoning", "")
)
except (json.JSONDecodeError, KeyError):
return ConsensusResult(
final_decision=response.choices[0].message.content,
supporting_experts=[op.expert_name for op in opinions],
dissenting_experts=[],
confidence_score=0.7,
reasoning="自动综合"
)
class AgentVerse:
"""AgentVerse主类"""
def __init__(self, model: str = "gpt-4"):
self.model = model
self.expert_pool = ExpertPool()
self.recruiter = Recruiter(self.expert_pool, model)
self.consensus_maker = ConsensusMaker(model)
def solve(
self,
task: str,
max_experts: int = 4,
enable_debate: bool = True
) -> Dict:
"""
解决任务
Args:
task: 任务描述
max_experts: 最大专家数量
enable_debate: 是否启用辩论环节
Returns:
解决方案字典
"""
result = {
"task": task,
"recruited_experts": [],
"opinions": [],
"debate_log": [],
"consensus": None
}
print(f"\n{'='*60}")
print("🌐 AgentVerse Multi-Agent Collaboration")
print(f"{'='*60}")
print(f"📋 Task: {task}")
print(f"{'='*60}\n")
# 1. 专家招募
print("🔍 Phase 1: Expert Recruitment")
print("-" * 40)
experts = self.recruiter.recruit(task, max_experts)
result["recruited_experts"] = [e.name for e in experts]
print(f"Selected experts: {[e.name + ' (' + e.title + ')' for e in experts]}\n")
# 2. 收集专家意见
print("💭 Phase 2: Gathering Expert Opinions")
print("-" * 40)
opinions = []
for expert in experts:
print(f"Consulting {expert.name}...")
agent = ExpertAgent(expert, self.model)
opinion = agent.generate_opinion(task)
opinions.append(opinion)
print(f" ✓ Opinion received (confidence: {opinion.confidence*100:.0f}%)\n")
result["opinions"] = [
{
"expert": op.expert_name,
"opinion": op.opinion,
"confidence": op.confidence,
"supporting_points": op.supporting_points
}
for op in opinions
]
# 3. 辩论环节（可选）
if enable_debate and len(experts) > 1:
print("🗣️ Phase 3: Expert Debate")
print("-" * 40)
debate_log = []
for expert in experts:
print(f"{expert.name} responding to others...")
agent = ExpertAgent(expert, self.model)
response = agent.respond_to_debate(task, opinions)
debate_log.append({
"expert": expert.name,
"response": response
})
print(f" ✓ Response recorded\n")
result["debate_log"] = debate_log
# 4. 形成共识
print("🤝 Phase 4: Forming Consensus")
print("-" * 40)
consensus = self.consensus_maker.synthesize(task, opinions)
result["consensus"] = {
"final_decision": consensus.final_decision,
"supporting_experts": consensus.supporting_experts,
"dissenting_experts": consensus.dissenting_experts,
"confidence_score": consensus.confidence_score,
"reasoning": consensus.reasoning
}
print(f"\n{'='*60}")
print("✅ Collaboration Complete!")
print(f"{'='*60}")
print(f"Confidence Score: {consensus.confidence_score*100:.0f}%")
print(f"Supporting Experts: {consensus.supporting_experts}")
print(f"\n📝 Final Decision:\n{consensus.final_decision[:500]}...")
return result
def main():
"""主函数：演示AgentVerse框架"""
# 定义任务
task = """
我们正在设计一个面向老年用户的健康管理App。请帮我分析：
1. 核心功能应该包括哪些？
2. UI/UX设计应该注意什么？
3. 数据隐私和安全如何保障？
4. 如何验证产品的有效性？
"""
# 创建AgentVerse实例
verse = AgentVerse(model="gpt-4")
# 解决任务
result = verse.solve(task, max_experts=4, enable_debate=True)
# 保存结果
with open("agentverse_result.json", "w", encoding="utf-8") as f:
json.dump(result, f, ensure_ascii=False, indent=2)
print("\n📄 Full results saved to agentverse_result.json")
return result
if __name__ == "__main__":
main()代码解析：
- Expert数据类：定义专家的属性，包括技能列表和系统提示
- ExpertPool：管理专家池，支持按技能搜索
- ExpertAgent：将专家实例化为可对话的Agent
- Recruiter：根据任务智能招募专家
- ConsensusMaker：综合各专家意见形成最终决策
- AgentVerse：主类，协调整个协作流程
💡 思考：AgentVerse的动态招募相比固定角色有什么优势？
🤔 解答：
- 灵活性：可以根据任务类型选择最合适的专家组合
- 可扩展性：只需向专家池添加新专家即可扩展能力
- 效率：避免不相关专家参与，减少无效对话
- 多样性：可以根据需要引入不同视角
- 专业性：每个专家专注于自己的领域，提供更专业的意见
6. 多智能体协作模式大全
在实际应用中，多智能体系统可以采用多种协作模式。选择合适的模式对于系统效能至关重要。
6.1 中心化协调模式
在中心化模式中，存在一个"协调者"Agent负责统筹全局，分配任务给其他Agent。
┌────────────────────────────────────────────────────────────────────┐
│ 中心化协调模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ Coordinator │ │
│ │ (协调者) │ │
│ └──────┬──────┘ │
│ │ │
│ ┌──────────────────┼──────────────────┐ │
│ │ │ │ │
│ v v v │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Worker A │ │ Worker B │ │ Worker C │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 优点： │
│ • 全局视野，易于优化资源分配 │
│ • 决策一致性好 │
│ • 便于监控和调试 │
│ │
│ 缺点： │
│ • 单点故障风险 │
│ • 协调者可能成为瓶颈 │
│ • 扩展性受限 │
│ │
│ 适用场景：任务分解明确、需要全局优化的场景 │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class CentralizedCoordinator:
"""中心化协调器示例"""
def __init__(self, workers: List[Agent]):
self.workers = workers
self.coordinator = self._create_coordinator()
def _create_coordinator(self) -> Agent:
"""创建协调者Agent"""
return Agent(
system_prompt="""你是一个任务协调者。你的职责是：
1. 分析任务并分解为子任务
2. 将子任务分配给最合适的工作者
3. 收集工作者的输出并整合
4. 确保任务顺利完成
可用的工作者：
{workers_info}
"""
)
def execute(self, task: str) -> str:
"""执行任务"""
# 1. 协调者分解任务
decomposition = self.coordinator.chat(
f"请分解以下任务：{task}"
)
# 2. 分配给工作者
results = []
for subtask in self._parse_subtasks(decomposition):
worker = self._select_worker(subtask)
result = worker.chat(subtask)
results.append(result)
# 3. 整合结果
final_result = self.coordinator.chat(
f"请整合以下子任务的结果：{results}"
)
return final_result6.2 去中心化自组织模式
在去中心化模式中，没有中央协调者，Agent之间通过直接通信和协商来协作。
┌────────────────────────────────────────────────────────────────────┐
│ 去中心化自组织模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Agent A │<--->│ Agent B │ │
│ └────┬─────┘ └─────┬────┘ │
│ │ │ │
│ │ ┌──────────┐│ │
│ └--->│ Agent C │<┘ │
│ └────┬─────┘ │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ ┌────v─────┐ ┌────v─────┐ │
│ │ Agent D │<----->│ Agent E │ │
│ └──────────┘ └──────────┘ │
│ │
│ 优点： │
│ • 无单点故障 │
│ • 高度可扩展 │
│ • 灵活适应变化 │
│ │
│ 缺点： │
│ • 难以保证全局最优 │
│ • 协调开销可能较大 │
│ • 可能出现冲突或死锁 │
│ │
│ 适用场景：动态环境、需要高鲁棒性的场景 │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class DecentralizedAgent:
"""去中心化Agent示例"""
def __init__(self, agent_id: str, capabilities: List[str]):
self.agent_id = agent_id
self.capabilities = capabilities
self.neighbors: List['DecentralizedAgent'] = []
self.message_queue: List[Dict] = []
def connect(self, other: 'DecentralizedAgent'):
"""与其他Agent建立连接"""
if other not in self.neighbors:
self.neighbors.append(other)
other.neighbors.append(self)
def broadcast(self, message: Dict):
"""向所有邻居广播消息"""
for neighbor in self.neighbors:
neighbor.receive(message, sender=self)
def receive(self, message: Dict, sender: 'DecentralizedAgent'):
"""接收消息"""
self.message_queue.append({
"from": sender.agent_id,
"content": message
})
def negotiate(self, task: str) -> Optional[str]:
"""与邻居协商任务"""
# 检查自己是否有能力处理
if self._can_handle(task):
# 向邻居询问是否有人更合适
self.broadcast({"type": "task_offer", "task": task})
# 等待响应并决策
return self._process_task(task)
else:
# 转发给邻居
self.broadcast({"type": "task_forward", "task": task})
return None6.3 层级化管理模式
层级化模式模拟组织架构，Agent按层级组织，上级管理下级。
┌────────────────────────────────────────────────────────────────────┐
│ 层级化管理模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ │
│ │ CEO │ Level 0 │
│ │ (决策层) │ (Strategic) │
│ └────┬─────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ │ │ │ │
│ v v v │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Manager A│ │ Manager B│ │ Manager C│ Level 1 │
│ │ (研发经理)│ │ (产品经理)│ │ (运营经理)│ (Tactical) │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │
│ ┌──────┴──────┐ ┌───┴───┐ ┌───┴───┐ │
│ │ │ │ │ │ │ │
│ v v v v v v │
│ ┌───────┐ ┌───────┐ │
│ │Worker │ │Worker │ ... ... Level 2 │
│ │ 1 │ │ 2 │ (Operational) │
│ └───────┘ └───────┘ │
│ │
│ 特点： │
│ • 符合组织管理直觉 │
│ • 职责清晰，便于问责 │
│ • 支持复杂决策的分层处理 │
│ │
│ 适用场景：模拟企业运作、复杂项目管理 │
│ │
└────────────────────────────────────────────────────────────────────┘6.4 流水线协作模式
流水线模式将任务分解为顺序执行的阶段，每个阶段由专门的Agent负责。
┌────────────────────────────────────────────────────────────────────┐
│ 流水线协作模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ Input Output │
│ │ ▲ │
│ v │ │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ │
│ │Stage │ -> │Stage │ -> │Stage │ -> │Stage │ -> │Stage │─┘ │
│ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │Parser│ │Planner│ │Coder │ │Tester│ │Docgen│ │
│ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │
│ │
│ 每个阶段的Agent专注于单一任务： │
│ • Stage 1: 解析和理解输入 │
│ • Stage 2: 制定执行计划 │
│ • Stage 3: 执行核心任务 │
│ • Stage 4: 验证和测试 │
│ • Stage 5: 生成输出/文档 │
│ │
│ 优点：专业化分工、易于并行（不同任务） │
│ 缺点：难以处理需要反复迭代的任务 │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class PipelineStage:
"""流水线阶段"""
def __init__(self, name: str, agent: Agent):
self.name = name
self.agent = agent
self.next_stage: Optional['PipelineStage'] = None
def process(self, input_data: Dict) -> Dict:
"""处理输入并传递给下一阶段"""
# 当前阶段处理
output = self.agent.process(input_data)
# 如果有下一阶段，继续传递
if self.next_stage:
return self.next_stage.process(output)
return output
class Pipeline:
"""流水线管理器"""
def __init__(self):
self.stages: List[PipelineStage] = []
def add_stage(self, stage: PipelineStage):
"""添加阶段"""
if self.stages:
self.stages[-1].next_stage = stage
self.stages.append(stage)
def run(self, input_data: Dict) -> Dict:
"""运行流水线"""
if not self.stages:
return input_data
return self.stages[0].process(input_data)6.5 广播与订阅模式
广播/订阅模式允许Agent基于兴趣订阅特定类型的消息，实现松耦合的协作。
┌────────────────────────────────────────────────────────────────────┐
│ 广播与订阅模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ Message Broker │ │
│ │ (消息代理) │ │
│ └────────┬────────┘ │
│ │ │
│ ┌─────────────────────┼─────────────────────┐ │
│ │ │ │ │
│ Topic: code Topic: test Topic: deploy │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │ │ │ │ │ │ │
│ v v v v v v │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Sub A│ │Sub B│ │Sub C│ │Sub D│ │Sub E│ │Sub F│ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │Coder│ │Review│ │Tester│ │QA │ │DevOps│ │Monitor│ │
│ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ │
│ │
│ Publisher Subscribers │
│ (发布者) (订阅者) │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ • Agent订阅感兴趣的Topic │ │
│ │ • Publisher发布消息到Topic │ │
│ │ • 订阅了该Topic的Agent收到消息 │ │
│ │ • 实现了发布者和订阅者的解耦 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
python
from collections import defaultdict
from typing import Callable
class MessageBroker:
"""消息代理"""
def __init__(self):
self.subscriptions: Dict[str, List[Callable]] = defaultdict(list)
def subscribe(self, topic: str, callback: Callable):
"""订阅主题"""
self.subscriptions[topic].append(callback)
def unsubscribe(self, topic: str, callback: Callable):
"""取消订阅"""
if callback in self.subscriptions[topic]:
self.subscriptions[topic].remove(callback)
def publish(self, topic: str, message: Dict):
"""发布消息"""
for callback in self.subscriptions[topic]:
callback(message)
class SubscriberAgent:
"""订阅者Agent"""
def __init__(self, name: str, broker: MessageBroker):
self.name = name
self.broker = broker
self.received_messages: List[Dict] = []
def subscribe_to(self, topic: str):
"""订阅主题"""
self.broker.subscribe(topic, self._on_message)
def _on_message(self, message: Dict):
"""收到消息的回调"""
print(f"{self.name} received: {message}")
self.received_messages.append(message)
self._process_message(message)
def _process_message(self, message: Dict):
"""处理消息（子类重写）"""
pass💡 思考：如何选择合适的协作模式？
🤔 解答：选择协作模式需要考虑以下因素：
- 任务结构：顺序执行→流水线，需要协调→中心化，动态任务→去中心化
- Agent数量：少量Agent可以中心化，大量Agent考虑去中心化或层级化
- 实时性要求：高实时性→去中心化，可以延迟→中心化
- 可靠性要求：高可靠性→去中心化或层级化
- 领域特点：模拟组织→层级化，事件驱动→发布/订阅
7. 对抗与博弈：多智能体的竞争面
多智能体系统不仅可以协作，还可以通过对抗和博弈来提升系统性能。这种"对抗性协作"是一种强大的机制。
7.1 辩论式推理
辩论式推理让多个Agent就同一问题提出不同观点并进行辩论，通过这种方式可以发现更全面的解决方案或识别潜在问题。
┌────────────────────────────────────────────────────────────────────┐
│ 辩论式推理流程 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 问题: "我们应该采用微服务还是单体架构？" │
│ │
│ Round 1: 初始立场 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌───────────────────┐ ┌───────────────────┐ │ │
│ │ │ Pro-Microservices│ │ Pro-Monolithic │ │ │
│ │ │ Agent │ │ Agent │ │ │
│ │ ├───────────────────┤ ├───────────────────┤ │ │
│ │ │ • 可扩展性强 │ │ • 开发简单 │ │ │
│ │ │ • 技术栈灵活 │ │ • 部署方便 │ │ │
│ │ │ • 故障隔离 │ │ • 性能优越 │ │ │
│ │ └───────────────────┘ └───────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ Round 2: 反驳与质疑 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ "微服务的复杂性 "单体架构在规模 │ │
│ │ 会增加运维成本" <---> 扩大后难以维护" │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ v │
│ Round 3: 综合与共识 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ Moderator │ │ │
│ │ ├─────────────────────────────────────────────────────┤ │ │
│ │ │ 结论: 对于当前团队规模和业务需求，建议： │ │ │
│ │ │ 1. 初期采用模块化单体架构 │ │ │
│ │ │ 2. 为关键服务预留拆分接口 │ │ │
│ │ │ 3. 当达到特定规模时再进行微服务化 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class DebateSystem:
"""辩论系统"""
def __init__(self, topic: str, model: str = "gpt-4"):
self.topic = topic
self.model = model
self.pro_agent = self._create_agent("支持方")
self.con_agent = self._create_agent("反对方")
self.moderator = self._create_moderator()
def _create_agent(self, stance: str) -> Agent:
"""创建辩手Agent"""
return Agent(
system_prompt=f"""你是一名专业辩手，在本次辩论中你代表{stance}。
你的任务是：
1. 提出支持你立场的论据
2. 反驳对方的论点
3. 用证据和逻辑支持你的观点
辩论规则：
- 保持理性和礼貌
- 承认对方的合理观点
- 聚焦于论据而非人身攻击
"""
)
def _create_moderator(self) -> Agent:
"""创建主持人Agent"""
return Agent(
system_prompt="""你是一名辩论主持人。你的任务是：
1. 保持中立
2. 总结双方观点
3. 识别共识点和分歧点
4. 给出综合性的结论和建议
"""
)
def run_debate(self, rounds: int = 3) -> Dict:
"""运行辩论"""
debate_log = []
# 初始立场
pro_opening = self.pro_agent.chat(f"请阐述你对'{self.topic}'的支持立场")
con_opening = self.con_agent.chat(f"请阐述你对'{self.topic}'的反对立场")
debate_log.append({
"round": 0,
"type": "opening",
"pro": pro_opening,
"con": con_opening
})
# 多轮辩论
for round_num in range(1, rounds + 1):
# 反驳阶段
pro_rebuttal = self.pro_agent.chat(
f"对方观点：{con_opening}\n请进行反驳并加强你的论点"
)
con_rebuttal = self.con_agent.chat(
f"对方观点：{pro_opening}\n请进行反驳并加强你的论点"
)
debate_log.append({
"round": round_num,
"type": "rebuttal",
"pro": pro_rebuttal,
"con": con_rebuttal
})
pro_opening = pro_rebuttal
con_opening = con_rebuttal
# 主持人总结
summary_prompt = f"""
辩题：{self.topic}
辩论记录：
{json.dumps(debate_log, ensure_ascii=False, indent=2)}
请总结这场辩论，给出你的分析和建议。
"""
conclusion = self.moderator.chat(summary_prompt)
return {
"topic": self.topic,
"debate_log": debate_log,
"conclusion": conclusion
}7.2 红蓝对抗模式
红蓝对抗借鉴自网络安全领域，红队（攻击方）负责发现问题，蓝队（防守方）负责解决问题。
┌────────────────────────────────────────────────────────────────────┐
│ 红蓝对抗模式 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Target System │ │
│ │ (目标系统) │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Code │ │ Design │ │ Logic │ │ │
│ │ │ (代码) │ │ (设计) │ │ (逻辑) │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │ │
│ │ │ │
│ ┌───────────┴───────┐ ┌───────┴───────────┐ │
│ │ │ │ │ │
│ v │ │ v │
│ ┌───────────┐ │ │ ┌───────────┐ │
│ │ 🔴 Red │ Attack │ │ Defense │ 🔵 Blue │ │
│ │ Team │─────────────┼───┼─────────────│ Team │ │
│ │ (红队) │ Report │ │ Fix │ (蓝队) │ │
│ ├───────────┤<────────────┘ └────────────>├───────────┤ │
│ │ │ │ │ │
│ │• 发现漏洞 │ │• 修复漏洞 │ │
│ │• 测试边界 │ │• 加固系统 │ │
│ │• 提出攻击 │ │• 完善设计 │ │
│ │ 向量 │ │ │ │
│ └───────────┘ └───────────┘ │
│ │
│ 迭代流程： │
│ 1. 蓝队提出方案/代码 │
│ 2. 红队审查并攻击 │
│ 3. 蓝队根据红队反馈改进 │
│ 4. 重复直到红队无法找到问题 │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class RedBlueSystem:
"""红蓝对抗系统"""
def __init__(self, model: str = "gpt-4"):
self.model = model
self.red_team = self._create_red_team()
self.blue_team = self._create_blue_team()
def _create_red_team(self) -> Agent:
"""创建红队Agent"""
return Agent(
system_prompt="""你是红队安全专家。你的任务是：
1. 审查代码/设计，发现潜在漏洞
2. 设计攻击向量来验证漏洞
3. 评估漏洞的严重程度
4. 提供详细的漏洞报告
你应该像一个恶意攻击者一样思考，但目的是帮助改进系统。
尽可能发现所有潜在的安全问题、逻辑错误、边界情况。
"""
)
def _create_blue_team(self) -> Agent:
"""创建蓝队Agent"""
return Agent(
system_prompt="""你是蓝队防守专家。你的任务是：
1. 分析红队发现的漏洞
2. 设计并实施修复方案
3. 加固系统防御
4. 验证修复的有效性
你应该系统性地解决所有发现的问题，并考虑防御纵深。
"""
)
def run_assessment(self, target: str, max_rounds: int = 3) -> Dict:
"""运行安全评估"""
results = {
"target": target,
"rounds": []
}
current_version = target
for round_num in range(1, max_rounds + 1):
print(f"\n🔄 Round {round_num}")
print("-" * 40)
# 红队攻击
print("🔴 Red Team assessing...")
attack_report = self.red_team.chat(f"""
请对以下目标进行安全评估：
{current_version}
请列出发现的所有问题，按严重程度排序。
对于每个问题，说明：
1. 问题描述
2. 攻击向量
3. 潜在影响
4. 严重等级（Critical/High/Medium/Low）
""")
# 检查是否还有问题
if "没有发现" in attack_report or "未发现" in attack_report:
print("✅ No vulnerabilities found!")
results["rounds"].append({
"round": round_num,
"red_team": attack_report,
"blue_team": "N/A - No issues to fix",
"status": "PASS"
})
break
# 蓝队防守
print("🔵 Blue Team fixing...")
defense_response = self.blue_team.chat(f"""
红队发现了以下问题：
{attack_report}
原始目标：
{current_version}
请：
1. 分析每个问题
2. 提供修复方案
3. 输出修复后的完整版本
""")
results["rounds"].append({
"round": round_num,
"red_team": attack_report,
"blue_team": defense_response,
"status": "FIXED"
})
# 更新当前版本
current_version = defense_response
return results7.3 博弈论视角下的Agent交互
从博弈论视角来看，多智能体交互可以建模为各种博弈形式：
┌────────────────────────────────────────────────────────────────────┐
│ 多智能体博弈类型 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 合作博弈 (Cooperative Game) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Agent们共同最大化整体收益 │ │
│ │ │ │
│ │ 例：多Agent共同完成软件开发 │ │
│ │ 所有Agent的目标是交付高质量软件 │ │
│ │ │ │
│ │ 策略：信息共享、资源协调、互助 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 2. 零和博弈 (Zero-Sum Game) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 一方的收益等于另一方的损失 │ │
│ │ │ │
│ │ 例：辩论系统中的对抗 │ │
│ │ 红蓝对抗中的攻防 │ │
│ │ │ │
│ │ 策略：最大化自己收益，最小化对手收益 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 3. 非零和博弈 (Non-Zero-Sum Game) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 各方收益不一定此消彼长，可能双赢或双输 │ │
│ │ │ │
│ │ 例：资源分配谈判 │ │
│ │ Agent之间的任务协商 │ │
│ │ │ │
│ │ 策略：寻找帕累托最优解，协商与妥协 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 经典博弈矩阵示例 │ │
│ │ │ │
│ │ 囚徒困境 (Prisoner's Dilemma) │ │
│ │ │ │
│ │ Agent B │ │
│ │ 合作 背叛 │ │
│ │ 合作 │ (-1,-1) │ (-3, 0) │ │ │
│ │ Agent A ─────┼──────────┼─────────┤ │ │
│ │ 背叛 │ ( 0,-3) │ (-2,-2) │ │ │
│ │ │ │
│ │ 纳什均衡：双方都背叛 (-2, -2) │ │
│ │ 帕累托最优：双方都合作 (-1, -1) │ │
│ │ │ │
│ │ 启示：短期理性可能导致集体次优结果 │ │
│ │ 需要机制设计来促进合作 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘💡 思考：对抗性机制如何提升多智能体系统的性能？
🤔 解答：对抗性机制的价值体现在：
- 质量提升：通过相互检验，发现单个Agent可能忽略的问题
- 视角多元：不同立场的Agent提供不同视角的分析
- 鲁棒性增强：经过对抗测试的方案更加健壮
- 创新激发：对抗压力可能激发更创新的解决方案
- 偏见消除：多方观点有助于消除单一Agent的偏见
8. 涌现行为：1+1>2的奥秘
8.1 什么是涌现行为
涌现（Emergence）是复杂系统理论中的核心概念，指的是系统作为整体所表现出的性质和行为，这些性质和行为在系统的各个组成部分中并不存在，而是由组成部分之间的相互作用产生的。
┌────────────────────────────────────────────────────────────────────┐
│ 涌现行为示意图 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 个体层面（微观） 系统层面（宏观） │
│ │
│ ┌─────────────────┐ ┌─────────────────────────┐ │
│ │ │ │ │ │
│ │ ○ ○ ○ ○ ○ │ 涌现 │ ████████████████ │ │
│ │ ○ ○ ○ ○ ○ │ ========> │ ████ 复杂模式 ████ │ │
│ │ ○ ○ ○ ○ ○ │ │ ████████████████ │ │
│ │ ○ ○ ○ ○ ○ │ │ │ │
│ │ │ │ • 群体智能 │ │
│ │ 简单个体 │ │ • 自组织结构 │ │
│ │ 简单规则 │ │ • 新能力/新行为 │ │
│ │ │ │ │ │
│ └─────────────────┘ └─────────────────────────┘ │
│ │
│ 自然界的涌现例子： │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 🐜 蚁群 │ │ 🐦 鸟群 │ │ 🧠 大脑 │ │
│ │ │ │ │ │ │ │
│ │ 个体：简单蚂蚁│ │ 个体：单只鸟 │ │ 个体：神经元 │ │
│ │ 涌现：复杂 │ │ 涌现：优美 │ │ 涌现：意识 │ │
│ │ 工程 │ │ 编队 │ │ 思维 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ 涌现的特点： │
│ • 整体 > 部分之和 │
│ • 新属性无法从个体推导 │
│ • 依赖于个体间的交互 │
│ • 通常是非线性的 │
│ │
└────────────────────────────────────────────────────────────────────┘8.2 多智能体系统中的涌现现象
在基于LLM的多智能体系统中，研究者观察到了多种涌现现象：
┌────────────────────────────────────────────────────────────────────┐
│ 多智能体系统中的涌现现象 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 🎯 集体问题解决能力的涌现 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 单个Agent无法解决的复杂问题，多Agent协作后可以解决 │ │
│ │ │ │
│ │ 例：ChatDev中的软件开发 │ │
│ │ • 单个LLM难以完成完整的软件开发 │ │
│ │ • 多角色协作后可以产出可运行的软件 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 2. 🔄 自发的角色分化 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 即使没有预设角色，Agent在交互中可能自发分化出不同角色 │ │
│ │ │ │
│ │ 例：开放讨论中 │ │
│ │ • 有的Agent自然成为领导者 │ │
│ │ • 有的Agent成为质疑者 │ │
│ │ • 有的Agent成为调和者 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 3. 📈 推理能力的增强 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 通过辩论或讨论，多Agent可以达到比单个Agent更高的推理准确率 │ │
│ │ │ │
│ │ 研究发现： │ │
│ │ • 数学推理任务中，多Agent辩论比单Agent Chain-of-Thought │ │
│ │ 准确率提高10-20% │ │
│ │ • 多Agent可以发现并纠正彼此的逻辑错误 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 4. 🛡️ 错误检测与纠正能力 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 多个Agent相互检查，可以发现单个Agent的错误 │ │
│ │ │ │
│ │ 例：代码审查 │ │
│ │ • Programmer Agent写的代码 │ │
│ │ • Reviewer Agent发现bug │ │
│ │ • Tester Agent发现边界情况 │ │
│ │ • 三者协作产出的代码质量显著提升 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 5. 🎨 创造力的激发 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Agent之间的交互可能激发出更有创意的解决方案 │ │
│ │ │ │
│ │ 例：头脑风暴会议 │ │
│ │ • 一个Agent的想法可能启发另一个Agent │ │
│ │ • 不同专业背景的组合产生跨界创新 │ │
│ │ • 建设性批评促进想法迭代升级 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘8.3 涌现的条件与设计原则
要在多智能体系统中促进涌现行为，需要满足一定条件并遵循设计原则：
┌────────────────────────────────────────────────────────────────────┐
│ 涌现的条件与设计原则 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 必要条件： │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 足够数量的Agent（临界质量） │ │
│ │ • 太少的Agent难以产生复杂交互 │ │
│ │ • 通常需要3个以上Agent │ │
│ │ │ │
│ │ 2. Agent之间存在交互机制 │ │
│ │ • 需要通信渠道 │ │
│ │ • 交互需要有意义的信息交换 │ │
│ │ │ │
│ │ 3. Agent具有一定的异质性 │ │
│ │ • 不同的知识、视角或角色 │ │
│ │ • 完全相同的Agent难以产生涌现 │ │
│ │ │ │
│ │ 4. 存在反馈机制 │ │
│ │ • Agent能够感知其他Agent的行为 │ │
│ │ • 可以根据反馈调整自己的行为 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 设计原则： │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 原则1: 保持适度的自主性 │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ • 过度控制会抑制涌现 │ │ │
│ │ │ • 完全放任可能导致混乱 │ │ │
│ │ │ • 在约束和自由之间找到平衡 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 原则2: 设计有意义的交互协议 │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ • 交互应该有明确目的 │ │ │
│ │ │ • 鼓励深度讨论而非浅层交流 │ │ │
│ │ │ • 支持质疑和反驳 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 原则3: 引入适度的张力 │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ • 不同意见的碰撞促进创新 │ │ │
│ │ │ • 设置适当的约束和挑战 │ │ │
│ │ │ • 避免过度和谐（groupthink） │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 原则4: 允许迭代和演化 │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ • 涌现需要时间 │ │ │
│ │ │ • 支持多轮交互 │ │ │
│ │ │ • 允许方案逐步演化 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
python
class EmergenceExperiment:
"""涌现行为实验框架"""
def __init__(self, num_agents: int = 5, model: str = "gpt-4"):
self.num_agents = num_agents
self.model = model
self.agents = self._create_diverse_agents()
self.interaction_history = []
def _create_diverse_agents(self) -> List[Agent]:
"""创建多样化的Agent群体"""
personas = [
("Optimist", "你总是看到事物积极的一面，相信问题都有解决方案"),
("Skeptic", "你习惯质疑，总是寻找潜在的问题和风险"),
("Pragmatist", "你注重实际，关心方案的可行性和执行"),
("Innovator", "你喜欢创新，总是寻找不同寻常的解决方案"),
("Analyst", "你注重数据和逻辑，喜欢深入分析问题"),
]
agents = []
for i, (name, description) in enumerate(personas[:self.num_agents]):
agent = Agent(
name=name,
system_prompt=f"""你是一个{name}类型的思考者。{description}
在讨论中：
1. 保持你的角色特点
2. 积极参与讨论
3. 可以同意或反对其他观点，但要给出理由
4. 尝试从你的角度提供独特见解
"""
)
agents.append(agent)
return agents
def run_discussion(self, topic: str, rounds: int = 5) -> Dict:
"""运行多Agent讨论实验"""
discussion_log = []
current_context = f"讨论话题：{topic}\n\n"
for round_num in range(1, rounds + 1):
print(f"\n=== Round {round_num} ===\n")
round_responses = []
for agent in self.agents:
# 每个Agent根据当前上下文发表意见
response = agent.chat(
f"{current_context}\n请发表你的看法（简洁有力，100字以内）："
)
print(f"[{agent.name}]: {response}\n")
round_responses.append({
"agent": agent.name,
"response": response
})
# 更新上下文
current_context += f"\n[{agent.name}]: {response}"
discussion_log.append({
"round": round_num,
"responses": round_responses
})
# 分析涌现现象
emergence_analysis = self._analyze_emergence(discussion_log)
return {
"topic": topic,
"discussion_log": discussion_log,
"emergence_analysis": emergence_analysis
}
def _analyze_emergence(self, log: List[Dict]) -> Dict:
"""分析讨论中的涌现现象"""
# 这里可以使用另一个Agent来分析讨论
analyzer = Agent(
system_prompt="""你是一个复杂系统分析专家。
请分析多Agent讨论中的涌现现象，包括：
1. 是否出现了角色分化
2. 是否产生了个体Agent可能不会产生的新想法
3. 讨论是否达成了某种共识或综合观点
4. 交互过程中是否有创新的火花
"""
)
analysis = analyzer.chat(
f"请分析以下多Agent讨论：\n{json.dumps(log, ensure_ascii=False, indent=2)}"
)
return {"analysis": analysis}💡 思考：涌现是可预测的还是随机的？
🤔 解答：涌现既不是完全可预测的，也不是纯粹随机的：
- 可预测的部分：通过精心设计交互机制和Agent特性，可以增加某些涌现现象出现的概率
- 不可预测的部分：具体会涌现出什么样的行为或解决方案，往往是事先无法精确预测的
- 设计的艺术：好的多智能体系统设计是在"控制"和"放手"之间找到平衡，创造涌现的"土壤"，但不能"制造"涌现
9. 通信协议与消息传递
9.1 Agent间通信机制
多智能体系统的协作离不开高效的通信机制。在LLM-based MAS中，通信主要通过自然语言消息实现。
┌────────────────────────────────────────────────────────────────────┐
│ Agent通信机制概览 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 通信模式： │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 点对点通信 (Point-to-Point) │ │
│ │ ┌───────┐ ┌───────┐ │ │
│ │ │Agent A│──message──>│Agent B│ │ │
│ │ └───────┘ └───────┘ │ │
│ │ 适用：CAMEL式双Agent协作 │ │
│ │ │ │
│ │ 2. 广播通信 (Broadcast) │ │
│ │ ┌───────┐ │ │
│ │ │Agent B│ │ │
│ │ └───▲───┘ │ │
│ │ ┌───────┐ │ ┌───────┐ │ │
│ │ │Agent A│──message──>│Agent C│ │ │
│ │ └───────┘ │ └───────┘ │ │
│ │ └───▼───┐ │ │
│ │ │Agent D│ │ │
│ │ └───────┘ │ │
│ │ 适用：公告、状态更新 │ │
│ │ │ │
│ │ 3. 组播通信 (Multicast) │ │
│ │ 发送给特定Agent组 │ │
│ │ 适用：部门内部通信 │ │
│ │ │ │
│ │ 4. 请求-响应 (Request-Response) │ │
│ │ ┌───────┐ request ┌───────┐ │ │
│ │ │Agent A│────────────>│Agent B│ │ │
│ │ │ │<────────────│ │ │ │
│ │ └───────┘ response └───────┘ │ │
│ │ 适用：任务委派、信息查询 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 消息结构： │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ { │ │
│ │ "message_id": "uuid", // 消息唯一标识 │ │
│ │ "sender": "agent_id", // 发送者 │ │
│ │ "receiver": "agent_id|*|group", // 接收者 │ │
│ │ "type": "request|response|broadcast|notify", │ │
│ │ "content": "...", // 消息内容 │ │
│ │ "reply_to": "message_id|null", // 回复的消息ID │ │
│ │ "timestamp": "ISO8601", // 时间戳 │ │
│ │ "metadata": {...} // 元数据 │ │
│ │ } │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘9.2 共享记忆与黑板模式
黑板模式（Blackboard Pattern）是一种经典的多智能体协作模式，所有Agent通过共享的"黑板"交换信息。
┌────────────────────────────────────────────────────────────────────┐
│ 黑板模式架构 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────┐ │
│ │ Blackboard │ │
│ │ (黑板) │ │
│ │ │ │
│ │ ┌───────────────────────┐ │ │
│ │ │ Current State │ │ │
│ │ │ • task_description │ │ │
│ │ │ • progress: 60% │ │ │
│ │ │ • artifacts: [...] │ │ │
│ │ └───────────────────────┘ │ │
│ │ │ │
│ │ ┌───────────────────────┐ │ │
│ │ │ Shared Knowledge │ │ │
│ │ │ • requirements.md │ │ │
│ │ │ • architecture.md │ │ │
│ │ │ • code_files: [...] │ │ │
│ │ └───────────────────────┘ │ │
│ │ │ │
│ │ ┌───────────────────────┐ │ │
│ │ │ Message Queue │ │ │
│ │ │ • pending messages │ │ │
│ │ │ • notifications │ │ │
│ │ └───────────────────────┘ │ │
│ │ │ │
│ └──────────────┬──────────────┘ │
│ │ │
│ ┌────────────────────┼────────────────────┐ │
│ │ read/write│ │ │
│ │ │ │ │
│ v v v │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Agent A │ │ Agent B │ │ Agent C │ │
│ │ (Planner)│ │ (Coder) │ │ (Tester) │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 黑板操作： │
│ • read(key) - 读取黑板内容 │
│ • write(key, value) - 写入黑板 │
│ • subscribe(key, callback) - 订阅变化 │
│ • lock(key) - 锁定资源（避免冲突） │
│ │
└────────────────────────────────────────────────────────────────────┘9.3 代码实战：构建通信层
python
"""
Multi-Agent Communication Layer
多智能体通信层实现
"""
import uuid
import time
import threading
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Callable, Any
from collections import defaultdict
from queue import Queue
import json
@dataclass
class Message:
"""消息类"""
message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
sender: str = ""
receiver: str = "" # 可以是agent_id, "*"(广播), 或 "group:xxx"
msg_type: str = "message" # request, response, broadcast, notify
content: str = ""
reply_to: Optional[str] = None
timestamp: float = field(default_factory=time.time)
metadata: Dict = field(default_factory=dict)
def to_dict(self) -> Dict:
return {
"message_id": self.message_id,
"sender": self.sender,
"receiver": self.receiver,
"type": self.msg_type,
"content": self.content,
"reply_to": self.reply_to,
"timestamp": self.timestamp,
"metadata": self.metadata
}
class Blackboard:
"""共享黑板"""
def __init__(self):
self._data: Dict[str, Any] = {}
self._locks: Dict[str, threading.Lock] = defaultdict(threading.Lock)
self._subscribers: Dict[str, List[Callable]] = defaultdict(list)
self._history: List[Dict] = []
def read(self, key: str, default: Any = None) -> Any:
"""读取黑板内容"""
return self._data.get(key, default)
def write(self, key: str, value: Any, author: str = "system"):
"""写入黑板"""
with self._locks[key]:
old_value = self._data.get(key)
self._data[key] = value
# 记录历史
self._history.append({
"action": "write",
"key": key,
"old_value": old_value,
"new_value": value,
"author": author,
"timestamp": time.time()
})
# 通知订阅者
for callback in self._subscribers[key]:
try:
callback(key, value, old_value)
except Exception as e:
print(f"Subscriber callback error: {e}")
def subscribe(self, key: str, callback: Callable):
"""订阅key的变化"""
self._subscribers[key].append(callback)
def unsubscribe(self, key: str, callback: Callable):
"""取消订阅"""
if callback in self._subscribers[key]:
self._subscribers[key].remove(callback)
def get_snapshot(self) -> Dict:
"""获取黑板快照"""
return dict(self._data)
def get_history(self, limit: int = 100) -> List[Dict]:
"""获取历史记录"""
return self._history[-limit:]
class MessageBus:
"""消息总线"""
def __init__(self):
self._queues: Dict[str, Queue] = defaultdict(Queue)
self._groups: Dict[str, set] = defaultdict(set)
self._handlers: Dict[str, Callable] = {}
self._message_log: List[Message] = []
def register_agent(self, agent_id: str, handler: Callable):
"""注册Agent"""
self._handlers[agent_id] = handler
def unregister_agent(self, agent_id: str):
"""注销Agent"""
if agent_id in self._handlers:
del self._handlers[agent_id]
def join_group(self, agent_id: str, group_name: str):
"""加入群组"""
self._groups[group_name].add(agent_id)
def leave_group(self, agent_id: str, group_name: str):
"""离开群组"""
if agent_id in self._groups[group_name]:
self._groups[group_name].remove(agent_id)
def send(self, message: Message):
"""发送消息"""
self._message_log.append(message)
receiver = message.receiver
if receiver == "*":
# 广播
for agent_id, handler in self._handlers.items():
if agent_id != message.sender:
self._deliver(message, agent_id)
elif receiver.startswith("group:"):
# 组播
group_name = receiver[6:]
for agent_id in self._groups.get(group_name, set()):
if agent_id != message.sender:
self._deliver(message, agent_id)
else:
# 点对点
self._deliver(message, receiver)
def _deliver(self, message: Message, agent_id: str):
"""投递消息"""
if agent_id in self._handlers:
try:
self._handlers[agent_id](message)
except Exception as e:
print(f"Message delivery error to {agent_id}: {e}")
else:
# 放入队列等待
self._queues[agent_id].put(message)
def get_pending_messages(self, agent_id: str) -> List[Message]:
"""获取待处理消息"""
messages = []
while not self._queues[agent_id].empty():
messages.append(self._queues[agent_id].get())
return messages
def get_message_log(self, limit: int = 100) -> List[Message]:
"""获取消息日志"""
return self._message_log[-limit:]
class CommunicationHub:
"""通信中心 - 整合黑板和消息总线"""
def __init__(self):
self.blackboard = Blackboard()
self.message_bus = MessageBus()
def register_agent(self, agent_id: str, handler: Callable):
"""注册Agent"""
self.message_bus.register_agent(agent_id, handler)
def send_message(
self,
sender: str,
receiver: str,
content: str,
msg_type: str = "message",
reply_to: Optional[str] = None,
metadata: Dict = None
) -> Message:
"""发送消息"""
message = Message(
sender=sender,
receiver=receiver,
msg_type=msg_type,
content=content,
reply_to=reply_to,
metadata=metadata or {}
)
self.message_bus.send(message)
return message
def broadcast(self, sender: str, content: str, msg_type: str = "broadcast"):
"""广播消息"""
return self.send_message(sender, "*", content, msg_type)
def update_shared_state(self, key: str, value: Any, author: str):
"""更新共享状态"""
self.blackboard.write(key, value, author)
def get_shared_state(self, key: str, default: Any = None) -> Any:
"""获取共享状态"""
return self.blackboard.read(key, default)
def subscribe_state(self, key: str, callback: Callable):
"""订阅状态变化"""
self.blackboard.subscribe(key, callback)
class CommunicatingAgent:
"""支持通信的Agent基类"""
def __init__(self, agent_id: str, hub: CommunicationHub):
self.agent_id = agent_id
self.hub = hub
self.inbox: List[Message] = []
# 注册到通信中心
hub.register_agent(agent_id, self._on_message)
def _on_message(self, message: Message):
"""收到消息的回调"""
self.inbox.append(message)
self.handle_message(message)
def handle_message(self, message: Message):
"""处理消息（子类重写）"""
print(f"[{self.agent_id}] Received from {message.sender}: {message.content[:50]}...")
def send_to(self, receiver: str, content: str, msg_type: str = "message"):
"""发送消息给特定Agent"""
return self.hub.send_message(
sender=self.agent_id,
receiver=receiver,
content=content,
msg_type=msg_type
)
def broadcast(self, content: str):
"""广播消息"""
return self.hub.broadcast(self.agent_id, content)
def update_state(self, key: str, value: Any):
"""更新共享状态"""
self.hub.update_shared_state(key, value, self.agent_id)
def get_state(self, key: str, default: Any = None) -> Any:
"""获取共享状态"""
return self.hub.get_shared_state(key, default)
# 示例：使用通信层
def demo_communication():
"""演示通信功能"""
# 创建通信中心
hub = CommunicationHub()
# 创建Agent
class PlannerAgent(CommunicatingAgent):
def handle_message(self, message: Message):
print(f"[Planner] Got: {message.content}")
if "help" in message.content.lower():
self.send_to(message.sender, "I can help you plan the project!")
class CoderAgent(CommunicatingAgent):
def handle_message(self, message: Message):
print(f"[Coder] Got: {message.content}")
if "code" in message.content.lower():
self.update_state("code_status", "in_progress")
planner = PlannerAgent("planner", hub)
coder = CoderAgent("coder", hub)
# 订阅状态变化
def on_code_status_change(key, new_val, old_val):
print(f"Code status changed: {old_val} -> {new_val}")
hub.subscribe_state("code_status", on_code_status_change)
# 模拟通信
print("\n=== Communication Demo ===\n")
# 点对点消息
planner.send_to("coder", "Please start coding the feature")
# 广播
coder.broadcast("I need help with the database design")
# 更新共享状态
planner.update_state("project_phase", "development")
coder.update_state("code_status", "completed")
# 查看黑板状态
print(f"\nBlackboard snapshot: {hub.blackboard.get_snapshot()}")
return hub
if __name__ == "__main__":
demo_communication()💡 思考：为什么需要专门的通信层，直接让Agent互相调用不行吗？
🤔 解答：专门的通信层提供了重要的好处：
- 解耦：Agent之间不需要直接引用，降低耦合度
- 可追溯：所有通信都有记录，便于调试和分析
- 灵活性：可以轻松添加消息过滤、优先级、持久化等功能
- 扩展性：支持不同的通信模式（点对点、广播、组播）
- 共享状态管理：黑板模式提供了一致的状态共享机制
10. 实战项目：构建多智能体研究团队
让我们综合运用前面所学的知识，构建一个多智能体研究团队，用于自动化文献研究和综述撰写。
10.1 项目设计与架构
┌────────────────────────────────────────────────────────────────────┐
│ 多智能体研究团队架构 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ Research Lead │ │
│ │ (研究负责人) │ │
│ └────────┬────────┘ │
│ │ │
│ │ 协调 │
│ │ │
│ ┌────────────────────────┼────────────────────────┐ │
│ │ │ │ │
│ v v v │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │Literature│ │ Analyst │ │ Writer │ │
│ │ Searcher │ │ (分析师) │ │ (写作者) │ │
│ │(文献检索) │ └────┬─────┘ └────┬─────┘ │
│ └────┬─────┘ │ │ │
│ │ │ │ │
│ │ v v │
│ │ ┌──────────┐ ┌──────────┐ │
│ │ │ Critic │ │ Editor │ │
│ │ │ (批评者) │ │ (编辑) │ │
│ │ └──────────┘ └──────────┘ │
│ │ │
│ └──────────────────────┬──────────────────────────┘ │
│ │ │
│ v │
│ ┌─────────────────┐ │
│ │ Blackboard │ │
│ │ │ │
│ │ • research_topic│ │
│ │ • papers_found │ │
│ │ • key_insights │ │
│ │ • draft_outline │ │
│ │ • final_report │ │
│ │ │ │
│ └─────────────────┘ │
│ │
│ 工作流程： │
│ 1. Research Lead 分解研究任务 │
│ 2. Literature Searcher 检索相关文献 │
│ 3. Analyst 分析文献，提取关键洞见 │
│ 4. Critic 质疑和验证分析结论 │
│ 5. Writer 撰写研究报告 │
│ 6. Editor 审校和润色 │
│ 7. Research Lead 最终审核 │
│ │
└────────────────────────────────────────────────────────────────────┘10.2 完整代码实现
python
"""
Multi-Agent Research Team
多智能体研究团队实现
"""
import os
import json
from dataclasses import dataclass, field
from typing import List, Dict, Optional
from enum import Enum
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
class ResearchPhase(Enum):
"""研究阶段"""
PLANNING = "planning"
LITERATURE_SEARCH = "literature_search"
ANALYSIS = "analysis"
CRITIQUE = "critique"
WRITING = "writing"
EDITING = "editing"
REVIEW = "review"
@dataclass
class ResearchState:
"""研究状态"""
topic: str
phase: ResearchPhase = ResearchPhase.PLANNING
research_questions: List[str] = field(default_factory=list)
papers: List[Dict] = field(default_factory=list)
key_insights: List[str] = field(default_factory=list)
critiques: List[str] = field(default_factory=list)
outline: str = ""
draft: str = ""
final_report: str = ""
class ResearchAgent:
"""研究Agent基类"""
def __init__(self, name: str, role: str, system_prompt: str, model: str = "gpt-4"):
self.name = name
self.role = role
self.system_prompt = system_prompt
self.model = model
def think(self, prompt: str, context: str = "") -> str:
"""Agent思考并生成回复"""
messages = [
{"role": "system", "content": self.system_prompt},
{"role": "user", "content": f"{context}\n\n{prompt}" if context else prompt}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=2000
)
return response.choices[0].message.content
class ResearchLead(ResearchAgent):
"""研究负责人"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Dr. Research Lead",
role="Research Lead",
system_prompt="""你是一位资深研究负责人，负责：
1. 定义研究问题和范围
2. 协调团队成员的工作
3. 确保研究质量
4. 最终审核研究成果
你有丰富的学术研究经验，能够把握研究方向和重点。""",
model=model
)
def define_research_questions(self, topic: str) -> List[str]:
"""定义研究问题"""
response = self.think(f"""
请为以下研究主题定义3-5个核心研究问题：
主题：{topic}
要求：
1. 问题要具体、可研究
2. 问题之间要有逻辑关联
3. 覆盖主题的关键方面
请以JSON格式返回：
{{"questions": ["问题1", "问题2", ...]}}
""")
try:
if "```json" in response:
response = response.split("```json")[1].split("```")[0]
data = json.loads(response)
return data.get("questions", [])
except:
return [response]
def final_review(self, report: str) -> Dict:
"""最终审核"""
response = self.think(f"""
请对以下研究报告进行最终审核：
{report[:3000]}...
请评估：
1. 研究问题是否得到回答
2. 论证是否充分
3. 结论是否合理
4. 是否需要修改
请以JSON格式返回：
{{
"approved": true/false,
"score": 1-10,
"strengths": ["优点1", "优点2"],
"weaknesses": ["不足1", "不足2"],
"suggestions": ["建议1", "建议2"]
}}
""")
try:
if "```json" in response:
response = response.split("```json")[1].split("```")[0]
return json.loads(response)
except:
return {"approved": True, "score": 7, "feedback": response}
class LiteratureSearcher(ResearchAgent):
"""文献检索员"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Literature Bot",
role="Literature Searcher",
system_prompt="""你是一位专业的文献检索专家，负责：
1. 根据研究问题检索相关文献
2. 筛选高质量、高相关性的文献
3. 提供文献的关键信息摘要
你熟悉各领域的重要文献和最新进展。
注意：由于你无法访问实际数据库，请基于你的知识模拟文献检索结果。""",
model=model
)
def search(self, questions: List[str], topic: str) -> List[Dict]:
"""检索文献"""
response = self.think(f"""
研究主题：{topic}
研究问题：
{chr(10).join([f"{i+1}. {q}" for i, q in enumerate(questions)])}
请为这些研究问题推荐相关的重要文献。对于每篇文献，提供：
1. 标题
2. 作者
3. 年份
4. 主要贡献
5. 与研究问题的相关性
请以JSON格式返回5-8篇重要文献：
{{
"papers": [
{{
"title": "论文标题",
"authors": "作者",
"year": 2023,
"contribution": "主要贡献",
"relevance": "与研究的关联"
}}
]
}}
""")
try:
if "```json" in response:
response = response.split("```json")[1].split("```")[0]
data = json.loads(response)
return data.get("papers", [])
except:
return []
class Analyst(ResearchAgent):
"""分析师"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Dr. Analyst",
role="Research Analyst",
system_prompt="""你是一位资深研究分析师，负责：
1. 深入分析文献内容
2. 提取关键洞见和模式
3. 综合不同来源的信息
4. 识别研究领域的趋势和缺口
你擅长批判性思维和综合分析。""",
model=model
)
def analyze(self, papers: List[Dict], questions: List[str]) -> List[str]:
"""分析文献"""
papers_text = "\n\n".join([
f"【{p['title']}】({p['year']})\n{p['contribution']}"
for p in papers
])
response = self.think(f"""
研究问题：
{chr(10).join([f"{i+1}. {q}" for i, q in enumerate(questions)])}
相关文献：
{papers_text}
请基于这些文献进行深入分析，提取5-8个关键洞见。
每个洞见应该：
1. 直接回应某个研究问题
2. 有文献支持
3. 有实际意义
请以JSON格式返回：
{{"insights": ["洞见1", "洞见2", ...]}}
""")
try:
if "```json" in response:
response = response.split("```json")[1].split("```")[0]
data = json.loads(response)
return data.get("insights", [])
except:
return [response]
class Critic(ResearchAgent):
"""批评者"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Critical Reviewer",
role="Research Critic",
system_prompt="""你是一位严格的学术批评者，负责：
1. 质疑研究假设和结论
2. 发现论证中的漏洞
3. 指出可能的偏见或局限
4. 提出改进建议
你的批评是建设性的，旨在提高研究质量。""",
model=model
)
def critique(self, insights: List[str], context: str) -> List[str]:
"""批评和质疑"""
response = self.think(f"""
研究背景：
{context}
分析得出的洞见：
{chr(10).join([f"{i+1}. {ins}" for i, ins in enumerate(insights)])}
请对这些洞见进行批判性审视：
1. 哪些结论可能过于草率？
2. 有哪些潜在的反例或例外？
3. 论证中是否有逻辑漏洞？
4. 是否有重要的方面被忽视？
请提供3-5条建设性的批评意见：
{{"critiques": ["批评1", "批评2", ...]}}
""")
try:
if "```json" in response:
response = response.split("```json")[1].split("```")[0]
data = json.loads(response)
return data.get("critiques", [])
except:
return [response]
class Writer(ResearchAgent):
"""写作者"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Academic Writer",
role="Research Writer",
system_prompt="""你是一位专业的学术写作专家，负责：
1. 将研究发现转化为清晰的文字
2. 组织文章结构
3. 确保学术规范
4. 使复杂概念易于理解
你的写作风格专业而清晰。""",
model=model
)
def create_outline(self, topic: str, questions: List[str], insights: List[str]) -> str:
"""创建大纲"""
return self.think(f"""
研究主题：{topic}
研究问题：
{chr(10).join([f"- {q}" for q in questions])}
关键洞见：
{chr(10).join([f"- {ins}" for ins in insights])}
请为研究报告创建一个详细的大纲，包括：
1. 引言
2. 背景与相关工作
3. 主要发现（按研究问题组织）
4. 讨论
5. 结论
输出清晰的大纲结构。
""")
def write_draft(self, outline: str, insights: List[str], critiques: List[str]) -> str:
"""撰写初稿"""
return self.think(f"""
请根据以下大纲撰写研究报告的初稿：
大纲：
{outline}
关键洞见：
{chr(10).join([f"- {ins}" for ins in insights])}
需要注意的批评意见：
{chr(10).join([f"- {c}" for c in critiques])}
要求：
1. 学术风格，专业术语
2. 论证充分，逻辑清晰
3. 回应批评意见
4. 2000-3000字
请撰写完整的研究报告初稿。
""")
class Editor(ResearchAgent):
"""编辑"""
def __init__(self, model: str = "gpt-4"):
super().__init__(
name="Senior Editor",
role="Research Editor",
system_prompt="""你是一位资深学术编辑，负责：
1. 审校文章的语言和风格
2. 改进文章的可读性
3. 确保格式规范
4. 检查引用和参考文献
你注重细节，追求文字的精确和优美。""",
model=model
)
def edit(self, draft: str) -> str:
"""编辑润色"""
return self.think(f"""
请对以下研究报告初稿进行编辑和润色：
{draft}
编辑要点：
1. 改进语言表达
2. 增强逻辑连贯性
3. 优化段落结构
4. 确保学术规范
请输出编辑后的完整报告。
""")
class ResearchTeam:
"""多智能体研究团队"""
def __init__(self, model: str = "gpt-4"):
self.model = model
# 创建团队成员
self.lead = ResearchLead(model)
self.searcher = LiteratureSearcher(model)
self.analyst = Analyst(model)
self.critic = Critic(model)
self.writer = Writer(model)
self.editor = Editor(model)
# 研究状态
self.state: Optional[ResearchState] = None
def conduct_research(self, topic: str) -> Dict:
"""执行完整的研究流程"""
print(f"\n{'='*60}")
print(f"🔬 Multi-Agent Research Team")
print(f"{'='*60}")
print(f"📚 Topic: {topic}")
print(f"{'='*60}\n")
# 初始化状态
self.state = ResearchState(topic=topic)
# Phase 1: 规划
print("📋 Phase 1: Research Planning")
print("-" * 40)
self.state.phase = ResearchPhase.PLANNING
questions = self.lead.define_research_questions(topic)
self.state.research_questions = questions
print(f"Research Questions:")
for i, q in enumerate(questions, 1):
print(f" {i}. {q}")
print()
# Phase 2: 文献检索
print("🔍 Phase 2: Literature Search")
print("-" * 40)
self.state.phase = ResearchPhase.LITERATURE_SEARCH
papers = self.searcher.search(questions, topic)
self.state.papers = papers
print(f"Found {len(papers)} relevant papers:")
for p in papers[:3]:
print(f" • {p['title']} ({p['year']})")
print(" ...")
print()
# Phase 3: 分析
print("📊 Phase 3: Analysis")
print("-" * 40)
self.state.phase = ResearchPhase.ANALYSIS
insights = self.analyst.analyze(papers, questions)
self.state.key_insights = insights
print(f"Key Insights:")
for i, ins in enumerate(insights[:3], 1):
print(f" {i}. {ins[:80]}...")
print()
# Phase 4: 批评
print("🔎 Phase 4: Critical Review")
print("-" * 40)
self.state.phase = ResearchPhase.CRITIQUE
critiques = self.critic.critique(insights, f"Topic: {topic}")
self.state.critiques = critiques
print(f"Critiques:")
for i, c in enumerate(critiques[:2], 1):
print(f" {i}. {c[:80]}...")
print()
# Phase 5: 写作
print("✍️ Phase 5: Writing")
print("-" * 40)
self.state.phase = ResearchPhase.WRITING
outline = self.writer.create_outline(topic, questions, insights)
self.state.outline = outline
draft = self.writer.write_draft(outline, insights, critiques)
self.state.draft = draft
print(f"Draft completed: {len(draft)} characters")
print()
# Phase 6: 编辑
print("📝 Phase 6: Editing")
print("-" * 40)
self.state.phase = ResearchPhase.EDITING
final_report = self.editor.edit(draft)
self.state.final_report = final_report
print(f"Final report: {len(final_report)} characters")
print()
# Phase 7: 最终审核
print("✅ Phase 7: Final Review")
print("-" * 40)
self.state.phase = ResearchPhase.REVIEW
review = self.lead.final_review(final_report)
print(f"Review Result:")
print(f" Approved: {review.get('approved', 'N/A')}")
print(f" Score: {review.get('score', 'N/A')}/10")
print()
# 汇总结果
result = {
"topic": topic,
"research_questions": questions,
"papers_reviewed": len(papers),
"key_insights": insights,
"critiques": critiques,
"final_report": final_report,
"review": review
}
print(f"{'='*60}")
print("🎉 Research Completed!")
print(f"{'='*60}\n")
return result
def main():
"""主函数"""
# 定义研究主题
topic = "大型语言模型在多智能体系统中的协作机制研究"
# 创建研究团队
team = ResearchTeam(model="gpt-4")
# 执行研究
result = team.conduct_research(topic)
# 保存结果
with open("research_result.json", "w", encoding="utf-8") as f:
json.dump(result, f, ensure_ascii=False, indent=2)
# 保存研究报告
with open("research_report.md", "w", encoding="utf-8") as f:
f.write(result["final_report"])
print("Results saved to research_result.json")
print("Report saved to research_report.md")
return result
if __name__ == "__main__":
main()10.3 运行效果与分析
运行上述代码，你会看到类似以下的输出：
============================================================
🔬 Multi-Agent Research Team
============================================================
📚 Topic: 大型语言模型在多智能体系统中的协作机制研究
============================================================
📋 Phase 1: Research Planning
----------------------------------------
Research Questions:
1. LLM-based多智能体系统中，Agent之间如何有效地进行信息交换和共享？
2. 什么样的协作架构最适合特定类型的任务？
3. 如何解决多Agent协作中的冲突和死锁问题？
4. 涌现行为在LLM多智能体系统中如何产生和利用？
🔍 Phase 2: Literature Search
----------------------------------------
Found 6 relevant papers:
• CAMEL: Communicative Agents for "Mind" Exploration (2023)
• ChatDev: Communicative Agents for Software Development (2023)
• AgentVerse: Facilitating Multi-Agent Collaboration (2023)
...
📊 Phase 3: Analysis
----------------------------------------
Key Insights:
1. 自然语言作为Agent间通信媒介大大降低了系统设计复杂度...
2. 角色专业化和任务分解是提高协作效率的关键...
3. 辩论和对抗机制可以提高推理质量...
🔎 Phase 4: Critical Review
----------------------------------------
Critiques:
1. 当前研究大多基于GPT-4等闭源模型，可复现性存在问题...
2. 缺乏对计算成本和延迟的系统性评估...
✍️ Phase 5: Writing
----------------------------------------
Draft completed: 4532 characters
📝 Phase 6: Editing
----------------------------------------
Final report: 4789 characters
✅ Phase 7: Final Review
----------------------------------------
Review Result:
Approved: True
Score: 8/10
============================================================
🎉 Research Completed!
============================================================💡 思考：这个研究团队系统有什么优势和局限？
🤔 解答 ：
优势：
- 自动化程度高，大大减少人工工作量
- 多Agent协作提供了多角度分析
- 批评机制有助于发现问题
- 流程清晰，可追溯
局限：
- 无法访问真实的文献数据库
- 依赖LLM的知识可能有偏差或过时
- 生成的报告需要人工核实
- 深度分析能力仍有待提高
11. 挑战与前沿探索
11.1 当前面临的挑战
尽管LLM-based多智能体系统展现出了巨大潜力，但仍面临诸多挑战：
┌────────────────────────────────────────────────────────────────────┐
│ 多智能体系统面临的挑战 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 🔴 成本与效率 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ • 多Agent意味着多次LLM调用，成本高昂 │ │
│ │ • 延迟累加，响应时间长 │ │
│ │ • Token消耗随对话轮数增长 │ │
│ │ │ │
│ │ 解决方向： │ │
│ │ - 优化Agent数量和交互轮数 │ │
│ │ - 使用更小的模型处理简单任务 │ │
│ │ - 异步并行处理 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 2. 🟠 协调与一致性 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ • Agent可能产生相互矛盾的输出 │ │
│ │ • 难以保证全局一致性 │ │
│ │ • 共享状态的同步和冲突处理 │ │
│ │ │ │
│ │ 解决方向： │ │
│ │ - 设计明确的协调协议 │ │
│ │ - 引入仲裁机制 │ │
│ │ - 使用事务性的状态更新 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 3. 🟡 可控性与安全性 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ • Agent可能偏离预设目标 │ │
│ │ • 自主性带来的不可预测性 │ │
│ │ • 多Agent交互可能产生意外行为 │ │
│ │ │ │
│ │ 解决方向： │ │
│ │ - 设置行为边界和安全约束 │ │
│ │ - 人在环中（Human-in-the-loop）监督 │ │
│ │ - 可解释性和审计机制 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 4. 🟢 评估与基准 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ • 缺乏标准化的评估基准 │ │
│ │ • 难以量化协作效率和涌现效果 │ │
│ │ • 不同系统之间难以公平比较 │ │
│ │ │ │
│ │ 解决方向： │ │
│ │ - 建立多维度评估框架 │ │
│ │ - 开发标准化测试任务集 │ │
│ │ - 社区共建基准数据集 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 5. 🔵 可扩展性 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ • Agent数量增加时，交互复杂度指数增长 │ │
│ │ • 内存和计算资源需求快速增长 │ │
│ │ • 协调开销可能成为瓶颈 │ │
│ │ │ │
│ │ 解决方向： │ │
│ │ - 层级化组织结构 │ │
│ │ - 局部化交互，减少全局通信 │ │
│ │ - 动态Agent创建和销毁 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘11.2 前沿研究方向
当前学术界和工业界正在探索的前沿方向：
┌────────────────────────────────────────────────────────────────────┐
│ 前沿研究方向 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 🚀 自主Agent世界模型 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 让Agent建立对环境和其他Agent的内部模型，实现更智能的交互 │ │
│ │ │ │
│ │ 代表工作： │ │
│ │ • World Models for Autonomous Agents │ │
│ │ • Theory of Mind in Multi-Agent Systems │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 2. 🧬 Agent进化与学习 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Agent在交互中不断学习和进化，适应新的任务和环境 │ │
│ │ │ │
│ │ 代表工作： │ │
│ │ • Voyager: Learning to Play Minecraft │ │
│ │ • Self-Refine: Iterative Refinement with Self-Feedback │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 3. 🌐 大规模Agent社会模拟 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 模拟数百甚至数千Agent的社会行为，研究复杂社会现象 │ │
│ │ │ │
│ │ 代表工作： │ │
│ │ • Generative Agents: Interactive Simulacra of Human Behavior│ │
│ │ • AgentSims: An Open-Source Sandbox for Large Language Model│ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 4. 🔗 跨模态多Agent协作 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 结合视觉、语音、代码等多模态能力的Agent协作 │ │
│ │ │ │
│ │ 代表工作： │ │
│ │ • Multi-Modal Agent Systems │ │
│ │ • Vision-Language-Action Models │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 5. 🛡️ Agent对齐与安全 │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 确保多Agent系统的行为与人类价值观和意图对齐 │ │
│ │ │ │
│ │ 代表工作： │ │
│ │ • Constitutional AI for Multi-Agent Systems │ │
│ │ • Safe Exploration in Multi-Agent Settings │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘💡 思考：多智能体系统的未来会是什么样？
🤔 解答：我们可以期待以下发展：
- 更自主的Agent：Agent将拥有更强的自主学习和适应能力
- 更大规模的协作：从几个Agent扩展到数百、数千Agent的协作
- 与物理世界结合：多Agent系统将与机器人、物联网深度结合
- 新的组织形式：可能出现我们从未见过的Agent组织和协作模式
- 更深入的涌现：随着系统规模扩大，可能出现更复杂的涌现行为
12. 总结与展望
核心要点回顾
通过本文的学习，我们深入探讨了多智能体协作的方方面面：
┌────────────────────────────────────────────────────────────────────┐
│ 核心要点总结 │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 📚 理论基础 │
│ • 多智能体系统的核心特征：自主性、社会性、反应性、适应性 │
│ • LLM为MAS带来了自然语言通信和角色扮演能力 │
│ │
│ 🔧 主流框架 │
│ • CAMEL：角色扮演驱动，Inception Prompting保持角色一致 │
│ • ChatDev：模拟软件公司，Chat Chain实现阶段化开发 │
│ • AgentVerse：动态招募，专家协作形成共识 │
│ │
│ 🔄 协作模式 │
│ • 中心化：协调者统筹，适合任务明确的场景 │
│ • 去中心化：自组织，高鲁棒性 │
│ • 层级化：模拟组织架构 │
│ • 流水线：顺序执行，专业分工 │
│ • 发布订阅：松耦合，事件驱动 │
│ │
│ ⚔️ 对抗机制 │
│ • 辩论式推理：多角度分析，提高决策质量 │
│ • 红蓝对抗：攻防迭代，增强系统鲁棒性 │
│ • 博弈论视角：理解Agent交互的本质 │
│ │
│ ✨ 涌现行为 │
│ • 集体智能：1+1>2的效果 │
│ • 必要条件：足够数量、异质性、交互机制、反馈 │
│ • 设计原则：适度自主、有意义交互、适度张力、允许迭代 │
│ │
│ 📡 通信机制 │
│ • 消息传递：点对点、广播、组播 │
│ • 共享状态：黑板模式提供一致的状态管理 │
│ │
└────────────────────────────────────────────────────────────────────┘实践建议
如果你想在自己的项目中应用多智能体系统，以下是一些建议：
- 从简单开始：先用2-3个Agent验证想法，再逐步扩展
- 明确角色：每个Agent应有清晰的角色定义和职责边界
- 设计好协议：Agent间的通信和协调机制要提前设计
- 监控和调试：记录所有Agent交互，便于问题排查
- 迭代优化：根据实际效果不断调整Agent配置和协作流程
展望未来
多智能体系统正处于快速发展期，我们有理由相信：
- 更强大的协作：随着基础模型能力的提升，Agent协作将更加智能
- 更广泛的应用：从软件开发扩展到科学研究、创意设计、商业决策等领域
- 更深刻的理解：对涌现行为的研究将帮助我们更好地设计和利用多Agent系统
- 人机协作：多Agent系统将成为人类的强大助手，而非替代者
正如蚁群和蜂群展示的那样，简单个体的协作可以创造出令人惊叹的集体智慧。在AI Agent时代，我们正在见证一种新型"数字生态"的诞生------多个AI Agent通过协作、竞争、涌现，共同解决人类面临的复杂挑战。
让我们拭目以待，并积极参与这场激动人心的变革！
📝 作者说明：本文是【Agents篇】系列的第9篇，聚焦于多智能体协作的核心概念和实践。如果您觉得本文有帮助，欢迎点赞、收藏和分享！有任何问题或建议，欢迎在评论区讨论。
参考文献
1\] Li, G., Hammoud, H. A. A. K., Itani, H., Khizbullin, D., \& Ghanem, B. (2023). CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. *arXiv preprint arXiv:2303.17760*. \[2\] Qian, C., Cong, X., Yang, C., Chen, W., Su, Y., Xu, J., ... \& Sun, M. (2023). ChatDev: Communicative Agents for Software Development. *arXiv preprint arXiv:2307.07924*. \[3\] Chen, W., Su, Y., Zuo, J., Yang, C., Yuan, C., Qian, C., ... \& Sun, M. (2023). AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors in Agents. *arXiv preprint arXiv:2308.10848*. \[4\] Park, J. S., O'Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., \& Bernstein, M. S. (2023). Generative Agents: Interactive Simulacra of Human Behavior. *arXiv preprint arXiv:2304.03442*. \[5\] Hong, S., Zheng, X., Chen, J., Cheng, Y., Zhang, C., Wang, Z., ... \& Wu, Y. (2023). MetaGPT: Meta Programming for Multi-Agent Collaborative Framework. *arXiv preprint arXiv:2308.00352*. \[6\] Du, Y., Li, S., Torralba, A., Tenenbaum, J. B., \& Mordatch, I. (2023). Improving Factuality and Reasoning in Language Models through Multiagent Debate. *arXiv preprint arXiv:2305.14325*. \[7\] Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., ... \& Anandkumar, A. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. *arXiv preprint arXiv:2305.16291*. \[8\] Wooldridge, M. (2009). An Introduction to MultiAgent Systems (2nd ed.). John Wiley \& Sons. \[9\] Shoham, Y., \& Leyton-Brown, K. (2009). Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press. \[10\] Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., ... \& Zhou, D. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. *Advances in Neural Information Processing Systems*, 35, 24824-24837. \[11\] Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., \& Cao, Y. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. *International Conference on Learning Representations (ICLR)*. \[12\] Xi, Z., Chen, W., Guo, X., He, W., Ding, Y., Hong, B., ... \& Gui, T. (2023). The Rise and Potential of Large Language Model Based Agents: A Survey. *arXiv preprint arXiv:2309.07864*. \[13\] Wu, Q., Bansal, G., Zhang, J., Wu, Y., Zhang, S., Zhu, E., ... \& Wang, C. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework. *arXiv preprint arXiv:2308.08155*. \[14\] Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., ... \& Clark, P. (2023). Self-Refine: Iterative Refinement with Self-Feedback. *arXiv preprint arXiv:2303.17651*. \[15\] Huang, J., Gu, S. S., Hou, L., Wu, Y., Wang, X., Yu, H., \& Han, J. (2022). Large Language Models Can Self-Improve. *arXiv preprint arXiv:2210.11610*. \[16\] Liang, T., He, Z., Jiao, W., Wang, X., Wang, Y., Wang, R., ... \& Shi, S. (2023). Encouraging Divergent Thinking in Large Language Models through Multi-Agent Debate. *arXiv preprint arXiv:2305.19118*. \[17\] Minsky, M. (1988). The Society of Mind. Simon \& Schuster. \[18\] Ferber, J. (1999). Multi-Agent Systems: An Introduction to Distributed Artificial Intelligence. Addison-Wesley. \[19\] Silver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., ... \& Hassabis, D. (2018). A General Reinforcement Learning Algorithm That Masters Chess, Shogi, and Go Through Self-Play. *Science*, 362(6419), 1140-1144. \[20\] Vinyals, O., Babuschkin, I., Czarnecki, W. M., Mathieu, M., Dudzik, A., Chung, J., ... \& Silver, D. (2019). Grandmaster Level in StarCraft II Using Multi-Agent Reinforcement Learning. *Nature*, 575(7782), 350-354.