使用LangGraph构建多Agent系统

最新推荐文章于 2025-04-21 16:47:45 发布

少喝冰美式

最新推荐文章于 2025-04-21 16:47:45 发布

阅读量1k

点赞数 19

文章标签：人工智能数据库 AI大模型大模型技术 LangGraph Agent AI

本文链接：https://blog.csdn.net/python12222_/article/details/145300654

版权

使用LangGraph构建多代理系统

0.完整工作流

在这里插入图片描述

1.开发代码

环境变量

# open ai的相关环境变量
OPENAI_API_KEY=xxx
OPENAI_BASE_URL=https://api.openai-hk.com/v1

# LangSmith的环境变量，方便去LangSmith看执行过程
LANGCHAIN_TRACING_V2=xxx
LANGCHAIN_ENDPOINT=xxx
LANGCHAIN_API_KEY=xxx
LANGCHAIN_PROJECT=xxx

# 搜索用的
TAVILY_API_KEY=xxx 环境变量

构建通用的agent

# 导入基本消息类、用户消息类和工具消息类
from langchain_core.messages import (
    HumanMessage
)
# 导入聊天提示模板和消息占位符
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 定义一个函数，用于创建代理
def create_agent(llm, tools, system_message: str):
    """创建一个代理。"""
    # 创建一个聊天提示模板
    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "你是一个有帮助的AI助手，与其他助手合作。"
                " 使用提供的工具来推进问题的回答。"
                " 如果你不能完全回答，没关系，另一个拥有不同工具的助手"
                " 会接着你的位置继续帮助。执行你能做的以取得进展。"
                " 如果你或其他助手有最终答案或交付物，"
                " 在你的回答前加上FINAL ANSWER，以便团队知道停止。"
                " 你可以使用以下工具: {tool_names}。\n{system_message}",
            ),  # 系统消息
            # 消息占位符 
            MessagesPlaceholder(variable_name="messages"),
        ]
    )
    # 传递系统消息参数
    prompt = prompt.partial(system_message=system_message)
    # 传递工具名称参数
    prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))

    # 返回RunnableSequence，先用消息messages填充提示词，再llm_with_tools进行调用 (类型是：langchain_core.runnables.base.RunnableSequence)
    return prompt | llm.bind_tools(tools)

构建通用的agent节点

# 辅助函数，用于为给定的代理创建节点
from langchain_core.messages import ToolMessage, AIMessage

"""
图的agent节点。决定做什么操作(也就是调用下llm)
1.把历史消息放入提示词，然后让llm回答。(此时的state里就有历史消息，也就是messages，而sender再字典里，也无关紧要，虽然传入进去了，但是底层没用)
2.返回消息和发送方
"""

def agent_node(state, agent, name):
    # 调用代理
    result = agent.invoke(state)
    # 将代理输出转换为适合附加到全局状态的格式
    if isinstance(result, ToolMessage):
        pass
    else:
        # 先result.dict(exclude={"type", "name"}) 返回一个去除type和name的字典，然后通过**变成关键字参数，最后把name传进去
        # 相当于曲线救国，把消息的name改成了。
        result = AIMessage(**result.dict(exclude={"type", "name"}), name=name)

    return {
        "messages": [result],  # 会追加到消息后边
        # 由于我们有一个严格的工作流程，我们可以
        # 跟踪发送者，以便知道下一个传递给谁。
        "sender": name,
    }

构建tool

# 导入注解类型
from typing import Annotated

# 导入Tavily搜索工具
from langchain_community.tools.tavily_search import TavilySearchResults
# 导入工具装饰器
from langchain_core.tools import tool
# 导入Python REPL工具
from langchain_experimental.utilities import PythonREPL

# 创建Tavily搜索工具实例，设置最大结果数为5
tavily_tool = TavilySearchResults(max_results=5)

# 警告：这会在本地执行代码，未沙箱化时可能不安全
# 创建Python REPL实例
repl = PythonREPL()

# 定义一个工具函数，用于执行Python代码
@tool
def python_repl(
        code: Annotated[str, "要执行以生成图表的Python代码。并保存到本地plt.png。"],
):
    """使用这个工具来执行Python代码。如果你想查看某个值的输出，
    应该使用print(...)。这个输出对用户可见。"""
    try:
        # 尝试执行代码
        result = repl.run(code)
    except BaseException as e:
        # 捕捉异常并返回错误信息
        return f"执行失败。错误: {repr(e)}"
    # 返回执行结果
    result_str = f"成功执行:\n```python\n{code}\n```\nStdout: {result}"
    return (
            result_str + "\n\n如果你已完成所有任务，请回复FINAL ANSWER。"
    )

