LangGraph构建多智能体

LangGraph

🦜🕸 LangGraph ⚡ 以图的方式构建语言代理 ⚡

官方文档地址：https://langchain-ai.github.io/langgraph/

LangGraph 是一个用于构建有状态的多参与者应用程序的库，利用 LLM 创建代理和多代理工作流。与

其他 LLM 框架相比，它提供了以下核心优势：循环性、可控性和持久性。LangGraph 允许您定义涉及

循环的流程，这对于大多数代理架构至关重要，使其与基于 DAG 的解决方案区别开来。作为一个非常底

层的框架，它提供了对应用程序流程和状态的细粒度控制，这对于创建可靠的代理至关重要。此外，

LangGraph 包含内置的持久性，支持先进的人机协作和记忆特性。

LangGraph 的灵感来源于 Pregel 和 Apache Beam。公共接口受 NetworkX 的启发。LangGraph 是由

LangChain Inc 开发的，它是 LangChain 的创建者，但可以在不使用 LangChain 的情况下使用。

LangGraph 平台是用于部署 LangGraph 代理的基础设施。它是一个商业解决方案，用于将代理应用程

序部署到生产环境，构建于开源的 LangGraph 框架之上。LangGraph 平台由多个组件组成，这些组件

协同工作以支持 LangGraph 应用程序的开发、部署、调试和监控：LangGraph 服务器（API）、

LangGraph SDK（API 客户端）、LangGraph CLI（构建服务器的命令行工具）、LangGraph

Studio（用户界面/调试器）。

主要功能

循环和分支：在您的应用程序中实现循环和条件语句。
持久性：在图中的每个步骤之后自动保存状态。在任何时候暂停和恢复图执行以支持错误恢复、 "人机交互"工作流、时间旅行等等。
"人机交互"：中断图执行以批准或编辑代理计划的下一个动作。
流支持：在每个节点产生输出时流式传输输出（包括令牌流式传输）。
与 LangChain 集成：LangGraph 与 LangChain 和 LangSmith 无缝集成（但不需要它们）。

LangGraph 平台

LangGraph 平台是一个商业解决方案，用于将代理应用程序部署到生产环境，构建于开源的，LangGraph 框架之上。以下是一些在复杂部署中常见的问题，LangGraph 平台解决了这些问题：

流式支持：LangGraph 服务器提供多种流式模式，优化以满足各种应用需求
后台运行：在后台异步运行代理
支持长时间运行的代理：能够处理长时间运行过程的基础设施
双重文本：处理用户在代理回复之前收到两条消息的情况
处理突发性 ：任务队列以确保请求在高负载下也能始终如一地处理，不会丢失。

Graph(图)

LangGraph 的核心是将代理工作流建模为图。你可以使用三个关键组件来定义代理的行为

状态：一个共享的数据结构，表示应用程序的当前快照。它可以是任何 Python 类型，但通常是
Type
dDict 或 Pydantic BaseModel。
节点：编码代理逻辑的 Python 函数。它们接收当前状态作为输入，执行一些计算，并返回一个
更新的状态。
边：Python 函数，根据当前状态确定要执行的下一个节点。它们可以是条件分支或固定转换。
通过组合节点和边，你可以创建复杂的循环工作流，随着时间的推移发展状态。但是，真正的力量来
自于 LangGraph 如何管理状态。需要强调的是：节点和边不再是 Python 函数------它们可以包含
LLM 或简单的 Python 代码。

简而言之：节点完成工作。边指示下一步要做什么。

LangGraph 的底层图算法使用消息传递来定义一个通用程序。当一个节点完成其操作时，它会沿着一条或多条边向其他节点发送消息。这些接收节点然后执行其函数，将结果消息传递给下一组节点，并且该过程继续进行。受到 Google 的 Pregel 系统的启发，该程序以离散的"超级步骤"进行。

超级步骤可以被认为是图节点上的单个迭代。并行运行的节点属于同一个超级步骤，而顺序运行的节点则属于不同的超级步骤。在图执行开始时，所有节点都处于 inactive 状态。当节点在任何传入边（或"通道"）上收到新消息（状态）时，它将变为 active 状态。然后，活动节点运行其函数并响应更新。在每个超级步骤结束时，没有传入消息的节点通过将其标记为 inactive 来投票 halt。当所有节点都处于inactive 状态且没有消息在传输中时，图执行终止。

StateGraph

