「智能体开发入门」LangChain 支持的哪些 Agent 编排模式？LangChain.js是一个智能体开发框架，可

LangChain.js是一个智能体开发框架，可以实现很多功能。而且它提供了很多中间件，让智能体支持多种编排模式，学习这些编排模式，可以让你更好的理解智能体的搭建和设计过程。

📦 一、现代架构（基于 LangGraph + createAgent）

1️⃣ ReAct Agent（推荐）

最强大的现代 Agent 模式，基于 LangGraph 状态图。

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [searchTool, calculatorTool, weatherTool],
  systemPrompt: "You are a helpful assistant.",
});

特点：

✅ 完整的状态管理（StateGraph）
✅ 中间件系统（17+ 内置中间件）
✅ 流式输出支持
✅ 结构化输出（Zod schema）
✅ 人机协作（HITL）
✅ 检查点持久化
✅ 时间旅行调试

执行流程：

思考 → 行动 → 观察 → 思考 → 行动 → ... → 结束

2️⃣ Supervisor Pattern（监督者模式）

多 Agent 协作的经典模式。

// 子 Agent
const calendarAgent = createAgent({
  model: llm,
  tools: [createCalendarEvent, getAvailableTimeSlots],
  systemPrompt: "You are a calendar assistant.",
});

const emailAgent = createAgent({
  model: llm,
  tools: [sendEmail],
  systemPrompt: "You are an email assistant.",
});

// 将子 Agent 包装为工具
const scheduleEvent = tool(
  async ({ request }) => {
    const result = await calendarAgent.invoke({
      messages: [{ role: "user", content: request }],
    });
    return result.messages[result.messages.length - 1].text;
  },
  {
    name: "schedule_event",
    description: "Schedule calendar events",
    schema: z.object({ request: z.string() }),
  }
);

// 监督者 Agent
const supervisorAgent = createAgent({
  model: llm,
  tools: [scheduleEvent, manageEmail], // 子 Agent 作为工具
  systemPrompt: "You coordinate between calendar and email.",
});

特点：

🎯 一个监督者协调多个专业 Agent
🔄 子 Agent 通过工具接口调用
📋 适合任务分解和委派
🔐 支持人机审批（HITL）

使用场景：

客服系统（路由到专业 Agent）
项目管理（任务分配）
复杂流程编排

3️⃣ Plan-and-Execute（通过中间件实现）

使用 todoListMiddleware 实现计划-执行模式。

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [searchTool, fileTool, analysisTool],
  middleware: [
    todoListMiddleware(), // 自动任务规划
  ],
});

执行流程：

1. 用户请求：「帮我重构代码库」
   ↓
2. Agent 调用 write_todos 创建任务列表：
   - [ ] 分析代码结构
   - [ ] 识别重复代码
   - [ ] 提取公共函数
   - [ ] 更新导入路径
   ↓
3. Agent 逐步执行并更新状态：
   - [✓] 分析代码结构
   - [⏳] 识别重复代码
   - [ ] 提取公共函数
   - [ ] 更新导入路径

特点：

📝 自动任务分解
📊 进度追踪
🔄 状态更新
🎯 适合复杂多步骤任务

4️⃣ Tool Selector Pattern（工具选择模式）

使用 llmToolSelectorMiddleware 进行智能工具筛选。

const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [
    // 100+ 个工具
    searchTool, fileTool, databaseTool, apiTool, ...
  ],
  middleware: [
    llmToolSelectorMiddleware({
      model: "openai:gpt-4o-mini", // 轻量级模型筛选
      maxTools: 5, // 最多选择 5 个工具
      selectionPrompt: "Select the most relevant tools for the task",
    }),
  ],
});

执行流程：

用户查询
  ↓
1. 选择器 LLM 分析查询
2. 从 100+ 工具中筛选出 5 个相关工具
3. 主 LLM 只看到筛选后的 5 个工具
4. 执行工具调用

特点：

🎯 减少 token 消耗
⚡ 提高推理速度
🔧 支持大规模工具库
📊 避免工具选择困惑

5️⃣ 自定义 LangGraph构建复杂工作流

以前也说过，langchain的底层依赖LangGraph实现智能体的编排。而LangGraph特别搭建构建工作流。

下面是一个简单的案例。

import { StateGraph, END } from "@langchain/langgraph";

const workflow = new StateGraph({
  channels: {
    messages: { reducer: (x, y) => x.concat(y) },
    nextAgent: { reducer: (x, y) => y ?? x },
  },
});

// 添加节点
workflow.addNode("researcher", researcherAgent);
workflow.addNode("writer", writerAgent);
workflow.addNode("reviewer", reviewerAgent);

// 添加边和条件路由
workflow.addEdge("__start__", "researcher");
workflow.addConditionalEdges("researcher", (state) => {
  if (state.researchComplete) return "writer";
  return "researcher";
});
workflow.addEdge("writer", "reviewer");
workflow.addConditionalEdges("reviewer", (state) => {
  if (state.approved) return END;
  return "writer"; // 返工
});

const app = workflow.compile();

特点：

🔄 完全自定义工作流
📊 复杂状态管理
🎯 条件分支路由
🔁 循环和反馈
💾 检查点支持

🎨 二、中间件增强的特殊模式

基于 createAgent + 中间件组合实现的高级模式：

