智能体

智能体（Agent）是一个循环调用工具的模型，直到给定任务完成。核心智能体循环示意图

脚手架（Harness）是围绕该循环的一切：提示词、工具以及任何塑造模型行为的中间件。

智能体 = 模型 + 脚手架脚手架的职责是：在正确的时间为给定任务提供正确的上下文给模型。

@@MDX_PRESERVE_1@@ create_agent 是一个高度可配置的脚手架。最简单的情况下，你可以用以下方式创建一个：

import { createAgent } from "langchain";

var agent = createAgent({ model: "google-genai:gemini-3.6-flash", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "openai:gpt-5.5", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "anthropic:claude-sonnet-4-6", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "openrouter:openrouter:z-ai/glm-5.2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "fireworks:accounts/fireworks/models/glm-5p2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "baseten:zai-org/GLM-5.2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "ollama:north-mini-code-1.0", tools });

在此基础上，你可以直接使用 model=、tools= 和 system_prompt= 参数配置基础功能。要获取更高级的功能，请通过中间件扩展脚手架。

核心组件

模型

传递一个模型标识符字符串 ("provider:model") 或一个已初始化的模型实例来为你的智能体选择模型。有关参数、提供商设置和动态模型选择，请参见模型。

import { createAgent } from "langchain";

var agent = createAgent({ model: "google-genai:gemini-3.6-flash", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "openai:gpt-5.5", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "anthropic:claude-sonnet-4-6", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "openrouter:openrouter:z-ai/glm-5.2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "fireworks:accounts/fireworks/models/glm-5p2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "baseten:zai-org/GLM-5.2", tools });

import { createAgent } from "langchain";

var agent = createAgent({ model: "ollama:north-mini-code-1.0", tools });

工具

要为智能体提供工具，请传递任何可调用的 Python 对象、LangChain 工具或工具字典。有关工具定义、上下文访问和动态工具选择，请参见工具。

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "google-genai:gemini-3.6-flash", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "openai:gpt-5.5", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "anthropic:claude-sonnet-4-6", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "openrouter:openrouter:z-ai/glm-5.2", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "fireworks:accounts/fireworks/models/glm-5p2", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "baseten:zai-org/GLM-5.2", tools: [search] });

import { tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `Results for: ${query}`, {
  name: "search",
  description: "搜索信息",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({ model: "ollama:north-mini-code-1.0", tools: [search] });

系统提示

塑造智能体处理任务的方式。系统提示参数接受字符串或 SystemMessage。要在运行时动态生成提示，请使用中间件。

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools,
  systemPrompt: "你是一个得力的助手。请保持回答的简洁性和准确性。",
});

结构化输出

使用 response_format= 从智能体返回一个经过验证的模式。有关策略和示例，请参见结构化输出。

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "openai:gpt-5.5",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

const Answer = z.object({ summary: z.string(), confidence: z.number() });
    
var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools,
  responseFormat: Answer,
});
const result = await agent.invoke({
  messages: [{ role: "user", content: "总结AI趋势" }],
});
result.structuredResponse; // { summary: ..., confidence: ... }

调用

使用 LangSmith 追踪此循环的每一步、调试工具调用并评估智能体输出。请遵循追踪快速入门进行设置。我们建议您同时设置 LangSmith Engine，它可以监控您的追踪记录、检测问题并提出修复建议。

你可以用一条消息来调用智能体。在底层，这会向智能体的 State 传递一个更新。所有智能体的状态中都包含一个消息序列；要调用智能体，请传递一条新消息以及一个 thread_id，以便智能体能够持久化并恢复对话历史：

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [],
  checkpointer: new MemorySaver(),
});
    
const config = { configurable: { thread_id: crypto.randomUUID() } };
    
let result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" },
    ],
  },
  config,
);
    
// 同一对话的后续轮次：重用相同的 thread_id 以保持历史记录
result = await agent.invoke(
  { messages: [{ role: "user", content: "What about tomorrow?" }] },
  config,
);

使用 thread_id 持久化对话历史需要智能体配置一个检查点器。当部署在 LangSmith 上时，系统会自动配置一个检查点器。在本地开发时，请显式传递一个，例如 create_agent(..., checkpointer=InMemorySaver())。