stateGraph 类是使用的主要图类。它由用户定义的状态对象参数化。

python 复制代码

#示例：state_graph.py
# 从langgraph.graph模块导入START和StateGraph
from langgraph.graph import START, StateGraph
# 定义一个节点函数my_node，接收状态和配置，返回新的状态
def my_node(state, config):
    return {"x": state["x"] + 1,"y": state["y"] + 2}
# 创建一个状态图构建器builder，使用字典类型作为状态类型
builder = StateGraph(dict)
# 向构建器中添加节点my_node，节点名称将自动设置为'my_node'
builder.add_node(my_node) # node name will be 'my_node'
# 添加一条边，从START到'my_node'节点
builder.add_edge(START, "my_node")
# 编译状态图，生成可执行的图
graph = builder.compile()
# 调用编译后的图，传入初始状态{"x": 1}
print(graph.invoke({"x": 3,"y":2}))

# 输出：
# {'x': 2,'y': 4}

Compiling your graph(编译你的图)

要构建你的图，你首先定义状态，然后添加节点和边，最后进行编译。编译图究竟是什么，为什么需要它？

编译是一个非常简单的步骤。它对图的结构进行一些基本检查（没有孤立的节点等等）。它也是你可以指定运行时参数的地方，例如检查点和断点。你只需调用 .compile 方法即可编译你的图。

python 复制代码

#你必须在使用图之前编译它。

graph = graph_builder.compile(...)

编译结果

State(状态)

定义图时，你做的第一件事是定义图的 状态 。 状态 包含图的模式以及归约器函数，它们指定如何将

更新应用于 状态 。 状态 的模式将是图中所有 节点 和 边 的输入模式，可以是 TypedDict 或者

Pydantic 模型。所有 节点 将发出对 状态 的更新，这些更新然后使用指定的 归约器 函数进行应用。

Nodes(节点)

在 LangGraph 中，节点通常是 Python 函数（同步或 async），其中第一个位置参数是状态，（可选地），第二个位置参数是"配置"，包含可选的可配置参数（例如 thread_id）。类似于 NetworkX，您可以使用add_node方法将这些节点添加到图形中

python 复制代码

#示例：node_case.py
from langchain_core.runnables import RunnableConfig
from langgraph.graph import StateGraph, START
from langgraph.graph import END
# 初始化 StateGraph，状态类型为字典
graph = StateGraph(dict)
# 定义节点
def my_node(state: dict, config: RunnableConfig):
    print("In node: ", config["configurable"]["user_id"])
    return {"results": f"Hello, {state['input']}!"}
def my_other_node(state: dict):
    return state
# 将节点添加到图中
graph.add_node("my_node", my_node)
graph.add_node("other_node", my_other_node)
# 连接节点以确保它们是可达的
graph.add_edge(START, "my_node")
graph.add_edge("my_node", "other_node")
graph.add_edge("other_node", END)
# 编译图
print(graph.compile())

在幕后，函数被转换为RunnableLambda，它为您的函数添加了批处理和异步支持，以及本地跟踪和调试。

如果您在没有指定名称的情况下将节点添加到图形中，它将被赋予一个默认名称，该名称等同于函数名称。

python 复制代码

graph.add_node(my_node)
# You can then create edges to/from this node by referencing it as
`"my_node"`

START 节点

START节点是一个特殊节点，它代表将用户输入发送到图形的节点。引用此节点的主要目的是确定哪些节点应该首先被调用。

python 复制代码

from langgraph.graph import START

graph.add_edge(START,"my_node")
graph.add_edge("my_node","other_node")

END 节点

END节点是一个特殊节点，它代表一个终端节点。当您想要指定哪些边在完成操作后没有动作时，会引用此节点。

python 复制代码

from langgraph.graph import END

graph.add_edge("other_node", END)

Edges(边)

边定义了逻辑如何路由以及图形如何决定停止。这是您的代理如何工作以及不同节点如何相互通信的重要部分。有一些关键类型的边

普通边：直接从一个节点到下一个节点。
条件边：调用一个函数来确定下一个要转到的节点。
入口点：用户输入到达时首先调用的节点。
条件入口点：调用一个函数来确定用户输入到达时首先调用的节点。

一个节点可以有多个输出边。如果一个节点有多个输出边，则所有这些目标节点将在下一个超级步骤中并行执行。

普通边

如果您总是想从节点 A 到节点 B，您可以直接使用add_edge方法。

python 复制代码

