AutoGen 框架：微软的多 Agent 对话系统

AutoGen 是微软研究院推出的多 Agent 框架，其核心理念与 LangChain 或 LlamaIndex 都有本质区别：后两者的 Agent 是"工具调用循环"，而 AutoGen 的 Agent 是"通过对话协作完成任务"。

在 AutoGen 的模型中，每个 Agent 既是消息的发送方，也是消息的接收方。任务的执行过程就是 Agent 之间互发消息、相互响应、逐步推进的过程。这种模型在代码生成、数学推理等需要反复验证和迭代的任务上有天然优势。

1. 核心概念

AutoGen多Agent对话架构图
AutoGen 多 Agent 对话架构 — 两人对话模式与 GroupChat 群聊模式

ConversableAgent：AutoGen 中所有 Agent 的基类。任何 Agent 都能发起对话、接收消息，以及决定是否继续对话还是终止。所有高级 Agent 类型都继承自它。

AssistantAgent：代表 AI 助手角色。默认使用 LLM 生成回复，能够编写代码、分析问题、给出建议。不会主动执行代码——它只生成代码文本，执行的工作由另一方完成。

UserProxyAgent：代理用户角色。主要职责是执行代码并反馈结果。内置代码执行沙箱，可以在本地、Docker 容器或远程环境中安全运行代码。当代码出错时，它会把错误信息原封不动地返回给 AssistantAgent，让对方修正。

GroupChat：多 Agent 群聊模式。多个 Agent 加入同一个聊天室，由 GroupChatManager 负责协调发言顺序，每轮由 LLM 判断下一个应该发言的 Agent。

2. 对话模式：两人对话 vs 群聊

AutoGen 支持两种基本的对话模式，适用于不同复杂度的任务。

2.1. 两人对话

最基础的模式。一个 AssistantAgent 和一个 UserProxyAgent 轮流发言，直到任务完成或达到最大轮次。

python

import autogen

# LLM 配置，支持 OpenAI、Azure OpenAI、本地模型等
config_list = [
    {
        "model": "gpt-4o",
        "api_key": "your-api-key",
    }
]

# AssistantAgent：使用 LLM 生成回复
# system_message 定义 Agent 的角色和行为准则
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list, "temperature": 0},
    system_message=(
        "你是一个专业的 Python 数据分析专家。"
        "编写的代码必须包含必要的注释，并在最后打印出结论。"
        "如果代码执行出错，请分析错误原因并修正。"
    ),
)

# UserProxyAgent：执行代码并返回结果
# human_input_mode="NEVER" 表示全自动，不需要人工干预
# code_execution_config 配置代码执行环境
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10,  # 最多自动回复 10 次，防止无限循环
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={
        "work_dir": "workspace",     # 代码执行的工作目录
        "use_docker": False,         # 本地执行，无需 Docker
        "timeout": 60,               # 单次执行超时时间（秒）
    },
)

# 发起对话，user_proxy 把任务传给 assistant
user_proxy.initiate_chat(
    assistant,
    message=(
        "分析 titanic.csv 数据集，计算不同舱位（Pclass）的生存率，"
        "并用文字描述分析结论。"
    ),
)

典型的对话轮次如下：

UserProxy → Assistant："分析 titanic.csv..."
Assistant → UserProxy："（生成分析代码）"
UserProxy 执行代码，得到结果
UserProxy → Assistant："代码执行结果：头等舱生存率 62%，..."
Assistant → UserProxy："分析完成。一等舱生存率最高（62%），..."，末尾附 TERMINATE
对话终止

2.2. 群聊模式

当任务需要多种专业角色参与时，GroupChat 允许多个 Agent 在同一个对话中轮流发言，每个 Agent 负责自己擅长的部分。

python

import autogen

config_list = [{"model": "gpt-4o", "api_key": "your-api-key"}]
llm_config = {"config_list": config_list, "temperature": 0}

# 三个专业角色
coder = autogen.AssistantAgent(
    name="coder",
    llm_config=llm_config,
    system_message=(
        "你是一个 Python 专家，负责编写高质量的数据处理和分析代码。"
        "代码需要包含错误处理和清晰的注释。"
        "只编写代码，不做其他分析。"
    ),
)

