CrewAI生产实践

CrewAI生产实践2026:打造AI梦之队

引言 CrewAI以其简洁的API和角色扮演式多智能体设计,在2026年获得了大量生产用户。与AutoGen相比,CrewAI更注重"团队协作"的自然性。本文将分享CrewAI在生产环境中的实践经验。 CrewAI核心概念 Crew(团队) 一个Crew由多个Agent组成,每个Agent有特定角色、目标和工具。 Agent(成员) from crewai import Agent, Task, Crew, Process researcher = Agent( role='市场研究员', goal='收集和分析市场数据', backstory='你是一位有10年经验的市场研究专家,擅长数据分析和趋势预测。', tools=[search_tool, analytics_tool], llm='gpt-5', verbose=True ) writer = Agent( role='技术写作专家', goal='将研究结果转化为清晰的报告', backstory='你是一位资深技术写作专家,擅长将复杂数据转化为易懂的报告。', llm='claude-4-opus', verbose=True ) editor = Agent( role='内容编辑', goal='确保报告质量和一致性', backstory='你是一位严谨的编辑,对细节和质量有极高要求。', llm='gpt-5', verbose=True ) Task(任务) research_task = Task( description='研究2026年AI市场趋势,重点关注LLM和Agent领域。', agent=researcher, expected_output='一份包含数据和分析的市场研究报告', context=[] ) writing_task = Task( description='基于研究报告,撰写一篇2000字的行业分析文章。', agent=writer, expected_output='一篇2000字的文章', context=[research_task] # 依赖研究任务的输出 ) editing_task = Task( description='审核并修改文章,确保准确性和可读性。', agent=editor, expected_output='最终版文章', context=[writing_task] ) Crew(组建团队) crew = Crew( agents=[researcher, writer, editor], tasks=[research_task, writing_task, editing_task], process=Process.sequential, # 顺序执行 verbose=True ) result = crew.kickoff() 2026年新特性 1. 流程类型 # 顺序流程 crew = Crew(agents=agents, tasks=tasks, process=Process.sequential) # 层级流程(有管理者) crew = Crew( agents=agents, tasks=tasks, process=Process.hierarchical, manager_llm='gpt-5' ) # 自定义流程 from crewai.process import CustomProcess class MyProcess(CustomProcess): def run(self, crew, tasks): # 自定义执行逻辑 pass 2. 工具集成 from crewai.tools import tool @tool("搜索网络") def search(query: str) -> str: """搜索互联网获取最新信息""" return web_search(query) @tool("执行代码") def execute_code(code: str) -> str: """执行Python代码并返回结果""" return exec_python(code) @tool("读取文件") def read_file(path: str) -> str: """读取本地文件""" with open(path) as f: return f.read() 3. 记忆系统 crew = Crew( agents=agents, tasks=tasks, memory=True, # 启用记忆 memory_config={ "provider": "chroma", # 向量数据库 "embedder": "bge-large-zh", "long_term": True, "short_term": True } ) 4. 人机协作 from crewai import HumanInput # 在关键步骤加入人工审核 task = Task( description='生成营销文案', agent=writer, human_input=HumanInput( enabled=True, check_every=1, # 每步都检查 prompt="请审核以上内容,输入修改意见或'approve'确认。" ) ) 生产实践经验 实践一:角色设计 # 好的角色设计 good_agent = Agent( role='资深安全审计员', # 具体角色 goal='发现代码中的安全漏洞并提供修复建议', # 明确目标 backstory='''你是一位有15年经验的网络安全专家, 曾在Google和腾讯安全团队工作,精通OWASP Top 10漏洞 和安全编码最佳实践。''', # 丰富背景 tools=[code_analyzer, vulnerability_db], llm='gpt-5' ) # 不好的角色设计 bad_agent = Agent( role='助手', # 太模糊 goal='帮忙', # 不明确 backstory='你是一个AI助手。' # 太简单 ) 实践二:任务分解 # 好的任务分解:颗粒度适中 tasks = [ Task(description='分析需求文档,提取功能点', agent=analyst), Task(description='为每个功能点设计测试用例', agent=test_designer), Task(description='编写自动化测试脚本', agent=test_engineer), Task(description='执行测试并生成报告', agent=test_runner), ] # 不好的任务分解:太粗 tasks = [ Task(description='做测试', agent=tester), # 太笼统 ] 实践三:错误处理 from crewai import CrewError try: result = crew.kickoff() except CrewError as e: print(f"Crew执行失败:{e}") # 降级处理 result = fallback_process() # Agent级别错误处理 class SafeAgent(Agent): def execute_task(self, task): try: return super().execute_task(task) except Exception as e: return f"任务执行失败:{e}。请重试或调整策略。" 实践四:成本控制 # 根据任务复杂度选择模型 researcher = Agent( role='研究员', llm='deepseek-v4', # 研究用便宜模型 max_iter=5 ) writer = Agent( role='作家', llm='claude-4-opus', # 写作用高质量模型 max_iter=3 ) # 设置预算上限 crew = Crew( agents=[researcher, writer], tasks=tasks, max_cost=1.0, # 最大花费$1 ) 实践五:质量保证 # 添加质量检查Agent quality_checker = Agent( role='质量检查员', goal='确保输出质量达到标准', backstory='你是一位严格的质量检查专家。', llm='gpt-5' ) quality_task = Task( description='检查最终输出的质量,评分并给出改进建议。', agent=quality_checker, expected_output='质量评分报告' ) # 在流程末尾加入质量检查 crew = Crew( agents=[researcher, writer, editor, quality_checker], tasks=[research_task, writing_task, editing_task, quality_task] ) 部署方案 API服务 from fastapi import FastAPI from crewai import Crew app = FastAPI() @app.post("/analyze") async def analyze(topic: str): crew = create_research_crew(topic) result = crew.kickoff() return {"result": result} @app.post("/analyze/stream") async def analyze_stream(topic: str): crew = create_research_crew(topic) async for chunk in crew.kickoff_stream(): yield chunk 异步执行 import asyncio async def run_crews_concurrently(topics): crews = [create_research_crew(topic) for topic in topics] results = await asyncio.gather(*[crew.kickoff_async() for crew in crews]) return results 监控与调试 from crewai import CrewMonitor monitor = CrewMonitor() @monitor.trace def run_crew(crew, input_data): result = crew.kickoff(inputs=input_data) return result # 查看执行详情 monitor.print_summary() # 包括:每个Agent的执行时间、token消耗、输出质量 应用场景 场景一:内容生产 # 内容生产团队 content_crew = Crew( agents=[ Agent(role='选题策划', ...), Agent(role='资料收集', ...), Agent(role='内容撰写', ...), Agent(role='排版编辑', ...), Agent(role='SEO优化', ...), ], tasks=[...], process=Process.sequential ) 场景二:代码审查 # 代码审查团队 review_crew = Crew( agents=[ Agent(role='代码审查员', tools=[read_file, code_analyzer]), Agent(role='安全审计员', tools=[vulnerability_scanner]), Agent(role='性能分析师', tools=[profiler]), Agent(role='报告生成者'), ], tasks=[...] ) 场景三:数据分析 # 数据分析团队 data_crew = Crew( agents=[ Agent(role='数据工程师', tools=[sql_tool, python_tool]), Agent(role='数据分析师', tools=[statistical_tool]), Agent(role='可视化专家', tools=[chart_tool]), Agent(role='报告撰写者'), ], tasks=[...] ) 结语 CrewAI在2026年已经成为生产环境中最流行的多智能体框架之一。它的角色扮演式设计让AI协作变得自然直观,丰富的工具集成和记忆系统让它能胜任复杂的实际任务。 ...

2026-07-02 · 3 min · 531 words · 硅基 AGI 探索者
AutoGen多智能体

AutoGen 2026多智能体:协作AI的新范式

引言 多智能体(Multi-Agent)是2026年AI应用的热门方向。微软的AutoGen框架是这一领域的领军者,它让多个AI智能体协作完成复杂任务成为可能。本文将全面介绍AutoGen 2026的最新进展。 AutoGen 2026核心概念 多智能体协作模式 模式一:对话式协作 Agent A ←→ Agent B (两个Agent通过对话解决问题) 模式二:层级式协作 Manager Agent ├── Worker Agent 1 ├── Worker Agent 2 └── Worker Agent 3 (管理者分配任务给工作者) 模式三:流水线协作 Agent A → Agent B → Agent C (每个Agent处理一个阶段) 模式四:竞争式协作 Agent A ↘ Agent B → Judge Agent Agent C ↗ (多个Agent竞争,裁判选择最佳) 基本使用 双Agent对话 from autogen import AssistantAgent, UserProxyAgent # 创建用户代理 user_proxy = UserProxyAgent( name="user", human_input_mode="TERMINATE", max_consecutive_auto_reply=10 ) # 创建助手 assistant = AssistantAgent( name="assistant", system_prompt="你是一个Python编程助手。", llm_config={"model": "gpt-5"} ) # 开始对话 user_proxy.initiate_chat( assistant, message="帮我写一个快速排序算法" ) 多Agent协作 from autogen import AssistantAgent, GroupChat, GroupChatManager # 创建多个专家Agent coder = AssistantAgent( name="coder", system_prompt="你是一个Python程序员,负责写代码。", llm_config={"model": "gpt-5"} ) reviewer = AssistantAgent( name="reviewer", system_prompt="你是一个代码审查专家,负责检查代码质量。", llm_config={"model": "claude-4-opus"} ) tester = AssistantAgent( name="tester", system_prompt="你是一个测试工程师,负责编写测试用例。", llm_config={"model": "gpt-5"} ) # 创建群聊 group_chat = GroupChat( agents=[coder, reviewer, tester], messages=[], max_round=20 ) manager = GroupChatManager( groupchat=group_chat, llm_config={"model": "gpt-5"} ) # 开始协作 user_proxy.initiate_chat( manager, message="实现一个LRU缓存,包括代码、审查和测试" ) 2026年新特性 1. Agent Workflow from autogen import Workflow # 定义工作流 workflow = Workflow() # 添加节点 workflow.add_node("researcher", research_agent) workflow.add_node("writer", writing_agent) workflow.add_node("editor", editing_agent) # 定义流程 workflow.add_edge("researcher", "writer") workflow.add_edge("writer", "editor") workflow.add_edge("editor", "writer", condition="needs_revision") # 执行 result = workflow.run("写一篇关于AI的科普文章") 2. Agent工具 from autogen import register_function # 注册工具 @register_function("search") def search_web(query: str) -> str: """搜索网络""" return web_search(query) @register_function("code_exec") def execute_code(code: str) -> str: """执行Python代码""" return exec_python(code) # Agent可以使用这些工具 agent = AssistantAgent( name="tool_agent", tools=["search", "code_exec"], llm_config={"model": "gpt-5"} ) 3. 可观测性 from autogen import trace # 追踪Agent交互 with trace("my_conversation"): user_proxy.initiate_chat(assistant, message="...") # 查看追踪 trace.visualize() # 生成交互图 4. 持久化 from autogen import save_state, load_state # 保存对话状态 save_state(assistant, "agent_state.pkl") # 加载状态继续对话 assistant = load_state("agent_state.pkl") user_proxy.initiate_chat(assistant, message="继续之前的对话") 应用场景 场景一:软件开发 # 多Agent协作开发软件 product_manager = AssistantAgent( name="PM", system_prompt="你是产品经理,负责需求分析和项目规划。" ) architect = AssistantAgent( name="Architect", system_prompt="你是架构师,负责技术设计。" ) developer = AssistantAgent( name="Developer", system_prompt="你是开发者,负责编码实现。" ) qa = AssistantAgent( name="QA", system_prompt="你是测试工程师,负责质量保证。" ) team = GroupChat( agents=[product_manager, architect, developer, qa], max_round=50 ) 场景二:研究报告 # 多Agent协作写研究报告 researcher = AssistantAgent( name="Researcher", system_prompt="你是研究员,负责收集和分析资料。" ) analyst = AssistantAgent( name="Analyst", system_prompt="你是分析师,负责数据分析和可视化。" ) writer = AssistantAgent( name="Writer", system_prompt="你是技术写作专家,负责撰写报告。" ) editor = AssistantAgent( name="Editor", system_prompt="你是编辑,负责审核和修改。" ) 场景三:客服系统 # 分层Agent客服 triage_agent = AssistantAgent( name="Triage", system_prompt="你是客服分流Agent,判断问题类型并路由。" ) tech_agent = AssistantAgent( name="Tech", system_prompt="你是技术支持Agent。" ) billing_agent = AssistantAgent( name="Billing", system_prompt="你是计费问题Agent。" ) 性能优化 并行执行 # 多Agent并行工作 import asyncio async def parallel_agents(): tasks = [ agent1.ainvoke("任务1"), agent2.ainvoke("任务2"), agent3.ainvoke("任务3") ] results = await asyncio.gather(*tasks) return results 成本控制 # 根据任务复杂度选择模型 def select_model(task_complexity): if task_complexity == "simple": return "gpt-5o-mini" elif task_complexity == "medium": return "gpt-5o" else: return "gpt-5" 与其他框架对比 特性 AutoGen CrewAI LangGraph 多Agent ★★★★★ ★★★★☆ ★★★☆☆ 工作流 ★★★★☆ ★★★★★ ★★★★★ 可观测性 ★★★☆☆ ★★★☆☆ ★★★★★ 学习曲线 中等 低 高 适合场景 复杂协作 角色扮演 图式流程 结语 AutoGen在2026年仍然是多智能体协作的首选框架。它让多个AI智能体像人类团队一样协作,各司其职,共同完成复杂任务。随着Agent工作流和可观测性的增强,AutoGen正在从实验性框架走向生产级工具。 ...

2026-07-02 · 2 min · 419 words · 硅基 AGI 探索者
Agent监督者架构

Agent监督者架构:多智能体系统的质量控制层

引言 在多智能体系统中,每个Agent都可能犯错。当多个Agent协作时,错误会级联放大。如何在系统层面保证质量?答案就是监督者架构(Supervisor Architecture)。 监督者不是简单的"监工",而是一个集质量控制、冲突协调、资源管理于一体的系统层组件。2026年,随着多智能体系统规模扩大,监督者架构已经成为生产部署的必备组件。 一、监督者的角色定位 1.1 质量守门人 监督者对Agent的输出进行质量检查,只有通过标准的结果才能进入下一环节。这是最基础的监督角色。 1.2 冲突仲裁者 当多个Agent给出矛盾的结果时,监督者负责仲裁。例如,两个分析Agent对同一数据给出相反的结论,监督者需要判断哪个更可信。 1.3 资源调度者 监督者监控各Agent的资源使用情况,动态调整资源分配。当某个Agent过载时,可以将其部分任务转移给空闲Agent。 1.4 异常处理者 当Agent出现异常(超时、错误、异常行为)时,监督者负责处理。包括重试、降级、切换Agent或升级处理。 二、监督模式 2.1 事前监督 在Agent执行前审查计划: Worker Agent: 提交执行计划 Supervisor: 审查计划 → 计划合理: 批准执行 → 计划有问题: 要求修改 → 计划危险: 拒绝并报告 优势:防止错误发生,成本最低。 劣势:可能过度限制Agent的自主性,增加延迟。 2.2 事中监督 在Agent执行过程中实时监控: Worker Agent: 正在执行步骤3/10 Supervisor: 监控执行状态 → 正常: 继续 → 偏离: 发出警告 → 严重偏离: 中断执行 优势:及时发现问题,避免浪费。 劣势:需要实时监控,资源开销大。 2.3 事后监督 在Agent完成后审查结果: Worker Agent: 返回结果 Supervisor: 审查结果 → 质量达标: 接受 → 质量不达标: 要求重做 → 严重问题: 人工审核 优势:不影响执行过程,开销小。 劣势:发现问题晚,可能需要大量返工。 ...

2026-07-02 · 2 min · 280 words · 硅基 AGI 探索者
Agent通信协议设计

Agent间通信协议设计:从消息传递到语义协商

引言 如果将多智能体系统比作一个组织,那么通信协议就是这个组织的语言和规则。没有良好的通信协议,再强大的Agent也只能是信息孤岛。2026年,随着多智能体应用规模从几个扩展到几十个甚至上百个,通信协议设计已经成为系统成败的关键因素。 一、通信协议的层次模型 借鉴OSI七层模型的思想,我们将Agent通信协议分为四个层次: 1.1 传输层 负责消息的物理传递。2026年的主流选择包括: HTTP/2 + SSE:适合Web原生场景,支持流式输出 gRPC:高性能RPC框架,适合内部服务间通信 WebSocket:全双工通信,适合实时交互场景 Message Queue(Kafka/NATS):适合异步解耦场景 1.2 消息层 定义消息的封装格式。目前有三种主流格式: JSON:可读性好,生态丰富,但冗余度高。适合原型开发和小规模系统。 Protocol Buffers:二进制格式,高效紧凑。适合高性能场景和跨语言通信。 MessagePack:介于JSON和Protobuf之间,兼顾可读性和效率。 1.3 语义层 定义消息的含义和意图。这是Agent通信协议与传统分布式系统协议最大的区别。一条消息不仅包含数据,还包含发送者的意图、期望的回应类型和处理优先级。 1.4 会话层 管理Agent间的多轮交互。包括会话建立、维护、终止,以及会话状态的同步。 二、消息格式设计 一个好的Agent通信消息格式应该包含以下字段: { "message_id": "msg-uuid-001", "conversation_id": "conv-uuid-001", "from": { "agent_id": "researcher-01", "agent_type": "research_agent", "capabilities": ["web_search", "data_analysis"] }, "to": { "agent_id": "writer-01", "agent_type": "writing_agent", "capabilities": ["content_generation"] }, "intent": "request_review", "content": { "type": "document_draft", "data": "...", "metadata": { "word_count": 1500, "language": "zh-CN" } }, "expected_response": { "type": "review_feedback", "deadline": "2026-07-01T10:30:00Z" }, "priority": "normal", "requires_ack": true, "timestamp": "2026-07-01T10:00:00Z" } 关键设计决策 意图字段(intent):明确消息的目的,如request_info、provide_result、request_review、delegate_task等。这帮助接收方快速理解如何处理消息。 期望响应(expected_response):告知接收方应该返回什么类型的响应,降低误解概率。 能力声明(capabilities):发送方声明自己的能力,便于接收方判断是否需要转发给其他Agent。 三、通信模式 3.1 请求-响应 最基础的通信模式。Agent A向Agent B发送请求,B处理后返回响应。适用于同步、一对一的场景。 3.2 发布-订阅 Agent发布消息到主题,所有订阅该主题的Agent都能收到。适合一对多、解耦的场景。例如,一个Agent发布"新数据可用"事件,多个Agent各自处理。 ...

2026-07-02 · 1 min · 172 words · 硅基 AGI 探索者
多智能体编排架构

多智能体编排架构2026:从协作到自治的演进

引言 2026年,多智能体系统(Multi-Agent System, MAS)已经从实验室原型走向生产环境。从OpenAI的Swarm框架到Anthropic的Claude多智能体编排,再到开源社区的AutoGen、CrewAI和LangGraph,多智能体编排架构正在重新定义我们构建AI应用的方式。 本文将系统性地剖析多智能体编排架构的核心设计模式、协作机制、状态管理和生产化挑战。 一、编排范式:三种主流模式 1.1 中心化编排(Hub-and-Spoke) 中心化编排是最直观的模式:一个Supervisor Agent负责任务分解、分配和结果聚合。所有子Agent只与Supervisor通信,彼此之间不直接交互。 ┌─────────────┐ │ Supervisor │ └──────┬──────┘ ┌───┼───┐ ▼ ▼ ▼ A1 A2 A3 优势:控制流清晰,易于调试,状态一致性强。 劣势:Supervisor成为瓶颈和单点故障。当子Agent数量超过7个时,Supervisor的上下文窗口会迅速膨胀。 适用场景:工作流确定、子Agent数量少于7个的场景。典型的如研究报告生成:一个Research Agent收集资料,一个Writing Agent撰写内容,一个Review Agent审核质量。 1.2 去中心化编排(Mesh) 去中心化编排中,Agent之间直接通信,没有中心协调者。每个Agent自主决定何时与谁交互。 优势:高度灵活,无单点故障,可扩展性强。 劣势:调试困难,可能出现死锁或活锁,消息风暴风险。 适用场景:探索性任务、创意协作。例如多个Agent进行头脑风暴,每个Agent可以自由回应其他Agent的观点。 1.3 层级编排(Hierarchical) 层级编排结合了前两者的优点:顶层Supervisor管理中层Coordinator,中层Coordinator管理底层Worker Agent。 Supervisor / | \ Coord1 Coord2 Coord3 / \ | / \ W1 W2 W3 W4 W5 优势:可扩展性好(每层只管理少量下属),职责分离清晰。 劣势:延迟较高,信息在层级间传递可能失真。 适用场景:复杂的企业级任务,如软件开发流程:Supervisor负责任务规划,Coordinator分别管理前端、后端、测试,Worker Agent执行具体编码。 二、通信协议设计 多智能体编排的核心挑战之一是Agent间的通信设计。2026年的主流方案有以下几种: 2.1 结构化消息传递 使用JSON Schema定义消息格式,每条消息包含发送者、接收者、消息类型、载荷和元数据: ...

2026-07-02 · 1 min · 156 words · 硅基 AGI 探索者

多智能体协作 2026:从 LangGraph 到 CrewAI 的架构演进

引言 2026年,多智能体协作(Multi-Agent Collaboration)从概念验证走向大规模生产部署。不同的框架在架构设计、通信模式、编排能力上各有侧重。本文对比 LangGraph、CrewAI、AutoGen、MetaGPT 四大框架的核心差异。 四大框架架构对比 LangGraph:状态机驱动 LangGraph 的核心是"有状态的工作流"。它不预设智能体角色,而是让开发者自行定义状态流转图。 核心概念: Node:执行单元(可以是单个Agent或LLM调用) Edge:节点间的连接(条件边支持动态路由) State:节点间共享的状态对象 优势: 完全可控:开发者掌控每一步 循环和分支支持:天然支持迭代和条件逻辑 检查点机制:支持断点恢复 劣势: 学习曲线陡:需要理解图的状态机模型 无内置角色管理:角色定义需自行处理 CrewAI:角色驱动 CrewAI 的核心是"角色-任务-流程"模型。开发者定义智能体角色和任务,框架自动编排执行。 核心概念: Agent:具有角色、目标和工具的智能体 Task:可分配给Agent的具体任务 Crew:Agent和Task的集合 优势: 上手简单:角色定义直观 自动编排:框架处理任务分配 工具共享:Crew内Agent共享工具集 劣势: 编排灵活性有限:复杂流程需自定义 调试困难:自动编排的黑盒特性 AutoGen:对话驱动 AutoGen 由微软开发,核心是"多Agent对话"模式。智能体通过消息交换自主协商解决方案。 核心概念: ConversableAgent:可对话的智能体 GroupChat:多Agent群组讨论 AssistantAgent / UserProxyAgent:预设角色 优势: 自主协商:Agent可自主决定响应策略 灵活性强:对话模式天然支持复杂交互 代码执行:内置代码执行能力 劣势: 不可预测性:对话过程难以完全控制 调试困难:多轮对话的追踪复杂 MetaGPT:流程驱动 MetaGPT 的核心是"模拟软件公司"的理念。它预定义了产品经理、架构师、工程师等角色和标准流程。 核心概念: 预定义角色:PM、Architect、Engineer、QA SOP流程:标准操作流程 知识复用:任务间的知识传递 优势: 开箱即用:预设角色和流程 高质量输出:流程化保证质量 可解释性:每步都有明确角色 劣势: 灵活性最低:仅适用于特定场景 角色固定:难以自定义角色 选型指南 场景 推荐框架 理由 复杂工作流 LangGraph 状态机模型灵活可控 快速原型 CrewAI 角色定义简单直观 自主协商 AutoGen 对话模式支持动态决策 软件工程 MetaGPT 预设角色和流程 生产部署 LangGraph 检查点和状态管理完善 多智能体通信模式 1. 同步通信 Agent之间直接调用,类似函数调用。 ...

2026-06-30 · 1 min · 141 words · 硅基 AGI 探索者
multi agent collaboration patterns

多智能体协作模式:从层级到对等网络

从单兵作战到群体智能 单个智能体的能力再强,也有其认知边界。当任务的复杂度超过单个智能体的处理能力时,多智能体协作就成为一种必然选择。2026 年的 AGI 领域,多智能体系统(MAS)已经从学术研究走向工程实践,AutoGen、CrewAI、LangGraph 等框架的成熟使得构建多智能体系统变得越来越便捷。 但"多个智能体一起工作"远比想象中复杂。如何分工?如何通信?如何处理分歧?如何避免死循环?这些问题的答案,构成了多智能体协作模式的核心设计空间。 一、协作模式分类框架 在深入具体模式之前,我们需要一个分类框架来理解多智能体协作的设计空间。我从两个维度来划分: 控制结构维度: 中心化(有明确的领导者) 去中心化(无明确领导者) 通信拓扑维度: 层级式(树状结构) 总线式(共享黑板) 对等式(网状结构) 环式(链式传递) 这两个维度的组合,产生了实践中最常见的几种协作模式。 二、层级式协作:指挥官与士兵 2.1 基本结构 层级式是最直观的多智能体协作模式。一个"编排者"(Orchestrator)智能体位于顶层,负责理解任务、分解子任务、分配给下游智能体,并汇总结果。 [编排者智能体] / | \ [研究智能体] [编码智能体] [测试智能体] 2.2 实现示例 以 AutoGen 为例,一个典型的层级式协作: import autogen # 配置模型 config_list = [{ "model": "gpt-4", "api_key": "your-api-key" }] # 创建编排者 orchestrator = autogen.AssistantAgent( name="编排者", system_message="""你是项目编排者。职责: 1. 理解用户需求 2. 将需求分解为子任务 3. 分配给合适的专家智能体 4. 汇总结果并确保质量 可用的专家: - 研究员:负责信息搜集和调研 - 工程师:负责代码编写 - 测试员:负责代码测试 请用以下格式分配任务: [TO: 专家名] 任务描述""", llm_config={"config_list": config_list} ) # 创建专家智能体 researcher = autogen.AssistantAgent( name="研究员", system_message="你是研究专家。接收编排者的任务,进行信息搜集和分析。", llm_config={"config_list": config_list} ) engineer = autogen.AssistantAgent( name="工程师", system_message="你是资深工程师。接收编排者的任务,编写高质量代码。", llm_config={"config_list": config_list} ) tester = autogen.AssistantAgent( name="测试员", system_message="你是测试工程师。接收编排者的任务,编写和执行测试。", llm_config={"config_list": config_list} ) # 用户代理 user_proxy = autogen.UserProxyAgent( name="用户", human_input_mode="NEVER", max_consecutive_auto_reply=10 ) # 建立群聊 groupchat = autogen.GroupChat( agents=[user_proxy, orchestrator, researcher, engineer, tester], messages=[], max_round=30 ) manager = autogen.GroupChatManager( groupchat=groupchat, llm_config={"config_list": config_list} ) # 启动协作 user_proxy.initiate_chat( manager, message="开发一个 Python 命令行工具,可以统计指定目录下各类文件的数量。" ) 2.3 层级式的优劣 优势: ...

2026-06-26 · 5 min · 944 words · 硅基 AGI 探索者
autogen multi agent

AutoGen 多智能体框架:从对话到协作

引言:为什么需要多智能体? 单一 AI Agent 的能力是有限的——一个 Agent 难以同时扮演产品经理、开发者和测试工程师的角色。微软 AutoGen 框架的核心思想是:让多个专业化 Agent 协作完成复杂任务,就像一个高效的团队一样。 AutoGen 核心架构 框架层次 ┌─────────────────────────────────┐ │ Application Layer │ │ (User Interface / API) │ ├─────────────────────────────────┤ │ Orchestration Layer │ │ ┌───────────┐ ┌────────────┐ │ │ │ Group Chat│ │ Workflow │ │ │ │ Manager │ │ Engine │ │ │ └───────────┘ └────────────┘ │ ├─────────────────────────────────┤ │ Agent Layer │ │ AssistantAgent│UserProxyAgent│ │ MultimodalAgent│CustomAgent │ ├─────────────────────────────────┤ │ Communication Layer │ │ Message Queue │ Event Bus │ ├─────────────────────────────────┤ │ Model Layer │ │ OpenAI │ Azure │ Local Models │ └─────────────────────────────────┘ Agent 类型 Agent 类型 职责 典型场景 AssistantAgent 执行任务、生成内容 编码、分析、写作 UserProxyAgent 代理用户行为 执行代码、提供反馈 GroupChatManager 管理多 Agent 对话 团队协作场景 MultimodalAgent 处理图像等多模态输入 视觉分析任务 CustomAgent 用户自定义 Agent 特殊业务逻辑 快速上手 安装与基础配置 # 安装 AutoGen # pip install autogen-agentchat autogen-ext import asyncio from autogen_agentchat.agents import AssistantAgent from autogen_agentchat.teams import RoundRobinGroupChat from autogen_agentchat.conditions import TextMentionTermination from autogen_ext.models.openai import OpenAIChatCompletionClient # 配置模型 model_client = OpenAIChatCompletionClient( model="gpt-5", api_key="your-api-key", # Azure OpenAI 配置 # base_url="https://your-resource.openai.azure.com", # api_version="2026-03-01-preview", ) 创建第一个多 Agent 团队 # 创建专业化的 Agent 团队 product_manager = AssistantAgent( name="ProductManager", model_client=model_client, system_message=""" 你是一个产品经理。你的职责: 1. 理解用户需求 2. 将需求拆解为具体的功能点 3. 定义验收标准 不要写代码,专注于需求分析。 当需求分析完成时,说"需求已明确,请开发人员开始实现"。 """, ) developer = AssistantAgent( name="Developer", model_client=model_client, system_message=""" 你是一个高级 Python 开发者。你的职责: 1. 根据产品经理的需求编写代码 2. 确保代码质量(类型标注、错误处理) 3. 编写单元测试 写完代码后,说"代码已完成,请测试人员审查"。 """, # 可以执行代码 reflect_on_tool_history=True, ) tester = AssistantAgent( name="Tester", model_client=model_client, system_message=""" 你是一个 QA 测试工程师。你的职责: 1. 审查代码的逻辑正确性 2. 检查边界条件和错误处理 3. 提出改进建议 审查完成后,说"APPROVED"表示通过,或指出需要修改的问题。 """, ) # 创建团队(轮询模式) team = RoundRobinGroupChat( participants=[product_manager, developer, tester], termination_condition=TextMentionTermination("APPROVED"), max_turns=20, ) # 执行任务 async def main(): result = await team.run( task="实现一个函数,接收日期字符串,返回该日期是星期几," "支持多种日期格式输入" ) print(result) asyncio.run(main()) 高级:工作流编排 自定义工作流 from autogen_agentchat.teams import SelectorGroupChat from autogen_agentchat.conditions import MaxMessageTermination # 使用智能选择器(Selector)模式 # 由一个"管理者"Agent 决定下一个发言者 team = SelectorGroupChat( participants=[product_manager, developer, tester], model_client=model_client, # 用于选择发言者 selector_prompt=""" 你是一个团队协调者。根据当前对话状态, 选择下一个应该发言的团队成员。 可选成员:{participants} 对话历史:{history} 返回下一个发言者的名字。 """, termination_condition=MaxMessageTermination(30), allow_repeated_speaker=False, # 同一成员不能连续发言 ) # 带工具的工作流 async def run_with_tools(): # 给 Developer 添加代码执行工具 from autogen_ext.tools.code import PythonCodeExecutionTool code_executor = PythonCodeExecutionTool( timeout=30, work_dir="./workspace", ) developer_with_tools = AssistantAgent( name="Developer", model_client=model_client, tools=[code_executor], system_message="写完代码后用工具执行验证。", ) team = RoundRobinGroupChat( participants=[product_manager, developer_with_tools, tester], max_turns=15, ) result = await team.run(task="实现并验证一个快速排序算法") return result DAG 工作流 from autogen_agentchat.teams import GraphWorkflow from autogen_agentchat.graph import Graph, Node, Edge # 定义有向无环图工作流 async def build_research_workflow(): # 创建专业化 Agent researcher = AssistantAgent( name="Researcher", model_client=model_client, system_message="你是一个研究员,负责搜索和整理信息。", ) analyst = AssistantAgent( name="Analyst", model_client=model_client, system_message="你是一个分析师,负责分析数据并得出结论。", ) writer = AssistantAgent( name="Writer", model_client=model_client, system_message="你是一个技术写作专家,负责撰写报告。", ) reviewer = AssistantAgent( name="Reviewer", model_client=model_client, system_message="你是审稿人,负责审核报告质量。", ) # 构建工作流图 graph = Graph() # 添加节点 graph.add_node(Node("research", researcher)) graph.add_node(Node("analyze", analyst)) graph.add_node(Node("write", writer)) graph.add_node(Node("review", reviewer)) # 添加边(定义执行顺序) graph.add_edge(Edge("research", "analyze")) graph.add_edge(Edge("analyze", "write")) graph.add_edge(Edge("write", "review")) # 审核不通过可以回退 graph.add_edge(Edge("review", "write", condition="needs_revision")) workflow = GraphWorkflow(graph=graph) result = await workflow.run( task="研究 2026 年 AI 编程助手市场格局并撰写分析报告" ) return result 通信与消息传递 消息结构 # AutoGen 的消息结构 from autogen_agentchat.messages import TextMessage, MultiModalMessage # 文本消息 text_msg = TextMessage( source="Developer", content="我已经实现了用户认证模块,请审查。", metadata={"timestamp": "2026-06-25T10:00:00Z"} ) # 多模态消息(包含图片) multimodal_msg = MultiModalMessage( source="Tester", content=[ "测试结果截图如下:", Image.from_file("test-results.png"), ] ) 自定义通信协议 from autogen_core import MessageContext, RoutedAgent, message_handler class TaskMessage: def __init__(self, content: str, priority: int = 0): self.content = content self.priority = priority class ResultMessage: def __init__(self, content: str, status: str): self.content = content self.status = status class CustomWorkerAgent(RoutedAgent): def __init__(self, model_client): super().__init__("Worker") self.model_client = model_client self._history = [] @message_handler async def handle_task(self, message: TaskMessage, ctx: MessageContext) -> ResultMessage: # 处理任务 self._history.append(message.content) response = await self.model_client.create( messages=[{"role": "user", "content": message.content}] ) return ResultMessage( content=response.content, status="completed" ) 状态管理与持久化 from autogen_core import CancellationToken import json import os class CheckpointManager: """Agent 会话状态持久化""" def __init__(self, checkpoint_dir: str = "./checkpoints"): self.checkpoint_dir = checkpoint_dir os.makedirs(checkpoint_dir, exist_ok=True) async def save(self, team, task_id: str): """保存团队状态""" state = await team.save_state() path = os.path.join(self.checkpoint_dir, f"{task_id}.json") with open(path, "w") as f: json.dump(state, f, ensure_ascii=False, indent=2) async def load(self, team, task_id: str): """恢复团队状态""" path = os.path.join(self.checkpoint_dir, f"{task_id}.json") if os.path.exists(path): with open(path) as f: state = json.load(f) await team.load_state(state) return True return False # 使用示例 checkpoint = CheckpointManager() # 保存中断的会话 await checkpoint.save(team, "task-001") # 恢复会话 await checkpoint.load(team, "task-001") result = await team.run(task="继续之前的任务") 性能优化 并行 Agent 执行 from autogen_agentchat.teams import ConcurrentGroupChat # 并行执行模式:多个 Agent 同时工作 concurrent_team = ConcurrentGroupChat( participants=[researcher, data_analyst, market_analyst], model_client=model_client, aggregation_strategy="merge", # merge | select | vote max_turns=10, ) # 三个 Agent 并行研究不同方面,然后合并结果 result = await concurrent_team.run( task="分析竞品:研究员查技术栈,数据分析师查性能指标,市场分析师查市场份额" ) 性能对比 模式 Agent 数量 平均耗时 Token 消耗 适用场景 单 Agent 1 15s ~5K 简单任务 轮询模式 3 45s ~15K 流程化任务 选择器模式 3 35s ~12K 灵活协作 并行模式 3 20s ~18K 独立子任务 DAG 工作流 4 60s ~20K 复杂流水线 生产部署 Docker 容器化 # Dockerfile FROM python:3.12-slim WORKDIR /app # 安装依赖 COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt # 复制代码 COPY . . # 启动 Agent 服务 CMD ["python", "-m", "autogen_server", "--host", "0.0.0.0", "--port", "8080"] # requirements.txt autogen-agentchat>=0.5.0 autogen-ext[openai,azure]>=0.5.0 fastapi>=0.115.0 uvicorn>=0.30.0 API 服务封装 from fastapi import FastAPI, BackgroundTasks from pydantic import BaseModel app = FastAPI(title="AutoGen Agent Service") class TaskRequest(BaseModel): task: str team_config: dict = {} max_turns: int = 20 class TaskResponse(BaseModel): task_id: str status: str result: str | None = None @app.post("/tasks", response_model=TaskResponse) async def create_task(req: TaskRequest, bg: BackgroundTasks): task_id = generate_task_id() # 异步执行 bg.add_task(run_agent_team, task_id, req.task, req.team_config) return TaskResponse(task_id=task_id, status="running") @app.get("/tasks/{task_id}", response_model=TaskResponse) async def get_task(task_id: str): status, result = await get_task_status(task_id) return TaskResponse(task_id=task_id, status=status, result=result) 竞品对比 特性 AutoGen CrewAI LangGraph 开发者 微软 CrewAI LangChain Agent 通信 消息传递 角色对话 图状态 工作流 轮询/选择器/DAG 顺序/层次 自定义图 代码执行 内置 内置 需集成 状态持久化 ✅ ✅ ✅ 多模态 ✅ 有限 ✅ 生态整合 Azure/M365 Zapier LangChain 结语 AutoGen 是目前功能最全面的多智能体框架之一。它提供了从简单对话到复杂工作流的完整工具链,适合构建生产级的多 Agent 系统。其微软生态整合使其在企业场景中具有天然优势,但学习曲线相对陡峭。 ...

2026-06-25 · 5 min · 884 words · 硅基 AGI 探索者
multi agent orchestration

多智能体编排架构:从中心化到去中心化的设计模式

1. 引言:为什么需要多智能体编排 单个 LLM Agent 在复杂任务中面临上下文窗口限制、角色混淆、推理链断裂等问题。多智能体架构通过任务分解、角色专精和协作机制,将复杂问题分配给多个专业化 Agent 协同完成。然而,如何编排这些 Agent——谁来调度、如何通信、何时同步——是工程落地的核心挑战。 2. 三种核心编排模式 2.1 中心化编排(Orchestrator Pattern) 一个中央编排器(Orchestrator)负责任务分配、状态管理和结果汇总。所有 Agent 只与编排器通信,互不直接交互。 ┌──────────────────────────────────┐ │ Orchestrator │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │Worker│ │Worker│ │Worker│ │ │ │ A │ │ B │ │ C │ │ │ └──────┘ └──────┘ └──────┘ │ └──────────────────────────────────┘ 核心代码实现: from abc import ABC, abstractmethod from typing import Any, Optional import asyncio class Agent(ABC): def __init__(self, name: str, system_prompt: str): self.name = name self.system_prompt = system_prompt self.message_history: list[dict] = [] @abstractmethod async def execute(self, task: str, context: dict) -> str: pass class Orchestrator: def __init__(self): self.agents: dict[str, Agent] = {} self.task_queue: list[dict] = [] self.results: dict[str, Any] = {} def register(self, agent: Agent): self.agents[agent.name] = agent async def dispatch(self, agent_name: str, task: str, context: dict = None) -> str: agent = self.agents[agent_name] result = await agent.execute(task, context or {}) self.results[f"{agent_name}:{task[:20]}"] = result return result async def run_pipeline(self, plan: list[dict]) -> dict: """按计划顺序执行任务,支持依赖传递""" for step in plan: agent_name = step["agent"] task = step["task"] deps = step.get("depends_on", []) merged_context = {d: self.results.get(d) for d in deps} await self.dispatch(agent_name, task, merged_context) return self.results 适用场景: 工作流明确的任务(如代码审查流水线、文档生成管线) ...

2026-06-25 · 5 min · 936 words · 硅基 AGI 探索者
autogen multi agent review

AutoGen 多智能体框架评测:微软的 Agent 雄心

AutoGen 概述 AutoGen 是微软推出的多智能体(Multi-Agent)框架,目标是让开发者能快速搭建多个 AI Agent 协作完成复杂任务。2025 年发布的 v0.4 是完全重写版本(也叫 AG2),架构设计全面升级。 v0.4 核心变化 维度 v0.3 (旧) v0.4 (新) 架构 扁平、耦合 分层、事件驱动 异步 ❌ ✅ 原生 asyncio 消息传递 直接调用 事件总线 Agent 通信 硬编码 可扩展通信协议 可观测性 基本日志 OpenTelemetry 集成 跨语言 Python only Python + .NET 扩展性 中 高(插件架构) 架构解析 事件驱动模型 ┌─────────────────────────────────────────┐ │ Runtime │ │ ┌──────────────────────────────────┐ │ │ │ Event Bus │ │ │ │ (消息路由、订阅/发布) │ │ │ └──────┬─────┬─────┬─────┬─────────┘ │ │ │ │ │ │ │ │ ┌────┴──┐ ┌┴────┐ ┌┴────┐ ┌┴──────┐ │ │ │Agent A│ │Agent B│ │Agent C│ │Tool │ │ │ │(Writer)│ │(Reviewer)│ │(Coder)│ │Agent │ │ │ └───────┘ └──────┘ └──────┘ └───────┘ │ │ │ │ ┌──────────────────────────────────┐ │ │ │ Model Client Layer │ │ │ │ (OpenAI / Azure / Ollama / ...) │ │ │ └──────────────────────────────────┘ │ └─────────────────────────────────────────┘ 所有 Agent 间通信通过事件总线,Agent 之间完全解耦。这意味着可以灵活替换、增删 Agent 而不影响其他部分。 ...

2026-06-24 · 3 min · 569 words · 硅基 AGI 探索者
鲁ICP备2026018361号