#示例：edges_case.py
graph.add_edge("node_a","node_b")

条件边

如果您想选择性地路由到一个或多个边（或选择性地终止），您可以使用add_conditional_edges方法。此方法接受节点的名称和一个"路由函数"，该函数将在该节点执行后被调用

python 复制代码

graph.add_conditional_edges("node_a", routing_function)

类似于节点， routing_function接受图形的当前 state并返回一个值。

默认情况下，返回值 routing_function用作要将状态发送到下一个节点的节点名称（或节点列表）。

所有这些节点将在下一个超级步骤中并行运行。

您可以选择提供一个字典，该字典将 routing_function的输出映射到下一个节点的名称。

python 复制代码

graph.add_conditional_edges("node_a"}), routing_function, {True: "node_b", False:"node_c")

入口点

入口点是图形启动时运行的第一个节点。您可以从虚拟的START节点使用add_edge方法到要执行的第一个节点，以指定进入图形的位置。

python 复制代码

from langgraph.graph import START

graph.add_edge(START,"my_node")

条件入口点

条件入口点允许您根据自定义逻辑从不同的节点开始。您可以从虚拟的START节点使用add_conditional_edges来实现这一点。

python 复制代码

from langgraph.graph import START

graph.add_conditional_edges(START, routing_function)

您可以选择提供一个字典，该字典将 routing_function的输出映射到下一个节点的名称。

python 复制代码

graph.add_conditional_edges(START, routing_my,{True: "my_node", False:"other_node"})

准备：

python 复制代码

pip install modelscope

mkdir -p /root/autodl-tmp/demo/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
cd /root/autodl-tmp/demo/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
modelscope download --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B --local_dir ./

# 创建Imdeploy隔离环境
conda create -n lmdeploy python=3.10 -y

# 激活环境
conda activate lmdeploy

# source activate lmdeploy
# 果是退出shell ,再次进入base环境，需要先加载环境
pip install lmdeploy

CUDA_VISIBLE_DEVICES=1 lmdeploy serve api_server /root/autodl-tmp/demo/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B --model-format=hf --dtype=bfloat16  --tp=1 --server-port=23333

python 复制代码

from typing import Literal, Annotated
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, START, END
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langchain_core.pydantic_v1 import BaseModel, Field
import re

# ================== 强化状态类 ==================
class AgentState(BaseModel):
    messages: Annotated[list, Field(default_factory=list)]
    next_agent: Literal["researcher", "calculator", "writer", "done"] = "researcher"
    step_count: int = 0
    is_finalized: bool = False

    @classmethod
    def from_raw(cls, raw):
        """统一状态转换方法"""
        if isinstance(raw, cls):
            return raw
        if isinstance(raw, dict):
            # 确保处理旧版状态格式
            return cls(
                messages=raw.get('messages', []),
                next_agent=raw.get('next_agent', 'researcher'),
                step_count=raw.get('step_count', 0),
                is_finalized=raw.get('is_finalized', False)
            )
        raise ValueError(f"无效状态类型: {type(raw)}")

    def to_safe_dict(self):
        """安全转换为字典（用于异常处理）"""
        return {
            "messages": [msg.dict() for msg in self.messages],
            "next_agent": self.next_agent,
            "step_count": self.step_count,
            "is_finalized": self.is_finalized
        }

# ================== 消息转换增强 ==================
def convert_messages(raw_messages):
    converted = []
    for msg in raw_messages:
        if isinstance(msg, dict):
            try:
                role = msg.get("role", "assistant")
                content = msg.get("content", "")
                msg_type = {
                    "user": HumanMessage,
                    "system": SystemMessage,
                    "assistant": AIMessage
                }[role]
                converted.append(msg_type(content=content))
            except KeyError:
                converted.append(AIMessage(content=str(msg)))
        elif hasattr(msg, 'content'):
            converted.append(msg)
        else:
            converted.append(AIMessage(content=str(msg)))
    return converted

# ================== 模型配置 ==================
model = ChatOpenAI(
    openai_api_base="http://localhost:23333/v1",
    model_name="/root/autodl-tmp/demo/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    openai_api_key="EMPTY",
    max_tokens=300,
    temperature=0.2
)