构建agent路由

from typing import Literal

# 定义路由器函数
def router(state) -> Literal["call_tool", "__end__", "other_agent"]:
    # 这是路由器
    messages = state["messages"]
    last_message = messages[-1]
    if last_message.tool_calls:
        # 上一个代理正在调用工具
        return "call_tool"
    if "FINAL ANSWER" in last_message.content:  # 刚开始的提示词里指定了以FINAL ANSWER为结束标志
        # 任何代理决定工作完成
        return "__end__"
    return "other_agent"

核心代码

from dotenv import load_dotenv

# 先加载环境变量，默认是找当前目录下的.env文件
load_dotenv()

# 导入操作符和类型注解
import functools
import operator
from typing import Annotated, Sequence, TypedDict
from langchain_core.messages import BaseMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph

from build_agent import create_agent
from build_tool import tavily_tool, python_repl
from build_agent_node import agent_node
from build_router import router
from langgraph.prebuilt import ToolNode
from langgraph.graph import END, START

# 定义一个对象，用于在图的每个节点之间传递
# 我们将为每个代理和工具创建不同的节点
class AgentState(TypedDict):
    # 添加operator.add注解，相当于每次把消息列表加起来。变相的追加而已。
    messages: Annotated[Sequence[BaseMessage], operator.add]
    sender: str

# 创建OpenAI聊天模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 查询的agent，用的时候给他送入消息就行
research_agent = create_agent(
    llm,
    [tavily_tool],
    system_message="你应该提供准确的数据供chart_generator使用。",
)

# 创建查询节点，指定对应的agent   functools.partial是会生成一个函数，函数为agent_node，指定参数agent和name
research_node = functools.partial(agent_node, agent=research_agent, name="Researcher")

# 图表生成的agent
chart_agent = create_agent(
    llm,
    [python_repl],
    system_message="你展示的任何图表都将对用户可见。",
)

# 创建图表生成节点，指定对应的agent
chart_node = functools.partial(agent_node, agent=chart_agent, name="chart_generator")

# 定义工具列表
tools = [tavily_tool, python_repl]
# 创建工具节点
tool_node = ToolNode(tools)

# -------------创建图---------------

# 创建状态图实例
workflow = StateGraph(AgentState)

# 添加搜索节点
workflow.add_node("Researcher", research_node)
# 添加图表生成器节点
workflow.add_node("chart_generator", chart_node)
# 添加工具调用节点
workflow.add_node("call_tool", tool_node)

# 添加起始边
workflow.add_edge(START, "Researcher")

# 添加条件边 (三种情况，结束，调用工具，调用其他代理)
workflow.add_conditional_edges(
    "Researcher",
    router,
    {"other_agent": "chart_generator", "call_tool": "call_tool", "__end__": END},
)
workflow.add_conditional_edges(
    "chart_generator",
    router,
    {"other_agent": "Researcher", "call_tool": "call_tool", "__end__": END},
)

# 添加条件边，工具调用结束后，需要返回到哪里。
workflow.add_conditional_edges(
    source="call_tool",
    # 每个代理节点更新'sender'字段
    # 工具调用节点不更新，这意味着
    # 该边将路由回调用工具的原始代理
    path=lambda x: x["sender"],  # 发送方是谁，就返回到哪里

    path_map={  # 根据path进行路由，防止sender和具体的节点名字不一样的情况
        "Researcher": "Researcher",
        "chart_generator": "chart_generator",
    },
)

# 编译工作流图
graph = workflow.compile()

# 将生成的图片保存到文件
graph_png = graph.get_graph().draw_mermaid_png()
with open("build_graph.png", "wb") as f:
    f.write(graph_png)

# 事件流
events = graph.stream(
    {
        "messages": [
            HumanMessage(
                content="获取过去5年AI软件市场规模，"
                        " 然后绘制一条折线图。"
                        " 一旦你编写好代码，完成任务。"
            )
        ],
    },
    # 图中最多执行的步骤数
    {"recursion_limit": 150},
)
# 打印事件流中的每个状态
for s in events:
    print(s)
    print("----")