1
2
3
4
5
6

timeline
    title AutoGen 演进与分化历史脉络
    2023年下半年 : 微软开源 AutoGen (v0.1 / v0.2) : "ConversableAgent" 奠定对话协作范式 : PyPI 注册 pyautogen
    2024年中期 : AutoGen Studio 诞生 : 引入低代码 Web 界面原型调试 : 社区生态爆炸式增长
    2024年底 : 治理与技术路线大分流 : 创始人团队推出 AG2 保持兼容 : 微软启动 v0.4 底层异步 Actor 重构
    2025年 - 2026年 : 微软统一生态 : AutoGen v0.4 融入 Microsoft Agent Framework : Magentic-One 确立复杂任务工业标杆

1
2
3
4
5
6
7
8
9

flowchart LR
    User([人类用户 / 触发器]) -->|发包任务| Proxy[UserProxyAgent]
    Proxy -->|请求解决方案| Coder[Coder Agent]
    Coder -->|返回代码块| Proxy
    Proxy -->|沙箱执行代码| Runner[(Code Runner / Docker)]
    Runner -->|输出运行日志/报错| Proxy
    Proxy -->|反馈报错| Coder
    Coder -->|修复代码| Proxy
    Proxy -->|运行成功，产出成果| User

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

+---------------------------------------------------------------------------------+
|                                 Extensions Layer                                |
|                                  (autogen-ext)                                  |
|   - 模型客户端: OpenAI, Azure OpenAI, Anthropic, Gemini, Ollama, LiteLLM        |
|   - 代码沙箱: DockerCommandLineCodeExecutor, LocalCommandLineCodeExecutor        |
|   - 向量检索与缓存: Qdrant, Chroma, Redis                                        |
+---------------------------------------------------------------------------------+
                                         ▲
                                         │  集成插件与服务
+---------------------------------------------------------------------------------+
|                                 AgentChat Layer                                 |
|                               (autogen-agentchat)                               |
|   - 智能体定义: AssistantAgent, CodeExecutorAgent, UserProxyAgent               |
|   - 协作拓扑: RoundRobinGroupChat, SelectorGroupChat, Swarm                     |
|   - 控制原语: TerminationConditions (AND / OR / Regex), Console UI 实时流        |
+---------------------------------------------------------------------------------+
                                         ▲
                                         │  构建于运行时之上
+---------------------------------------------------------------------------------+
|                                   Core Layer                                    |
|                                 (autogen-core)                                  |
|   - Actor Runtime: AgentId, SingleThreadedAgentRuntime, 消息总线路由           |
|   - 事件驱动基石: 强类型消息（Typed Message Handler）、订阅与广播机制            |
|   - 状态追踪与可观测性: OpenTelemetry 分布式跟踪, 上下文生命周期管理                |
+---------------------------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

classDiagram
    class Agent {
        +String name
        +String description
        +on_messages()
    }
    class AssistantAgent {
        +ChatCompletionClient model_client
        +String system_message
        +List~Tool~ tools
        +generate_reply()
    }
    class CodeExecutorAgent {
        +CodeExecutor code_executor
        +execute_code_blocks()
    }
    class UserProxyAgent {
        +HumanInputMode input_mode
        +get_human_input()
    }

    Agent <|-- AssistantAgent
    Agent <|-- CodeExecutorAgent
    Agent <|-- UserProxyAgent

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

flowchart TD
    subgraph 模式A: 轮询协作 (RoundRobin)
        A1[Agent 1] --> A2[Agent 2] --> A3[Agent 3] --> A1
    end

    subgraph 模式B: 动态选择器 (SelectorGroupChat)
        M[Selector / Router]
        M -->|1. 分析上下文| B1[Planner]
        M -->|2. 调度执行| B2[Coder]
        M -->|3. 调度校验| B3[Reviewer]
        B1 -.->|返回结果| M
        B2 -.->|返回结果| M
        B3 -.->|返回结果| M
    end

    subgraph 模式C: 蜂群交接 (Swarm / Handoffs)
        S1[FrontDesk] -->|Handoff: 账务问题| S2[BillingAgent]
        S1 -->|Handoff: 技术故障| S3[TechSupport]
        S3 -->|Handoff: 需要退款| S2
    end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