如果你还需要将每次运行的配置（例如用户 ID、API 密钥或功能标志）传递给工具和中间件，请将其与配置一起作为 context 传递。使用 contextSchema 定义该数据的结构，并通过 runtime.context 访问它：

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

import * as z from "zod";
import { AIMessage } from "@langchain/core/messages";
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
    
const contextSchema = z.object({
  user_id: z.string(),
});
    
const agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [],
  contextSchema,
  checkpointer: new MemorySaver(),
});
    
const result = await agent.invoke(
  {
    messages: [
      { role: "user", content: "旧金山天气怎么样？" },
    ],
  },
  {
    configurable: { thread_id: crypto.randomUUID() },
    context: { user_id: "user-123" },
  },
);

thread_id 定义了对话的范围（消息历史、检查点），而 context 承载了你的工具和中间件在调用时读取的每次运行的数据。两者通常会一起传递。更多信息请参见工具上下文和运行时。

流式传输

invoke 在运行结束时返回最终响应。如果智能体执行了多个工具调用，用户通常需要在完成前获得进度更新。使用流式传输可以在消息和工具活动发生时实时展示它们。

const stream = await agent.streamEvents(
  {
    messages: [
      {
        role: "user",
        content: "搜索AI新闻并总结发现",
      },
    ],
  },
  { version: "v3" },
);

for await (const snapshot of stream.values) {
  // 每个快照包含该时间点的完整状态
  const latestMessage = snapshot.messages.at(-1);
  if (latestMessage?.content) {
    if (latestMessage.type === "human") {
      console.log(`用户: ${latestMessage.content}`);
    } else if (latestMessage.type === "ai") {
      console.log(`助手: ${latestMessage.content}`);
    }
  } else if (latestMessage?.tool_calls?.length) {
    const toolCallNames = latestMessage.tool_calls.map((tc) => tc.name);
    console.log(`调用工具: ${toolCallNames.join(", ")}`);
  }
}

有关流式模式、事件类型和 UI 模式，请参见流式传输。

配置脚手架

create_agent 高度可扩展。中间件是自定义的基石：每一块处理一个关注点，在合适的时机钩入智能体循环，并且可以自由地与其他任何中间件组合。只取用例所需的部分，跳过其余部分。常见的模式被预构建为一等中间件。其他任何功能都可以构建为自定义中间件。按类别划分的智能体脚手架能力

随着智能体承担复杂的工作，它们需要在几个关键领域获得支持。中间件生态系统提供了：

执行环境

工具、文件系统、沙箱和代码执行

上下文管理

摘要、记忆、技能和提示缓存

规划和委派

待办事项列表和用于并行、隔离工作的子智能体

容错性

重试、回退和调用限制

防护栏

个人信息检测和内容控制

引导

在高影响操作前进行人工审批

create_deep_agent 为长时间运行的编码和研究任务预先组装了这套技术栈（默认包含文件系统、摘要、子智能体和提示缓存）。有关完整的预构建脚手架，请参见深度智能体。

执行环境

当智能体能够采取行动而不仅仅是生成文本时，它们尤其有用。执行环境为智能体提供了一个工作空间：它可以调用的工具、用于在多轮对话中读写文件的文件系统，以及用于运行脚本或 shell 命令的代码执行器。

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

import { createAgent } from "langchain";
import { createFilesystemMiddleware, StateBackend } from "deepagents";

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [search],
  middleware: [createFilesystemMiddleware({ backend: new StateBackend() })],
});

参见 @@MDX_PRESERVE_2@@ FilesystemMiddleware，沙箱，解释器。

上下文管理

每次模型调用都有固定的上下文窗口。随着智能体运行，该窗口会填满不断累积的历史记录、工具结果和中间步骤。摘要在溢出发生前压缩历史记录；记忆在启动时加载持久化指令，使知识能够跨会话保持；技能按需提供领域知识，而不是预先加载所有内容。

import { createAgent } from "langchain";
import {
  StateBackend,
  createFilesystemMiddleware,
  createSkillsMiddleware,
  createSummarizationMiddleware,
} from "deepagents";

var backend = new StateBackend();
const model = "anthropic:claude-sonnet-4-6";

var agent = createAgent({
  model,
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["./skills/"] }),
  ],
});

