构建多智能代理系统¶

单个智能代理如果需要在多个领域进行专业化处理或管理大量工具时可能会遇到困难。为了解决这个问题，你可以将智能代理拆分为更小的独立智能代理，并将它们组合成一个多智能代理系统。

在多智能代理系统中，智能代理之间需要相互通信。它们通过交接来实现这一点——这是一个原语，用于描述将控制权交给哪个智能代理以及发送给该智能代理的有效负载。

本指南涵盖以下内容：

实现智能代理之间的交接
使用交接和预构建的智能代理来构建自定义多智能代理系统

要开始构建多智能代理系统，请查看 LangGraph 预构建实现中两种最流行的多智能代理架构——supervisor 和 swarm。

交接¶

要在多智能代理系统中设置智能代理之间的通信，你可以使用交接——一种模式，其中一个智能代理将控制权*交接*给另一个智能代理。交接允许你指定：

destination（目标）：要导航到的目标智能代理（例如，要跳转到的 LangGraph 节点名称）
payload（有效负载）：要传递给该智能代理的信息（例如，状态更新）

创建交接¶

要实现交接，你可以从智能代理节点或工具中返回 Command 对象：

Python

from typing import Annotated
from langchain_core.tools import tool, InjectedToolCallId
from langgraph.prebuilt import create_react_agent, InjectedState
from langgraph.graph import StateGraph, START, MessagesState
from langgraph.types import Command

def create_handoff_tool(*, agent_name: str, description: str | None = None):
    name = f"transfer_to_{agent_name}"
    description = description or f"Transfer to {agent_name}"

    @tool(name, description=description)
    def handoff_tool(
        # highlight-next-line
        state: Annotated[MessagesState, InjectedState], # (1)!
        # highlight-next-line
        tool_call_id: Annotated[str, InjectedToolCallId],
    ) -> Command:
        tool_message = {
            "role": "tool",
            "content": f"Successfully transferred to {agent_name}",
            "name": name,
            "tool_call_id": tool_call_id,
        }
        return Command(  # (2)!
            # highlight-next-line
            goto=agent_name,  # (3)!
            # highlight-next-line
            update={"messages": state["messages"] + [tool_message]},  # (4)!
            # highlight-next-line
            graph=Command.PARENT,  # (5)!
        )
    return handoff_tool

使用 @[InjectedState] 注解访问调用交接工具的智能代理的状态。
Command 原语允许将状态更新和节点转换指定为单个操作，使其非常适合实现交接。
要交接到的智能代理或节点的名称。
获取智能代理的消息并将它们**添加**到父级的**状态**中作为交接的一部分。下一个智能代理将看到父级状态。
向 LangGraph 指示我们需要导航到**父级**多智能代理图中的智能代理节点。

Tip

如果你想使用返回 Command 的工具，可以使用预构建的 @[create_react_agent][] / @[ToolNode][] 组件，或者实现自己的工具执行节点来收集工具返回的 Command 对象并返回它们的列表，例如：

def call_tools(state):
    ...
    commands = [tools_by_name[tool_call["name"]].invoke(tool_call) for tool_call in tool_calls]
    return commands

JavaScript

import { tool } from "@langchain/core/tools";
import { Command, MessagesZodState } from "@langchain/langgraph";
import { z } from "zod";

function createHandoffTool({
  agentName,
  description,
}: {
  agentName: string;
  description?: string;
}) {
  const name = `transfer_to_${agentName}`;
  const toolDescription = description || `Transfer to ${agentName}`;

  return tool(
    async (_, config) => {
      // (1)!
      const state = config.state;
      const toolCallId = config.toolCall.id;

      const toolMessage = {
        role: "tool" as const,
        content: `Successfully transferred to ${agentName}`,
        name: name,
        tool_call_id: toolCallId,
      };

      return new Command({
        // (3)!
        goto: agentName,
        // (4)!
        update: { messages: [...state.messages, toolMessage] },
        // (5)!
        graph: Command.PARENT,
      });
    },
    {
      name,
      description: toolDescription,
      schema: z.object({}),
    }
  );
}