graph TD
    User([用户高维任务目标]) --> Orchestrator
    
    subgraph Magentic-One 编排中枢
        Orchestrator[Orchestrator 核心调度器]
        TaskLedger[(Task Ledger 任务总账本\n事实 / 猜测 / 宏观计划)]
        ProgressLedger[(Progress Ledger 进度账本\n当前步骤 / 评估 / 下一步决策)]
        Orchestrator <--> TaskLedger
        Orchestrator <--> ProgressLedger
    end

    subgraph 领域专家 Worker 矩阵
        WebSurfer[MultimodalWebSurfer\n基于 Chromium 视觉驱动网页浏览]
        FileSurfer[FileSurfer\n深度探索与解析本地文件系统]
        Coder[Coder\n编写并审查高质量 Python 脚本]
        Terminal[ComputerTerminal\n安全沙箱命令与脚本执行环境]
    end

    Orchestrator -->|调度与分发| WebSurfer
    Orchestrator -->|调度与分发| FileSurfer
    Orchestrator -->|调度与分发| Coder
    Orchestrator -->|调度与分发| Terminal

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

[智能体产出 Markdown 文本]
           │
           ▼
[代码提取器识别 ```python ... ``` 块]
           │
           ▼
┌─────────────────────────────────────────────────────────────┐
│                    执行器选择 (Code Executor)                │
├──────────────────────────────┬──────────────────────────────┤
│  LocalCommandLineCodeExecutor│ DockerCommandLineCodeExecutor│
│  - 本地宿主机进程环境运行    │ - 容器安全隔离               │
│  - 响应速度快，开箱即用      │ - 避免删库/注入攻击风险      │
│  - 仅推荐本地测试调试        │ - 企业级生产环境强制规范     │
└──────────────────────────────┴──────────────────────────────┘
           │
           ▼
[捕获返回 Exit Code, STDOUT, STDERR]
           │
           ▼
[作为消息重注入会话，由 Agent 评估或自我修复]

1
2
3
4
5
6

graph LR
    subgraph AutoGen Studio Web 架构
        UI[现代 Web 前端\nReact / Next.js] <---> API[FastAPI 后端服务]
        API <---> ORM[SQLModel / SQLAlchemy\nSQLite, PostgreSQL]
        API <---> Engine[AutoGen v0.4 AgentChat Engine]
    end

1
2
3
4
5
6
7
8

# 1. 安装 AutoGen Studio
pip install autogenstudio

# 2. 设置大模型 API 密钥 (Windows PowerShell)
$env:OPENAI_API_KEY="sk-..."

# 3. 启动本地 Web 服务
autogenstudio ui --port 8081

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient


async def run_round_robin_demo():
  # 1. 实例化底层大模型客户端
  model_client = OpenAIChatCompletionClient(
      model="gpt-4o",
      # api_key="sk-..." 可从环境变量 OPENAI_API_KEY 自动读取
  )

  # 2. 定义角色清晰的专家 Agent
  planner = AssistantAgent(
      name="Architect",
      model_client=model_client,
      system_message=(
          "你是一位资深系统架构师。面对用户的需求，请给出精炼的 3 步高可用设计框架。"
          "不要长篇大论，突出技术选型与关键考量。"
      ),
  )

  engineer = AssistantAgent(
      name="Engineer",
      model_client=model_client,
      system_message=(
          "你是一位资深全栈研发工程师。根据架构师给出的方案，给出具体的实现要点或伪代码。"
          "当确认设计与实现完整闭环后，请在回复末尾附带严格的单词：TERMINATE。"
      ),
  )

  # 3. 设置鲁棒的组合终止条件（满足其一即停）
  # - 文本中包含 TERMINATE
  # - 或对话达到 6 轮防死锁上限
  termination = TextMentionTermination("TERMINATE") | MaxMessageTermination(
      max_messages=6
  )

  # 4. 构建轮询编排团队
  team = RoundRobinGroupChat(
      participants=[planner, engineer], termination_condition=termination
  )

  # 5. 启动任务并以控制台流式渲染
  task_prompt = "请为日均千万级请求的短链接系统设计一套后端架构。"
  print(f"=== 开始执行任务: {task_prompt} ===\n")

  # Console 自动流式打印每个 Agent 的回复与状态
  await Console(team.run_stream(task=task_prompt))
  print("\n=== 任务执行结束 ===")


if __name__ == "__main__":
  asyncio.run(run_round_robin_demo())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

import asyncio
from autogen_agentchat.agents import AssistantAgent, CodeExecutorAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import SelectorGroupChat
from autogen_agentchat.ui import Console
from autogen_ext.code_executors.local import LocalCommandLineCodeExecutor
from autogen_ext.models.openai import OpenAIChatCompletionClient