# ================== 核心Agent模板 ==================
def create_agent(role: str, prompt: str):
    def agent(raw_state):
        state = AgentState.from_raw(raw_state)
        if state.is_finalized:
            return state

        try:
            messages = convert_messages(state.messages)
            messages.append(SystemMessage(
                content=f"{prompt}\n最后必须用'建议下一步：选项'格式结尾（选项只能是researcher/calculator/writer/done）"
            ))

            response = model.invoke(messages)
            print(f"\n[{role}输出] {response.content[:200]}...")  # 限制日志长度

            # 强制Writer添加END标识
            if role == "writer" and "[END]" not in response.content:
                response.content += "\n[END]"
                print(f"[{role}修正] 已添加[END]标识")

            # 解析下一步建议
            next_agent = "done"
            if match := re.search(r'建议下一步\s*[:：]\s*(\w+)', response.content):
                suggestion = match.group(1).lower()
                if suggestion in {"researcher", "calculator", "writer", "done"}:
                    next_agent = suggestion

            return AgentState(
                messages=messages + [response],
                next_agent=next_agent,
                step_count=state.step_count + 1,
                is_finalized="[END]" in response.content
            )
        except Exception as e:
            print(f"[{role}错误] {str(e)}")
            return AgentState(
                messages=state.messages,
                next_agent="done",
                step_count=state.step_count + 1,
                is_finalized=True
            )
    return agent

# ================== Supervisor节点强化 ==================
def supervisor(raw_state):
    state = AgentState.from_raw(raw_state)
    if state.is_finalized:
        return state

    try:
        print(f"\n[Supervisor] 当前步数: {state.step_count}")
        
        # 强制流程控制
        if state.step_count >= 8:
            print("[强制终止] 达到最大步数限制")
            return AgentState(
                messages=state.messages,
                next_agent="writer",
                step_count=state.step_count + 1,
                is_finalized=False
            )

        messages = convert_messages(state.messages)
        control_prompt = '''请严格选择下一步：
1. 需要更多数据 → researcher
2. 需要计算 → calculator 
3. 生成报告 → writer
4. 完成 → done'''
        
        response = model.invoke(messages + [SystemMessage(content=control_prompt)])
        decision = re.search(r'\b(researcher|calculator|writer|done)\b', response.content.lower())
        
        new_agent = decision.group(1).lower() if decision else "done"
        # 强制done前必须生成报告
        if new_agent == "done" and not any("[END]" in msg.content for msg in messages):
            new_agent = "writer"

        return AgentState(
            messages=state.messages,
            next_agent=new_agent,
            step_count=state.step_count + 1,
            is_finalized=False
        )
    except Exception as e:
        print(f"[Supervisor错误] {str(e)}")
        return AgentState(
            messages=state.messages,
            next_agent="writer",
            step_count=state.step_count + 1,
            is_finalized=False
        )

# ================== 工作流配置 ==================
builder = StateGraph(AgentState)
builder.add_node("supervisor", supervisor)
builder.add_node("researcher", create_agent("研究员", "收集经济数据并分析趋势"))
builder.add_node("calculator", create_agent("计算器", "执行GDP增长率计算"))
builder.add_node("writer", create_agent("作家", "生成包含[END]标识的最终报告"))

# builder.add_edge("supervisor","researcher")
builder.add_conditional_edges(
    "supervisor",
    lambda state: state.next_agent,
    {
        "researcher": "researcher",
        "calculator": "calculator", 
        "writer": "writer",
        "done": END
    }
)

for agent in ["researcher", "calculator", "writer"]:
    builder.add_edge(agent, "supervisor")

builder.set_entry_point("supervisor")
workflow = builder.compile()

# ================== 执行入口强化 ==================
if __name__ == "__main__":
    try:
        # 初始化状态时确保类型正确
        initial_state = AgentState(messages=[HumanMessage(content="成都市GDP增长率分析")])
        
        for step in workflow.stream(initial_state):
            node_name, raw_state = step.popitem()
            current_state = AgentState.from_raw(raw_state)
            
            print(f"\n[系统状态] 当前节点: {node_name}")
            print(f"下一步: {current_state.next_agent}")
            print(f"步数: {current_state.step_count}")
            print(f"完成状态: {current_state.is_finalized}")

            # 检查终止条件
            if current_state.is_finalized or node_name == "__end__":
                print("\n====== 流程完成 =====")
                if any("[END]" in msg.content for msg in current_state.messages):
                    print("最终报告内容:")
                    print(next(msg.content for msg in reversed(current_state.messages) if "[END]" in msg.content))
                else:
                    print("警告：未检测到完整报告")
                break
                
    except Exception as e:
        print(f"\n!!! 流程异常终止: {str(e)}")
        if 'current_state' in locals():
            print("最后状态:", current_state.to_safe_dict())

