1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from langchain.tools import tool

@tool
def search_database(query: str, limit: int = 10) -> str:
    """Search the customer database for records matching the query.

    Args:
        query: Search terms to look for
        limit: Maximum number of results to return
    """
    return f"Found {limit} results for '{query}'"

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

from typing import Literal
from pydantic import BaseModel, Field

class WeatherInput(BaseModel):
    location: str = Field(description="City name or coordinates")
    units: Literal["celsius", "fahrenheit"] = Field(
        default="celsius",
        description="Temperature unit preference",
    )
    include_forecast: bool = Field(default=False)

@tool(args_schema=WeatherInput)
def get_weather(
    location: str,
    units: str = "celsius",
    include_forecast: bool = False,
) -> str:
    """Get current weather and optional forecast."""
    ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool

@tool
def get_last_user_message(runtime: ToolRuntime) -> str:
    """Get the most recent message from the user."""
    for message in reversed(runtime.state["messages"]):
        if isinstance(message, HumanMessage):
            return message.content
    return "No user messages found"

@tool
def get_user_preference(pref_name: str, runtime: ToolRuntime) -> str:
    """Get a user preference value."""
    return runtime.state.get("user_preferences", {}).get(pref_name, "Not set")

 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

from langchain.agents import AgentState
from langchain.messages import ToolMessage
from langchain.tools import ToolRuntime, tool
from langgraph.types import Command

class CustomState(AgentState):
    user_name: str

@tool
def set_user_name(
    new_name: str,
    runtime: ToolRuntime[None, CustomState],
) -> Command:
    """Set the user's name in the conversation state."""
    return Command(
        update={
            "user_name": new_name,
            "messages": [
                ToolMessage(
                    content=f"User name set to {new_name}.",
                    tool_call_id=runtime.tool_call_id,
                )
            ],
        }
    )

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

from dataclasses import dataclass

@dataclass
class UserContext:
    user_id: str

@tool
def get_account_info(runtime: ToolRuntime[UserContext]) -> str:
    """Get the current user's account information."""
    return str(USER_DATABASE.get(runtime.context.user_id, "User not found"))

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_account_info],
    context_schema=UserContext,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's my balance?"}]},
    config={"configurable": {"thread_id": "thread-1"}},
    context=UserContext(user_id="user123"),
)

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

@tool
def get_user_info(user_id: str, runtime: ToolRuntime) -> str:
    """Look up user info."""
    item = runtime.store.get(("users",), user_id)
    return str(item.value) if item else "Unknown user"

@tool
def save_user_info(
    user_id: str,
    name: str,
    age: int,
    email: str,
    runtime: ToolRuntime,
) -> str:
    """Save user info."""
    runtime.store.put(
        ("users",), user_id, {"name": name, "age": age, "email": email}
    )
    return "Successfully saved user info."

1
2
3
4
5
6

@tool
def get_weather(city: str, runtime: ToolRuntime) -> str:
    """Get weather for a given city."""
    runtime.stream_writer(f"Looking up data for city: {city}")
    runtime.stream_writer(f"Acquired data for city: {city}")
    return f"It's always sunny in {city}!"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@tool(return_direct=True)
def fetch_and_store_order(order_id: str, runtime: ToolRuntime) -> Command:
    """Fetch order status and store it in state."""
    status = f"Order {order_id} is shipped."
    return Command(
        update={
            "last_order_status": status,
            "messages": [
                ToolMessage(content=status, tool_call_id=runtime.tool_call_id)
            ],
        }
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from langchain.agents.middleware import wrap_tool_call
from langchain.messages import ToolMessage

@wrap_tool_call
def handle_tool_errors(request, handler) -> ToolMessage:
    try:
        return handler(request)
    except Exception as error:
        return ToolMessage(
            content=f"Tool error: Please check your input. ({error})",
            tool_call_id=request.tool_call["id"],
        )

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

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_user_info],
    checkpointer=InMemorySaver(),
)

config = {"configurable": {"thread_id": "1"}}
agent.invoke(
    {"messages": [{"role": "user", "content": "Hi! My name is Bob."}]},
    config,
)
result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's my name?"}]},
    config,
)

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

from langchain.agents import AgentState

