多智能体系统

一个 agent 是一个使用 LLM 来决定应用程序控制流的系统。随着您开发这些系统，它们可能会随着时间的推移变得更加复杂，使其更难管理和扩展。例如，您可能会遇到以下问题

• agent 拥有太多工具，以至于在决定下一步调用哪个工具时做出错误决策
• 上下文变得过于复杂，单个 agent 无法跟踪
• 系统中需要多个专业领域（例如，规划器、研究员、数学专家等）

为了解决这些问题，您可以考虑将您的应用程序分解为多个更小的、独立的 agent，并将它们组合成一个 多智能体系统。这些独立的 agent 可以像提示和 LLM 调用一样简单，也可以像 ReAct agent（以及更多！）一样复杂。

使用多智能体系统的主要优点是

• 模块化：独立的 agent 使开发、测试和维护 agent 系统变得更容易。
• 专业化：您可以创建专注于特定领域的专家 agent，这有助于提高整体系统性能。
• 控制：您可以显式控制 agent 如何通信（而不是依赖于函数调用）。

多智能体架构

有几种方法可以在多智能体系统中连接 agent

• 网络：每个 agent 都可以与其他每个 agent 通信。任何 agent 都可以决定下一步调用哪个其他 agent。
• 主管：每个 agent 都与单个 主管 agent 通信。主管 agent 决定下一步应该调用哪个 agent。
• 分层：您可以定义一个具有主管的主管的多智能体系统。这是主管架构的概括，允许更复杂的控制流。
• 自定义多智能体工作流：每个 agent 仅与 agent 的子集通信。流程的某些部分是确定性的，只有一些 agent 可以决定下一步调用哪个其他 agent。

交接

在多智能体架构中，agent 可以表示为图节点。每个 agent 节点执行其步骤，并决定是完成执行还是路由到另一个 agent，包括可能路由到自身（例如，在循环中运行）。多智能体交互中的常见模式是交接，其中一个 agent 将控制权交给另一个 agent。交接允许您指定

• 目标：要导航到的目标 agent（例如，要转到的节点的名称）
• 负载：要传递给该 agent 的信息（例如，状态更新）

为了在 LangGraph 中实现交接，agent 节点可以返回 Command 对象，该对象允许您组合控制流和状态更新

const agent = (state: typeof StateAnnotation.State) => {
  const goto = getNextAgent(...)  // 'agent' / 'another_agent'
  return new Command({
    // Specify which agent to call next
    goto: goto,
    // Update the graph state
    update: {
      foo: "bar",
    }
  });
};

在更复杂的场景中，每个 agent 节点本身就是一个图（即，一个 子图），一个 agent 子图中的节点可能想要导航到不同的 agent。例如，如果您有两个 agent，alice 和 bob（父图中的子图节点），并且 alice 需要导航到 bob，您可以在 Command 对象中设置 graph=Command.PARENT

const some_node_inside_alice = (state) => {
    return new Command({
      goto: "bob",
      update: {
          foo: "bar",
      },
      // specify which graph to navigate to (defaults to the current graph)
      graph: Command.PARENT,
    })
}

网络

在这种架构中，agent 被定义为图节点。每个 agent 都可以与其他每个 agent 通信（多对多连接），并且可以决定下一步调用哪个 agent。这种架构适用于没有清晰的 agent 层级结构或 agent 应该被调用的特定顺序的问题。

import {
  StateGraph,
  Annotation,
  MessagesAnnotation,
  Command
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4o-mini",
});

const agent1 = async (state: typeof MessagesAnnotation.State) => {
  // you can pass relevant parts of the state to the LLM (e.g., state.messages)
  // to determine which agent to call next. a common pattern is to call the model
  // with a structured output (e.g. force it to return an output with a "next_agent" field)
  const response = await model.withStructuredOutput(...).invoke(...);
  return new Command({
    update: {
      messages: [response.content],
    },
    goto: response.next_agent,
  });
};

const agent2 = async (state: typeof MessagesAnnotation.State) => {
  const response = await model.withStructuredOutput(...).invoke(...);
  return new Command({
    update: {
      messages: [response.content],
    },
    goto: response.next_agent,
  });
};

const agent3 = async (state: typeof MessagesAnnotation.State) => {
  ...
  return new Command({
    update: {
      messages: [response.content],
    },
    goto: response.next_agent,
  });
};

const graph = new StateGraph(MessagesAnnotation)
  .addNode("agent1", agent1, {
    ends: ["agent2", "agent3" "__end__"],
  })
  .addNode("agent2", agent2, {
    ends: ["agent1", "agent3", "__end__"],
  })
  .addNode("agent3", agent3, {
    ends: ["agent1", "agent2", "__end__"],
  })
  .addEdge("__start__", "agent1")
  .compile();

主管

在这种架构中，我们将 agent 定义为节点，并添加一个主管节点（LLM），该节点决定下一步应该调用哪些 agent 节点。我们使用 Command 根据主管的决策将执行路由到适当的 agent 节点。这种架构也很适合并行运行多个 agent 或使用 map-reduce 模式。

import {
  StateGraph,
  MessagesAnnotation,
  Command,
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4o-mini",
});