reviewer = autogen.AssistantAgent(
    name="reviewer",
    llm_config=llm_config,
    system_message=(
        "你是一个代码审查专家，负责检查代码的正确性、可读性和安全性。"
        "发现问题时，明确指出具体位置和改进建议。"
        "如果代码没有问题，说'代码审查通过'。"
    ),
)

analyst = autogen.AssistantAgent(
    name="analyst",
    llm_config=llm_config,
    system_message=(
        "你是一个数据分析师，负责解读代码执行结果，提供业务层面的洞察。"
        "用非技术语言描述数据中发现的规律和建议。"
    ),
)

# UserProxyAgent 负责执行代码
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": False,
    },
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
)

# 创建群聊，定义参与者和最大轮次
groupchat = autogen.GroupChat(
    agents=[user_proxy, coder, reviewer, analyst],
    messages=[],
    max_round=20,
    # speaker_selection_method="auto" 让 LLM 决定下一个发言者
    # 也可以用 "round_robin" 轮流发言
    speaker_selection_method="auto",
)

# GroupChatManager 负责协调群聊，本身也使用 LLM
manager = autogen.GroupChatManager(
    groupchat=groupchat,
    llm_config=llm_config,
)

# 发起群聊
user_proxy.initiate_chat(
    manager,
    message=(
        "对 sales_2024.csv 进行月度销售额分析："
        "1. 计算每月销售总额；"
        "2. 找出销售额最高和最低的月份；"
        "3. 计算环比增长率；"
        "4. 提供业务建议。"
    ),
)

3. AutoGen 内置代码执行沙箱

沙箱（Sandbox）：一个与外部系统隔离的安全执行环境，AI 生成的代码在其中运行，即使代码有问题也不会影响真实文件或系统。

AutoGen 的代码执行是其核心差异化特性之一。它内置了一套完整的代码提取和执行机制：自动从 LLM 的回复中提取代码块，在指定的工作目录中执行，捕获 stdout/stderr（标准输出/标准错误：程序运行时打印信息和错误信息的两个输出通道）输出和异常，将完整的执行结果反馈给 LLM。

python

# Docker 模式：更安全，适合生产环境
# Docker：一种将程序及其依赖打包在隔离容器中运行的技术，即使代码出错也不会影响宿主机
user_proxy_docker = autogen.UserProxyAgent(
    name="secure_executor",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": "python:3.11-slim",  # 使用 Docker 隔离执行环境
        "timeout": 120,
    },
)

# 自定义代码执行器：限制可用模块
from autogen.coding import LocalCommandLineCodeExecutor

executor = LocalCommandLineCodeExecutor(
    work_dir="workspace",
    timeout=60,
    # 限制只能使用安全的模块，防止恶意代码
    functions=[],
)

user_proxy_custom = autogen.ConversableAgent(
    name="custom_executor",
    code_execution_config={"executor": executor},
    human_input_mode="NEVER",
)

4. 与 CrewAI、LangGraph 的对比

AutoGen、CrewAI（角色协作式多 Agent 框架：预先给每个 Agent 分配固定角色和任务，按流水线顺序协作）和 LangGraph 都是多 Agent 框架，但设计理念差异明显。

维度	AutoGen	CrewAI	LangGraph
核心比喻	会议室讨论	专业团队分工	有向图工作流
任务分配	Agent 之间自由对话	预先定义角色和任务	图节点和边定义流程
执行控制	较弱，自然语言驱动	中等，角色约束	强，精确可预测
代码执行	内置，一流支持	需要自定义工具	需要自定义节点
调试难度	较难，对话不可预测	中等	容易，流程图清晰
适用场景	代码生成、数学推理	内容创作、研究流程	生产级可控工作流

AutoGen 的优势在于： 代码生成和自动调试是它的设计出发点。两个 Agent 相互交错验证（写代码→执行→看结果→修改）的工作流，在 AutoGen 中几乎不需要额外编码，是最自然的使用方式。