1️⃣ Human-in-the-Loop（HITL）

让 AI Agent 在执行关键操作前暂停并等待人工审批，确保安全性和可控性。

humanInTheLoopMiddleware({
  interruptOn: {
    send_email: true, // 发送邮件前需要审批
    delete_file: { allowedDecisions: ["approve", "edit", "reject"] },
  },
})

2️⃣ Model Fallback（模型降级）

用于在主模型调用失败时自动按顺序尝试备用模型，提高系统的容错性。

自动回退：主模型失败时，按顺序尝试备用模型
顺序执行：按传入顺序依次尝试，直到成功或全部失败

modelFallbackMiddleware(
    "openai:gpt-4o",
    "openai:gpt-4o-mini", // 备用
    "anthropic:claude-3-5-sonnet", // 再备用
)

3️⃣ Context Editing（上下文管理）

用于在对话超过 token 阈值时自动清理旧的工具结果，从而管理上下文大小。它参考了 Anthropic 的上下文编辑能力，可用于任何 LangChain 聊天模型。

自动清理：当 token 数超过阈值时，自动清理旧的工具结果
保留最近结果：保留最近的 N 个工具结果（默认 3 个）
可配置策略：支持自定义编辑策略，可扩展
工具排除：可排除特定工具，避免被清理
可选清理工具输入：可选择是否同时清理工具调用的参数

import { contextEditingMiddleware, ClearToolUsesEdit } from "langchain";

const agent = createAgent({
  model: "anthropic:claude-3-5-sonnet",
  tools: [searchTool, calculatorTool],
  middleware: [
    contextEditingMiddleware({
      edits: [
        new ClearToolUsesEdit({
          triggerTokens: 50000,      // 超过 50K tokens 时触发
          clearAtLeast: 1000,         // 至少回收 1K tokens
          keep: 5,                    // 保留最近 5 个工具结果
          excludeTools: ["search"],   // 不清理 search 工具的结果
          clearToolInputs: true,      // 同时清理工具调用参数
        }),
      ],
      tokenCountMethod: "approx",     // 使用近似计数（或 "model"）
    }),
  ],
});

4️⃣ Summarization（历史压缩）

用于在对话历史接近 token 限制时自动总结历史消息，保留最近的消息并压缩旧消息，从而控制 token 使用并保持上下文连续性。

自动监控：在每次模型调用前检查消息的 token 数量
智能总结：当 token 超过阈值时，自动总结旧消息
保持上下文：确保 AI/Tool 消息对不被拆分，保持对话的完整性
保留最近消息：保留最近的 N 条消息（默认 20 条），确保最新上下文不丢失

summarizationMiddleware({
  model: "openai:gpt-4o-mini",
  maxTokensBeforeSummary: 50000,
  messagesToKeep: 5,
})

5️⃣ PII Redaction（敏感信息脱敏）

piiRedactionMiddleware({
  redact: ["email", "phone", "ssn", "credit_card"],
  model: "openai:gpt-4o",
})

6️⃣ Tool Retry（工具重试）

toolRetryMiddleware({
  maxRetries: 3,
  retryOn: ["NetworkError", "Timeout"],
})

7️⃣ Call Limit（调用限制）

callLimitMiddleware({
  maxCalls: 10, // 最多 10 次模型调用
})

8️⃣ Prompt Caching（提示缓存）

anthropicPromptCachingMiddleware({
  cacheSystemPrompt: true,
  cacheTools: true,
})

📚 三、经典架构（langchain-classic）

这些是遗留的 Agent 类型，功能较简单但仍可用。

1️⃣ ReAct Agent（经典版）

import { createReactAgent } from "langchain/agents";

const agent = createReactAgent({
  llm: model,
  tools: [searchTool, calculatorTool],
  prompt: reactPrompt,
});

const executor = new AgentExecutor({ agent, tools });

2️⃣ Structured Chat Agent

import { createStructuredChatAgent } from "langchain/agents";

const agent = createStructuredChatAgent({
  llm: model,
  tools: [complexTool],
  prompt: structuredPrompt,
});

3️⃣ OpenAI Functions Agent

import { createOpenAIFunctionsAgent } from "langchain/agents";

const agent = createOpenAIFunctionsAgent({
  llm: model, // OpenAI 模型
  tools: [weatherTool],
  prompt: functionsPrompt,
});

4️⃣ Tool Calling Agent

import { createToolCallingAgent } from "langchain/agents";

const agent = createToolCallingAgent({
  llm: model,
  tools: [searchTool],
  prompt: toolCallingPrompt,
});

5️⃣ XML Agent

import { createXMLAgent } from "langchain/agents";

const agent = createXMLAgent({
  llm: model, // Anthropic Claude
  tools: [xmlTool],
  prompt: xmlPrompt,
});

6️⃣ 对话式 Agent

import { ConversationalRetrievalQAChain } from "langchain/chains";

const chain = ConversationalRetrievalQAChain.fromLLM(
  model,
  vectorStore.asRetriever(),
  { memory }
);

7️⃣ SQL Agent

import { createSQLAgent } from "langchain/agents/toolkits/sql";

const toolkit = new SqlToolkit(db, model);
const executor = createSQLAgent(model, toolkit);

我也只是试验了一部分，例如HITL、Plan等，不过学习这些架构的设计，可以给自己开发的过程中提供很多灵感。