class CustomAgentState(AgentState):
    user_id: str
    preferences: dict

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_user_info],
    state_schema=CustomAgentState,
    checkpointer=InMemorySaver(),
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Hello"}],
        "user_id": "user_123",
        "preferences": {"theme": "dark"},
    },
    {"configurable": {"thread_id": "1"}},
)

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

from langchain.agents.middleware import before_model
from langchain.messages import RemoveMessage
from langgraph.graph.message import REMOVE_ALL_MESSAGES

@before_model
def trim_messages(state, runtime) -> dict | None:
    """Keep only the first and most recent messages."""
    messages = state["messages"]
    if len(messages) <= 3:
        return None

    first_message = messages[0]
    recent_messages = messages[-3:] if len(messages) % 2 == 0 else messages[-4:]
    return {
        "messages": [
            RemoveMessage(id=REMOVE_ALL_MESSAGES),
            first_message,
            *recent_messages,
        ]
    }

1
2
3
4
5
6
7
8

from langchain.messages import RemoveMessage

def delete_messages(state):
    messages = state["messages"]
    if len(messages) > 2:
        return {
            "messages": [RemoveMessage(id=message.id) for message in messages[:2]]
        }

1
2
3
4
5

from langchain.messages import RemoveMessage
from langgraph.graph.message import REMOVE_ALL_MESSAGES

def delete_messages(state):
    return {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES)]}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[...],
    middleware=[
        SummarizationMiddleware(
            model="openai:gpt-5.4-mini",
            trigger=("tokens", 4000),
            keep=("messages", 20),
        )
    ],
    checkpointer=checkpointer,
)

1
2
3
4
5

@tool
def get_user_info(runtime: ToolRuntime) -> str:
    """Look up user info."""
    user_id = runtime.state["user_id"]
    return "User is John Smith" if user_id == "user_123" else "Unknown user"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from typing import TypedDict
from langchain.agents.middleware import ModelRequest, dynamic_prompt

class CustomContext(TypedDict):
    user_name: str

@dynamic_prompt
def dynamic_system_prompt(request: ModelRequest) -> str:
    user_name = request.runtime.context["user_name"]
    return f"You are a helpful assistant. Address the user as {user_name}."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from langchain.agents.middleware import after_model
from langchain.messages import RemoveMessage

@after_model
def validate_response(state, runtime) -> dict | None:
    """Remove messages containing sensitive words."""
    stop_words = ["password", "secret"]
    last_message = state["messages"][-1]
    if any(word in last_message.content for word in stop_words):
        return {"messages": [RemoveMessage(id=last_message.id)]}
    return None

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

stream = agent.stream_events(
    {"messages": [{"role": "user", "content": "What is the weather in SF?"}]},
    version="v3",
)

for message in stream.messages:
    for delta in message.text:
        print(delta, end="", flush=True)

final_state = stream.output

1
2
3
4
5
6

for message in stream.messages:
    print(f"[{message.node}] ", end="")
    for delta in message.text:
        print(delta, end="", flush=True)
    if message.output.usage_metadata:
        print(message.output.usage_metadata)

1
2
3
4
5

for message in stream.messages:
    for delta in message.reasoning:
        print(f"[thinking] {delta}", end="", flush=True)
    for delta in message.text:
        print(delta, end="", flush=True)

1
2
3
4
5

for subagent in stream.subagents:
    print(f"{subagent.name}: ", end="")
    for message in subagent.messages:
        for token in message.text:
            print(token, end="", flush=True)

1
2
3
4

for snapshot in stream.values:
    print(snapshot)

final_state = stream.output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import asyncio

stream = await agent.astream_events(input, version="v3")

async def consume_messages():
    async for message in stream.messages:
        print(await message.text)

async def consume_tool_calls():
    async for call in stream.tool_calls:
        print(call.tool_name, call.input)

await asyncio.gather(consume_messages(), consume_tool_calls())

1
2
3
4
5
6
7

for name, item in stream.interleave("messages", "tool_calls", "values"):
    if name == "messages":
        print(item.text)
    elif name == "tool_calls":
        print(item.tool_name, item.input)
    elif name == "values":
        print(item)

1
2
3
4
5
6
7
8