const supervisor = async (state: typeof MessagesAnnotation.State) => {
  // you can pass relevant parts of the state to the LLM (e.g., state.messages)
  // to determine which agent to call next. a common pattern is to call the model
  // with a structured output (e.g. force it to return an output with a "next_agent" field)
  const response = await model.withStructuredOutput(...).invoke(...);
  // route to one of the agents or exit based on the supervisor's decision
  // if the supervisor returns "__end__", the graph will finish execution
  return new Command({
    goto: response.next_agent,
  });
};

const agent1 = async (state: typeof MessagesAnnotation.State) => {
  // you can pass relevant parts of the state to the LLM (e.g., state.messages)
  // and add any additional logic (different models, custom prompts, structured output, etc.)
  const response = await model.invoke(...);
  return new Command({
    goto: "supervisor",
    update: {
      messages: [response],
    },
  });
};

const agent2 = async (state: typeof MessagesAnnotation.State) => {
  const response = await model.invoke(...);
  return new Command({
    goto: "supervisor",
    update: {
      messages: [response],
    },
  });
};

const graph = new StateGraph(MessagesAnnotation)
  .addNode("supervisor", supervisor, {
    ends: ["agent1", "agent2", "__end__"],
  })
  .addNode("agent1", agent1, {
    ends: ["supervisor"],
  })
  .addNode("agent2", agent2, {
    ends: ["supervisor"],
  })
  .addEdge("__start__", "supervisor")
  .compile();

查看此 教程，了解主管多智能体架构的示例。

自定义多智能体工作流

在这种架构中，我们将各个 agent 添加为图节点，并预先定义 agent 被调用的顺序，在一个自定义工作流中。在 LangGraph 中，工作流可以通过两种方式定义

• 显式控制流（普通边）：LangGraph 允许您通过 普通图边 显式定义应用程序的控制流（即 agent 通信的顺序）。这是上述架构中最具确定性的变体 — 我们始终预先知道下一步将调用哪个 agent。

• 动态控制流（条件边）：在 LangGraph 中，您可以允许 LLM 决定应用程序控制流的部分内容。这可以通过使用 Command 来实现。

import {
  StateGraph,
  MessagesAnnotation,
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4o-mini",
});

const agent1 = async (state: typeof MessagesAnnotation.State) => {
  const response = await model.invoke(...);
  return { messages: [response] };
};

const agent2 = async (state: typeof MessagesAnnotation.State) => {
  const response = await model.invoke(...);
  return { messages: [response] };
};

const graph = new StateGraph(MessagesAnnotation)
  .addNode("agent1", agent1)
  .addNode("agent2", agent2)
  // define the flow explicitly
  .addEdge("__start__", "agent1")
  .addEdge("agent1", "agent2")
  .compile();

Agent 之间的通信

构建多智能体系统时，最重要的事情是弄清楚 agent 如何通信。有几个不同的考虑因素

• 如果两个 agent 具有 不同的状态模式 怎么办？
• 如何通过 共享消息列表 进行通信？

图状态

为了通过图状态进行通信，各个 agent 需要定义为 图节点。这些可以作为函数或作为整个 子图 添加。在图执行的每个步骤中，agent 节点接收图的当前状态，执行 agent 代码，然后将更新后的状态传递给下一个节点。

通常，agent 节点共享一个 状态模式。但是，您可能希望设计具有 不同状态模式 的 agent 节点。

不同的状态模式

一个 agent 可能需要具有与其余 agent 不同的状态模式。例如，搜索 agent 可能只需要跟踪查询和检索到的文档。在 LangGraph 中，有两种方法可以实现这一点

• 定义具有单独状态模式的 子图 agent。如果子图和父图之间没有共享状态键（通道），则重要的是 添加输入/输出转换，以便父图知道如何与子图通信。
• 定义具有 私有输入状态模式 的 agent 节点函数，该模式与整体图状态模式不同。这允许传递仅执行该特定 agent 所需的信息。

共享消息列表

agent 通信的最常见方式是通过共享状态通道，通常是消息列表。这假设状态中始终至少有一个 agent 共享的通道（键）。当通过共享消息列表进行通信时，还有一个额外的考虑因素：agent 应该 共享其思考过程的完整历史记录 还是仅 共享最终结果？

共享完整历史记录

Agent 可以与其他所有 agent 共享其思考过程的完整历史记录（即“草稿本”）。这个“草稿本”通常看起来像一个 消息列表。共享完整思考过程的好处是，它可能有助于其他 agent 做出更好的决策，并提高整个系统的推理能力。缺点是，随着 agent 数量及其复杂性的增加，“草稿本”将快速增长，并且可能需要额外的 内存管理 策略。

共享最终结果

Agent 可以拥有自己的私有“草稿本”，并且仅与其余 agent 共享最终结果。这种方法可能更适用于具有许多 agent 或更复杂的 agent 的系统。在这种情况下，您需要定义具有 不同状态模式 的 agent

对于作为工具调用的 agent，主管根据工具模式确定输入。此外，LangGraph 允许在运行时将 状态传递给各个工具，因此如果需要，下级 agent 可以访问父状态。