通过 config 参数访问调用交接工具的智能代理的状态。
Command 原语允许将状态更新和节点转换指定为单个操作，使其非常适合实现交接。
要交接到的智能代理或节点的名称。
获取智能代理的消息并将它们**添加**到父级的**状态**中作为交接的一部分。下一个智能代理将看到父级状态。
向 LangGraph 指示我们需要导航到**父级**多智能代理图中的智能代理节点。

Tip

如果你想使用返回 Command 的工具，可以使用预构建的 @[create_react_agent][] / @[ToolNode][] 组件，或者实现自己的工具执行节点来收集工具返回的 Command 对象并返回它们的列表，例如：

const callTools = async (state) => {
  // ...
  const commands = await Promise.all(
    toolCalls.map(toolCall => toolsByName[toolCall.name].invoke(toolCall))
  );
  return commands;
};

Important

此交接实现假设：

每个智能代理接收多智能代理系统中的整体消息历史（跨所有智能代理）作为其输入。如果你想对智能代理输入有更多控制，请参阅此部分
每个智能代理将其内部消息历史输出到多智能代理系统的整体消息历史中。如果你想对**智能代理输出的添加方式有更多控制**，请将智能代理包装在单独的节点函数中：

=== "Python"

def call_hotel_assistant(state):
    # 返回智能代理的最终响应，
    # 排除内部独白
    response = hotel_assistant.invoke(state)
    # highlight-next-line
    return {"messages": response["messages"][-1]}

=== "JavaScript"

const callHotelAssistant = async (state) => {
  // 返回智能代理的最终响应，
  // 排除内部独白
  const response = await hotelAssistant.invoke(state);
  // highlight-next-line
  return { messages: [response.messages.at(-1)] };
};

控制智能代理输入¶

Python

你可以使用 @[Send()][Send] 原语在交接期间直接向工作智能代理发送数据。例如，你可以请求调用智能代理为下一个智能代理填充任务描述：

from typing import Annotated
from langchain_core.tools import tool, InjectedToolCallId
from langgraph.prebuilt import InjectedState
from langgraph.graph import StateGraph, START, MessagesState
# highlight-next-line
from langgraph.types import Command, Send

def create_task_description_handoff_tool(
    *, agent_name: str, description: str | None = None
):
    name = f"transfer_to_{agent_name}"
    description = description or f"Ask {agent_name} for help."

    @tool(name, description=description)
    def handoff_tool(
        # 这由调用智能代理填充
        task_description: Annotated[
            str,
            "Description of what the next agent should do, including all of the relevant context.",
        ],
        # 这些参数被 LLM 忽略
        state: Annotated[MessagesState, InjectedState],
    ) -> Command:
        task_description_message = {"role": "user", "content": task_description}
        agent_input = {**state, "messages": [task_description_message]}
        return Command(
            # highlight-next-line
            goto=[Send(agent_name, agent_input)],
            graph=Command.PARENT,
        )

    return handoff_tool

JavaScript

你可以使用 @[Send()][Send] 原语在交接期间直接向工作智能代理发送数据。例如，你可以请求调用智能代理为下一个智能代理填充任务描述：

import { tool } from "@langchain/core/tools";
import { Command, Send, MessagesZodState } from "@langchain/langgraph";
import { z } from "zod";

function createTaskDescriptionHandoffTool({
  agentName,
  description,
}: {
  agentName: string;
  description?: string;
}) {
  const name = `transfer_to_${agentName}`;
  const toolDescription = description || `Ask ${agentName} for help.`;

  return tool(
    async (
      { taskDescription },
      config
    ) => {
      const state = config.state;

      const taskDescriptionMessage = {
        role: "user" as const,
        content: taskDescription,
      };
      const agentInput = {
        ...state,
        messages: [taskDescriptionMessage],
      };

      return new Command({
        // highlight-next-line
        goto: [new Send(agentName, agentInput)],
        graph: Command.PARENT,
      });
    },
    {
      name,
      description: toolDescription,
      schema: z.object({
        taskDescription: z
          .string()
          .describe(
            "Description of what the next agent should do, including all of the relevant context."
          ),
      }),
    }
  );
}

请参阅多智能代理 supervisor 示例，了解在交接中使用 @[Send()][Send] 的完整示例。