stream = agent.stream_events(
    input,
    version="v3",
    transformers=[ToolActivityTransformer],
)

for activity in stream.extensions["tool_activity"]:
    print(activity)

1
2
3
4

from langchain.agents.middleware import AgentMiddleware

class ToolActivityMiddleware(AgentMiddleware):
    transformers = (ToolActivityTransformer,)

1
2
3
4
5
6
7

agent = create_agent(
    model="openai:gpt-5-nano",
    tools=[],
    middleware=[
        PIIMiddleware("email", strategy="redact", apply_to_output=True),
    ],
)

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)        │
│  - 具备重试、熔断与主备模型平滑切换 │ │  - 挂载独立虚拟工作空间目录         │
└─────────────────────────────────────┘ └─────────────────────────────────────┘

1
2
3
4
5

from langchain_core.runnables import RunnableConfig

def my_node(state: State, config: RunnableConfig):
    checkpoint_ns = config["configurable"]["checkpoint_ns"]
    # "" for the parent graph, "node_name:uuid" for a subgraph

1
2
3
4
5
6
7

# get the latest state snapshot
config = {"configurable": {"thread_id": "1"}}
graph.get_state(config)

# get a state snapshot for a specific checkpoint_id
config = {"configurable": {"thread_id": "1", "checkpoint_id": "1ef663ba-28fe-6528-8002-5a559208592c"}}
graph.get_state(config)

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

The agent should:

- Read incoming customer emails
- Classify them by urgency and topic
- Search relevant documentation to answer questions
- Draft appropriate responses
- Escalate complex issues to human agents
- Schedule follow-ups when needed

Example scenarios to handle:

1. Simple product question: "How do I reset my password?"
2. Bug report: "The export feature crashes when I select PDF format"
3. Urgent billing issue: "I was charged twice for my subscription!"
4. Feature request: "Can you add dark mode to the mobile app?"
5. Complex technical issue: "Our API integration fails intermittently with 504 errors"

 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

from typing import TypedDict, Literal

# Define the structure for email classification
class EmailClassification(TypedDict):
    intent: Literal["question", "bug", "billing", "feature", "complex"]
    urgency: Literal["low", "medium", "high", "critical"]
    topic: str
    summary: str

class EmailAgentState(TypedDict):
    # Raw email data
    email_content: str
    sender_email: str
    email_id: str

    # Classification result
    classification: EmailClassification | None

    # Raw search/API results
    search_results: list[str] | None  # List of raw document chunks
    customer_history: dict | None  # Raw customer data from CRM

    # Generated content
    draft_response: str | None
    messages: list[str] | None

 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

# Create structured LLM that returns EmailClassification dict
structured_llm = llm.with_structured_output(EmailClassification)

# Format the prompt on-demand, not stored in state
classification_prompt = f"""
Analyze this customer email and classify it:

Email: {state['email_content']}
From: {state['sender_email']}

Provide classification including intent, urgency, topic, and summary.
"""

# Get structured response directly as dict
classification = structured_llm.invoke(classification_prompt)

# Determine next node based on classification
if classification['intent'] == 'billing' or classification['urgency'] == 'critical':
    goto = "human_review"
elif classification['intent'] in ['question', 'feature']:
    goto = "search_documentation"
elif classification['intent'] == 'bug':
    goto = "bug_tracking"
else:
    goto = "draft_response"

# Store classification as a single dict in state
return Command(
    update={"classification": classification},
    goto=goto
)]()

 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

from typing import Literal
from langgraph.graph import StateGraph, START, END
from langgraph.types import interrupt, Command, RetryPolicy
from langchain_openai import ChatOpenAI
from langchain.messages import HumanMessage

llm = ChatOpenAI(model="gpt-5-nano")

def read_email(state: EmailAgentState) -> dict:
    """Extract and parse email content"""
    # In production, this would connect to your email service
    return {
        "messages": [HumanMessage(content=f"Processing email: {state['email_content']}")]
    }