async def run_code_execution_selector_demo():
  model_client = OpenAIChatCompletionClient(model="gpt-4o")

  # 1. 编程专家：输出规范的 markdown 代码块
  coder = AssistantAgent(
      name="PythonCoder",
      model_client=model_client,
      description="精通 Python 的算法工程师。负责编写完整的、可直接运行的代码块来解决问题。",
      system_message=(
          "你是一名资深 Python 开发者。请针对任务编写无外部危险依赖的高效代码。"
          "务必将代码包裹在 ```python ... ``` 格式的 markdown 代码块中。"
      ),
  )

  # 2. 代码执行专员：只负责运行代码并捕获控制台输出
  workspace_dir = "./coding_workspace"
  local_executor = LocalCommandLineCodeExecutor(work_dir=workspace_dir)
  executor = CodeExecutorAgent(
      name="CodeRunner",
      code_executor=local_executor,
      description="代码执行专员。负责运行上文对话中的 Python 代码，并反馈控制台标准输出和错误。",
  )

  # 3. 质量审查与验收员
  reviewer = AssistantAgent(
      name="QualityReviewer",
      model_client=model_client,
      description="质量评估专家。审查运行结果是否正确，决定是否验收通过。",
      system_message=(
          "你负责审查代码执行返回的结果是否完全符合用户需求。"
          "如果运行报错，请指出问题并要求 PythonCoder 修复；"
          "如果计算结果准确无误，请在发言末尾输出 TERMINATE。"
      ),
  )

  # 4. 终止条件
  termination = TextMentionTermination("TERMINATE")

  # 5. 构建动态选择器团队（SelectorGroupChat）
  # Selector 会利用 model_client 来分析各 Agent 的 description 并决定下一位发言人
  team = SelectorGroupChat(
      participants=[coder, executor, reviewer],
      model_client=model_client,
      termination_condition=termination,
      allow_repeated_speaker=False,  # 强制禁止同一个智能体连续发言两次
  )

  task = "请计算第 30 个斐波那契数列的值，并计算前 30 个数的总和，打印输出结果。"
  print(f"=== 动态协同执行任务: {task} ===\n")
  await Console(team.run_stream(task=task))


if __name__ == "__main__":
  asyncio.run(run_code_execution_selector_demo())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 适用环境：pip install pyautogen 或 pip install ag2
import autogen

config_list = [{
    "model": "gpt-4o",
    "api_key": "sk-...",
}]
llm_config = {
    "config_list": config_list,
    "temperature": 0.2,
    "timeout": 120,
}

# 1. 具备代码执行能力的 UserProxyAgent
user_proxy = autogen.UserProxyAgent(
    name="Admin",
    system_message="人类管理者。负责协调任务并执行生成的代码。",
    code_execution_config={
        "work_dir": "classic_workspace",
        "use_docker": False,  # 仅测试，生产务必设为 True
    },
    human_input_mode="NEVER",
    is_termination_msg=lambda x: "TERMINATE" in x.get("content", ""),
)

# 2. 专家助理
engineer = autogen.AssistantAgent(
    name="Engineer",
    llm_config=llm_config,
    system_message="资深数据分析师。通过编写 Python 代码处理数据，当结论得出后输出 TERMINATE。",
)

# 3. 经典双 Agent 发起对话
user_proxy.initiate_chat(
    engineer, message="请帮我抓取近 7 天某加密货币的价格趋势并绘制折线图保存在本地。"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

                                [客户端 / 前端应用]
                                         │
                                         ▼ (WebSocket / SSE 流)
┌─────────────────────────────────────────────────────────────────────────────┐
│                       应用服务网关 (FastAPI / gRPC)                         │
│  - 鉴权认证、速率限制 (Rate Limit)、输入安全审查 (Guardrails)                │
└─────────────────────────────────────────────────────────────────────────────┘
                                         │
                                         ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                 AutoGen v0.4 运行时容器 (Agent Runtime Pool)                │
│  - 基于 Team 组织架构 (Selector / Magentic-One 模式)                         │
│  - OpenTelemetry 链路跟踪: 监控 LLM 延迟、Token 消耗、工具调用耗时          │
└─────────────────────────────────────────────────────────────────────────────┘
                     │                                   │
                     ▼                                   ▼
┌─────────────────────────────────────┐ ┌─────────────────────────────────────┐
│         模型服务接入层              │ │            隔离沙箱执行层           │
│  - 统一调用网关 (Azure / LiteLLM)   │ │  - 弹性容器池 (Docker / E2B)        │
│  - 具备重试、熔断与主备模型平滑切换 │ │  - 挂载独立虚拟工作空间目录         │
└─────────────────────────────────────┘ └─────────────────────────────────────┘