输出：
# python test03.py 
sys:1: LangChainDeprecationWarning: As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. The langchain_core.pydantic_v1 module was a compatibility shim for pydantic v1, and should no longer be used. Please update the code to import from Pydantic directly.

For example, replace imports like: `from langchain_core.pydantic_v1 import BaseModel`
with: `from pydantic import BaseModel`
or the v1 compatibility namespace if you are working in a code base that has not been fully upgraded to pydantic 2 yet.         from pydantic.v1 import BaseModel


[Supervisor] 当前步数: 0

[系统状态] 当前节点: supervisor
下一步: writer
步数: 1
完成状态: False

[作家输出] 嗯，用户让我分析成都市GDP增长率，还特别提到要包含[END]标识的最终报告，最后用建议下一步：选项的格式结尾，选项只能是researcher、calculator、writer、done。首先，我得弄清楚用户的需求是什么。他们可能是一个经济研究者，或者是一个学生，或者是政府工作人员，需要一份详细的分析报告。

用户提到的"包含[END]标识的最终报告"，可能意味着他们希望报告结构清晰，有明确的开...

[系统状态] 当前节点: writer
下一步: done
步数: 2
完成状态: True

====== 流程完成 =====
最终报告内容:
嗯，用户让我分析成都市GDP增长率，还特别提到要包含[END]标识的最终报告，最后用建议下一步：选项的格式结尾，选项只能是researcher、calculator、writer、done。首先，我得弄清楚用户的需求是什么。他们可能是一个经济研究者，或者是一个学生，或者是政府工作人员，需要一份详细的分析报告。

用户提到的"包含[END]标识的最终报告"，可能意味着他们希望报告结构清晰，有明确的开始和结束部分。而最后的建议选项，可能是在完成报告后，他们需要知道下一步该做什么，比如继续研究、计算更多数据，或者已经完成任务了。

接下来，我需要考虑分析的内容。GDP增长率分析通常包括历史趋势、影响因素、比较分析和预测。所以，我应该从这些方面入手。首先，收集成都市近年来的GDP数据，计算增长率，然后分析这些增长是否稳定，是否有波动。然后，找出影响GDP增长的主要因素，比如经济结构、政策、投资等。接着，比较成都市与其他城市的GDP增长率，看看其在全球或区域中的位置。最后，预测未来几年的GDP增长情况，这可能对政策制定者有帮助。

在分析过程中，我需要确保数据的准确性和来源的可靠性。可能需要查阅国家统计局的数据，或者相关的经济研究论文。同时，分析时要保持客观，指出增长的亮点和挑战，比如经济增长是否过于依赖某些

进行流程优化

python 复制代码

from typing import Literal, Annotated
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, START, END
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langchain_core.pydantic_v1 import BaseModel, Field
import re

# ================== 状态类定义 ==================
class AgentState(BaseModel):
    messages: Annotated[list, Field(default_factory=list)]
    next_agent: Literal["researcher", "calculator", "writer", "done"] = "researcher"
    step_count: int = 0

    def __getitem__(self, key):
        return getattr(self, key)
    
    def get(self, key, default=None):
        return getattr(self, key, default)

# ================== 消息转换函数 ==================
def convert_messages(raw_messages):
    return [
        msg if not isinstance(msg, dict) else 
        {
            "user": HumanMessage,
            "system": SystemMessage,
            "assistant": AIMessage
        }[msg["role"]](content=msg["content"])
        for msg in raw_messages
    ]

# ================== 模型配置 ==================
model = ChatOpenAI(
    openai_api_base="http://localhost:23333/v1",
    model_name="/root/autodl-tmp/demo/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    openai_api_key="EMPTY",
    max_tokens=150,
    temperature=0.2
)