def classify_intent(state: EmailAgentState) -> Command[Literal["search_documentation", "human_review", "draft_response", "bug_tracking"]]:
    """Use LLM to classify email intent and urgency, then route accordingly"""

    # Create structured LLM that returns EmailClassification dict
    structured_llm = llm.with_structured_output(EmailClassification)

    # Format the prompt on-demand, not stored in state
    classification_prompt = f"""
    Analyze this customer email and classify it:

    Email: {state['email_content']}
    From: {state['sender_email']}

    Provide classification including intent, urgency, topic, and summary.
    """

    # Get structured response directly as dict
    classification = structured_llm.invoke(classification_prompt)

    # Determine next node based on classification
    if classification['intent'] == 'billing' or classification['urgency'] == 'critical':
        goto = "human_review"
    elif classification['intent'] in ['question', 'feature']:
        goto = "search_documentation"
    elif classification['intent'] == 'bug':
        goto = "bug_tracking"
    else:
        goto = "draft_response"

    # Store classification as a single dict in state
    return Command(
        update={"classification": classification},
        goto=goto
    )

1
2
3
4
5
6
7
8
9

stream = agent.stream_events({
    "messages": [{"role": "user", "content": "What is the weather in SF?"}],
}, version="v3")

for message in stream.messages:
    for delta in message.text:
        print(delta, end="", flush=True)

final_state = stream.output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

stream = agent.stream_events(input, version="v3")

for message in stream.messages:
    print(f"[{message.node}] ", end="")
    for delta in message.text:
        print(delta, end="", flush=True)

    full_message = message.output
    usage = full_message.usage_metadata
    if usage:
        print(usage)

1
2
3
4
5
6
7
8

stream = agent.stream_events(input, version="v3")

for message in stream.messages:
    for delta in message.reasoning:
        print(f"[thinking] {delta}", end="", flush=True)

    for delta in message.text:
        print(delta, end="", flush=True)

1
2
3
4
5
6
7
8

stream = agent.stream_events(input, version="v3")

for message in stream.messages:
    for delta in message.reasoning:
        print(f"[thinking] {delta}", end="", flush=True)

    for delta in message.text:
        print(delta, end="", flush=True)

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

upervisor = create_agent(
    model=init_chat_model("openai:gpt-5.5"),
    tools=[call_weather],
    name="supervisor",
)

stream = supervisor.stream_events(
    {"messages": [{"role": "user", "content": "What's the weather in Boston?"}]},
    version="v3",
)

for subagent in stream.subagents:
    print(f"{subagent.name}: ", end="")
    for message in subagent.messages:
        for token in message.text:
            print(token, end="", flush=True)
    print()

1
2
3
4
5
6

stream = agent.stream_events(input, version="v3")

for snapshot in stream.values:
    print(snapshot)

final_state = stream.output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import asyncio

stream = await agent.astream_events(input, version="v3")

async def consume_messages():
    async for message in stream.messages:
        print(await message.text)

async def consume_tool_calls():
    async for call in stream.tool_calls:
        print(call.tool_name, call.input)

await asyncio.gather(consume_messages(), consume_tool_calls())

1
2
3
4
5
6
7
8
9

stream = agent.stream_events(input, version="v3")

for name, item in stream.interleave("messages", "tool_calls", "values"):
    if name == "messages":
        print(item.text)
    elif name == "tool_calls":
        print(item.tool_name, item.input)
    elif name == "values":
        print(item)

1
2
3
4
5
6
7
8

stream = agent.stream_events(
    input,
    version="v3",
    transformers=[ToolActivityTransformer],
)

for activity in stream.extensions["tool_activity"]:
    print(activity)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from langchain.agents import create_agent
from langchain.agents.middleware import AgentMiddleware


class ToolActivityMiddleware(AgentMiddleware):
    transformers = (ToolActivityTransformer,)


agent = create_agent(
    model="gpt-5-nano",
    tools=[get_weather],
    middleware=[ToolActivityMiddleware()],
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware

agent = create_agent(
    model="gpt-5-nano",
    tools=[],
    middleware=[
        PIIMiddleware("email", strategy="redact", apply_to_output=True),
    ],
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.store.memory import InMemoryStore

checkpointer = InMemorySaver()
store = InMemoryStore()

graph = builder.compile(checkpointer=checkpointer, store=store)

result = graph.invoke(
    {"messages": [{"role": "user", "content": "Hi, my name is Bob."}]},
    {"configurable": {"thread_id": "thread-1"}},
)