参见 @@MDX_PRESERVE_3@@ SummarizationMiddleware，@@MDX_PRESERVE_4@@ MemoryMiddleware，技能，上下文工程。

规划和委派

复杂任务常常超出单个上下文窗口的处理能力。委派让主智能体能够将工作分解成若干部分，交给各自运行在独立隔离上下文中的子智能体处理，主智能体则专注于协调而非执行。工作可以并行进行；主智能体的上下文保持整洁。

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

import { createAgent, todoListMiddleware, tool } from "langchain";
import {
  createFilesystemMiddleware,
  createSubAgentMiddleware,
  StateBackend,
} from "deepagents";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var backend = new StateBackend();

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [search],
  middleware: [
    createFilesystemMiddleware({ backend }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: "anthropic:claude-sonnet-4-6",
      defaultTools: [],
      subagents: [
        {
          name: "researcher",
          description: "搜索并返回结构化摘要。",
          systemPrompt:
            "使用搜索工具研究问题，并总结关键点。",
          tools: [search],
          model: "anthropic:claude-sonnet-4-6",
          middleware: [],
        },
      ],
    }),
  ],
});

参见子智能体。

为你的智能体命名

可选地为智能体使用一个标识符。这在将智能体作为子图嵌入多智能体系统时特别有用。

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools,
  name: "research_assistant",
});

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools,
  name: "research_assistant",
});

容错性

生产环境中的智能体会遇到开发中很少出现的失败：速率限制、模型超时、瞬时 API 错误。容错中间件在基础设施层面处理这些问题，这样你的工具和业务逻辑就不需要在每个调用周围都写 try/catch。

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

import {
  createAgent,
  modelRetryMiddleware,
  tool,
  toolRetryMiddleware,
} from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [search],
  middleware: [
    modelRetryMiddleware({ maxRetries: 3 }),
    toolRetryMiddleware({ maxRetries: 2 }),
  ],
});

参见 @@MDX_PRESERVE_7@@ modelRetryMiddleware，@@MDX_PRESERVE_8@@ toolRetryMiddleware，预构建中间件。

防护栏

某些策略不能仅放在提示中——它们需要被确定性地强制执行，无论模型做什么。防护栏在数据流经智能体循环时进行拦截，在工具结果到达模型上下文之前应用合规性规则或内容策略。

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

import { createAgent, piiMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索结果：${query}`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [search],
  middleware: [piiMiddleware("email")],
});

参见 @@MDX_PRESERVE_10@@ piiMiddleware，预构建中间件。

引导

完全自主并非总是合适。引导让你能够在特定的决策点——在破坏性写入、昂贵的 API 调用或任何需要判断的操作之前——安排人工介入，而无需重构你的智能体。智能体会暂停等待；人工批准、编辑或拒绝；然后执行继续。

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import * as z from "zod";

var search = tool(({ query }) => `搜索 "${query}" 的结果`, {
  name: "search",
  description: "搜索查询并返回简短摘要。",
  schema: z.object({ query: z.string() }),
});

var agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [search],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { writeFile: true } })],
});

参见 @@MDX_PRESERVE_12@@ humanInTheLoopMiddleware，人机协同。

中间件资源

中间件概述

中间件栈的工作原理以及钩子何时触发

预构建中间件

完整参考，附带配置示例

自定义中间件

为你自己的业务逻辑、个人信息擦除等编写钩子

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Get started

Core components

Middleware

Frontend

Advanced usage

Agent development

Production

核心组件

模型

工具

系统提示

结构化输出

调用

流式传输

配置脚手架

执行环境

上下文管理

规划和委派

容错性

防护栏

引导

执行环境

上下文管理

规划和委派

为你的智能体命名

容错性

防护栏

引导

中间件资源

中间件概述

预构建中间件

自定义中间件

​核心组件

​模型

​工具

​系统提示

​结构化输出

​调用

​流式传输

​配置脚手架

执行环境

上下文管理

规划和委派

容错性

防护栏

引导

​执行环境

​上下文管理

​规划和委派

​为你的智能体命名

​容错性

​防护栏

​引导

​中间件资源

中间件概述

预构建中间件

自定义中间件

核心组件

模型

工具

系统提示

结构化输出

调用

流式传输

配置脚手架

执行环境

上下文管理

规划和委派

为你的智能体命名

容错性

防护栏

引导

中间件资源