AutoGen 的劣势在于： 执行路径依赖 LLM 的判断，难以完全预测。当需要"必须按照 A→B→C 的顺序执行，中间不能跳步"这类严格控制时，LangGraph 更合适。

5. 完整示例：两 Agent 协作数据分析

以下是一个完整可运行的示例，演示 AssistantAgent 和 UserProxyAgent 协作完成数据分析任务，包含任务分配、代码执行、结果验证的完整闭环。

python

import autogen
import os

# 确保工作目录存在
os.makedirs("workspace", exist_ok=True)

# 准备一个简单的 CSV 数据文件用于测试
with open("workspace/sales.csv", "w") as f:
    f.write("month,product,revenue,units\n")
    f.write("2024-01,A,50000,100\n")
    f.write("2024-01,B,30000,60\n")
    f.write("2024-02,A,55000,110\n")
    f.write("2024-02,B,28000,56\n")
    f.write("2024-03,A,60000,120\n")
    f.write("2024-03,B,35000,70\n")
    f.write("2024-04,A,45000,90\n")
    f.write("2024-04,B,40000,80\n")

config_list = [
    {
        "model": "gpt-4o-mini",
        "api_key": os.environ.get("OPENAI_API_KEY"),
    }
]

# 数据分析师 Agent：只负责分析，不执行代码
data_analyst = autogen.AssistantAgent(
    name="data_analyst",
    llm_config={
        "config_list": config_list,
        "temperature": 0,
        # seed 让输出更稳定，便于测试和调试
        "seed": 42,
    },
    system_message="""你是一个专业的数据分析师。
    任务完成时，在回复末尾加上 TERMINATE。
    编写的 Python 代码需要使用 pandas 和 matplotlib。
    所有图表保存为 PNG 文件，不要调用 plt.show()。
    最后必须用文字总结关键发现。""",
)

# 代码执行器 Agent：负责执行代码、返回结果
executor = autogen.UserProxyAgent(
    name="executor",
    human_input_mode="NEVER",
    # 当检测到 TERMINATE 时结束对话
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": False,
        "timeout": 60,
    },
    # 不使用 LLM，只负责执行代码和返回结果
    llm_config=False,
)

# 发起分析任务
chat_result = executor.initiate_chat(
    data_analyst,
    message="""请分析 sales.csv 数据：
    1. 按月计算总销售额，找出最高月份
    2. 计算 A 和 B 产品各自的总收入占比
    3. 分析月度销售额的趋势
    4. 生成销售额趋势折线图，保存为 sales_trend.png
    """,
)

# 查看对话摘要
print("\n=== 对话完成 ===")
print(f"总轮次：{len(chat_result.chat_history)}")
print(f"最终答案：{chat_result.summary}")

6. 适用场景与注意事项

AutoGen 最适合以下场景：

代码生成与调试： 让 AssistantAgent 生成代码，UserProxyAgent 执行并反馈，自动修复错误。这是 AutoGen 设计的核心场景，几乎不需要额外配置。

数学推理与验证： 推理过程写成代码执行，用计算结果验证推理是否正确，比纯文字推理更可靠。

多角色内容生产： 写作 Agent 起草、审查 Agent 批注、修改 Agent 修改，轮流迭代，适合需要多轮打磨的内容任务。

注意事项：

对话轮次控制：max_consecutive_auto_reply 和 max_round 必须设置，否则可能出现无限循环，产生大量 API 消耗
终止条件：明确定义 is_termination_msg，让 Agent 知道何时结束任务
Token 成本：每一轮对话都会将完整的对话历史传入 LLM，随着轮次增加，Token 消耗快速增长
生产稳定性：自然语言驱动的执行路径存在不确定性，对稳定性要求高的场景建议使用 LangGraph

小结： AutoGen 把"写代码→执行→验证→修改"这个迭代循环自动化了。两 Agent 协作模式适合大多数代码生成任务，GroupChat 适合多角色的复杂任务。和 CrewAI、LangGraph 的定位差异搞清楚，选型就不难了。