# ================== 核心函数：create_agent ==================
def create_agent(role: str, prompt: str):
    """通用Agent创建函数"""
    def agent(state: AgentState):
        current_state = AgentState(**state) if isinstance(state, dict) else state
        
        messages = convert_messages(current_state.messages)
        messages.append(SystemMessage(
            content=f"{prompt}\n请用'建议下一步：选项'格式结尾（选项只能是researcher/calculator/writer/done）"
        ))
        
        try:
            response = model.invoke(messages)
            print(f"[{role}输出] {response.content}")
            
            # 解析下一步建议
            next_agent = "done"
            if match := re.search(r'建议下一步：\s*(\w+)', response.content, re.IGNORECASE):
                suggestion = match.group(1).lower()
                if suggestion in {"researcher", "calculator", "writer", "done"}:
                    next_agent = suggestion
            
            return AgentState(**{
                "messages": messages + [response],
                "next_agent": next_agent,
                "step_count": current_state.step_count + 1
            })
        except Exception as e:
            print(f"[{role}错误] {str(e)}")
            return AgentState(**{
                "messages": current_state.messages,
                "next_agent": "done",
                "step_count": current_state.step_count + 1
            })
    return agent

# ================== Supervisor节点 ==================
def supervisor(state: AgentState):
    current_state = AgentState(**state) if isinstance(state, dict) else state
    
    print(f"\n[Supervisor] 当前步数: {current_state.step_count}")
    if current_state.step_count >= 10:
        return AgentState(**{
            "messages": current_state.messages,
            "next_agent": "done",
            "step_count": current_state.step_count + 1
        })
    
    messages = convert_messages(current_state.messages)
    control_prompt = '''请严格选择并直接回复以下选项（仅单词）：
researcher - 需要进一步研究
calculator - 需要数学计算
writer - 生成最终报告
done - 结束流程'''
    messages.append(SystemMessage(content=control_prompt))
    
    try:
        response = model.invoke(messages)
        raw_output = response.content.strip().lower()
        print(f"[Supervisor决策] 原始输出: {raw_output}")
        
        # 增强解析逻辑
        if "writer" in raw_output:
            next_agent = "writer"
        elif "calculator" in raw_output:
            next_agent = "calculator"
        elif "researcher" in raw_output:
            next_agent = "researcher"
        else:
            next_agent = "done"
        
        return AgentState(**{
            "messages": current_state.messages,
            "next_agent": next_agent,
            "step_count": current_state.step_count + 1
        })
    except Exception as e:
        print(f"[Supervisor错误] {str(e)}")
        return AgentState(**{
            "messages": current_state.messages,
            "next_agent": "done",
            "step_count": current_state.step_count + 1
        })

# ================== 初始化各Agent ==================
researcher_agent = create_agent("研究员", "分析GDP趋势")
calculator_agent = create_agent("计算器", "执行增长率计算")
writer_agent = create_agent("作家", "生成最终报告（完成后必须添加[END]标识）")

# ================== 工作流配置 ==================
builder = StateGraph(AgentState)

builder.add_node("supervisor", supervisor)
builder.add_node("researcher", researcher_agent)
builder.add_node("calculator", calculator_agent)
builder.add_node("writer", writer_agent)

builder.add_conditional_edges(
    "supervisor",
    lambda state: state.next_agent,
    {
        "researcher": "researcher",
        "calculator": "calculator",
        "writer": "writer",
        "done": END
    }
)

for agent in ["researcher", "calculator", "writer"]:
    builder.add_edge(agent, "supervisor")

builder.set_entry_point("supervisor")
workflow = builder.compile()

# ================== 执行测试 ==================
if __name__ == "__main__":
    test_input = AgentState(
        messages=[{"role": "user", "content": "成都市GDP增长率分析"}]
    )
    
    try:
        for step in workflow.stream(test_input):
            node_name = list(step.keys())[0]
            state = step[node_name]
            
            print(f"\n[系统状态] 当前节点: {node_name}")
            print(f"[状态] next_agent: {state.get('next_agent')}")
            print(f"[状态] step_count: {state.get('step_count')}")
            
            if node_name == "__end__":
                print("\n====== 流程正常终止 ======")
                if state.messages:
                    print("最终报告：")
                    print(state.messages[-1].content)
                break
                
    except Exception as e:
        print(f"\n!!! 流程异常终止: {str(e)}")

输出：

root@autodl-container-01074f9e9d-c86e91af:~/autodl-tmp/model/demo_26# python test04.py

sys:1: LangChainDeprecationWarning: As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. The langchain_core.pydantic_v1 module was a compatibility shim for pydantic v1, and should no longer be used. Please update the code to import from Pydantic directly.

For example, replace imports like: from langchain_core.pydantic_v1 import BaseModel

with: from pydantic import BaseModel

or the v1 compatibility namespace if you are working in a code base that has not been fully upgraded to pydantic 2 yet. from pydantic.v1 import BaseModel