跳到主要内容

文档索引

在以下地址获取完整的文档索引：https://docs.langchain.org.cn/llms.txt

在进一步探索之前，请使用此文件发现所有可用页面。

智能体将语言模型与 工具 相结合，创建能够推理任务、决定使用何种工具并迭代寻求解决方案的系统。 createAgent() 提供了一个生产就绪的智能体实现。 LLM 智能体通过循环运行工具来达成目标。智能体持续运行直到满足停止条件，即模型发出最终输出或达到迭代限制。
createAgent() 使用 LangGraph 构建基于图 (graph) 的智能体运行时。图由定义智能体如何处理信息的节点（步骤）和边（连接）组成。智能体在图中移动，执行如模型节点（调用模型）、工具节点（执行工具）或中间件等节点。了解更多关于 Graph API 的信息。

​
核心组件

​
模型

模型是智能体的推理引擎。它可以通过多种方式指定，支持静态和动态模型选择。

​
静态模型

静态模型在创建智能体时配置一次，并在整个执行过程中保持不变。这是最常见且直接的方法。 要通过 初始化静态模型：
import { createAgent } from "langchain";

const agent = createAgent({
  model: "openai:gpt-5.4",
  tools: []
});
模型标识符字符串使用 provider:model 格式（例如 "openai:gpt-5.4"）。如果您需要对模型配置进行更多控制，可以直接使用提供商包初始化模型实例。 
import { createAgent } from "langchain";
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-5.4",
  temperature: 0.1,
  maxTokens: 1000,
  timeout: 30
});

const agent = createAgent({
  model,
  tools: []
});
模型实例为您提供了对配置的完全控制。当您需要设置特定参数（如 temperature、max_tokens、timeouts）或配置 API 密钥、base_url 及其他特定于提供商的设置时，请使用它们。请参阅 API 参考以查看模型可用的参数和方法。

​
动态模型

动态模型是在 根据当前的 和上下文进行选择的。这实现了复杂的路由逻辑和成本优化。 要使用动态模型，请创建一个带有 wrapModelCall 的中间件，用以在请求中修改模型：
import { ChatOpenAI } from "@langchain/openai";
import { createAgent, createMiddleware } from "langchain";

const basicModel = new ChatOpenAI({ model: "gpt-5.4-mini" });
const advancedModel = new ChatOpenAI({ model: "gpt-5.4" });

const dynamicModelSelection = createMiddleware({
  name: "DynamicModelSelection",
  wrapModelCall: (request, handler) => {
    // Choose model based on conversation complexity
    const messageCount = request.messages.length;

    return handler({
        ...request,
        model: messageCount > 10 ? advancedModel : basicModel,
    });
  },
});

const agent = createAgent({
  model: "gpt-5.4-mini", // Base model (used when messageCount ≤ 10)
  tools,
  middleware: [dynamicModelSelection],
});
关于中间件和高级模式的更多详细信息，请参阅 中间件文档。
有关模型配置详情，请参阅 模型。有关动态模型选择模式，请参阅 中间件中的动态模型。

​
工具

工具赋予智能体采取行动的能力。智能体通过促进以下功能，超越了简单的模型绑定工具：
  • 按顺序执行多个工具调用（由单个提示触发）
  • 在适当时并行调用工具
  • 根据之前的结果进行动态工具选择
  • 工具重试逻辑和错误处理
  • 跨工具调用的状态持久化
更多信息，请参阅 工具。

​
静态工具

静态工具在创建智能体时定义，在执行过程中保持不变。这是最常见且直接的方法。 要定义一个带有静态工具的智能体，请将工具列表传递给智能体。
import * as z from "zod";
import { createAgent, tool } from "langchain";

const search = tool(
  ({ query }) => `Results for: ${query}`,
  {
    name: "search",
    description: "Search for information",
    schema: z.object({
      query: z.string().describe("The query to search for"),
    }),
  }
);

const getWeather = tool(
  ({ location }) => `Weather in ${location}: Sunny, 72°F`,
  {
    name: "get_weather",
    description: "Get weather information for a location",
    schema: z.object({
      location: z.string().describe("The location to get weather for"),
    }),
  }
);

const agent = createAgent({
  model: "gpt-5.4",
  tools: [search, getWeather],
});
如果提供空工具列表，智能体将仅包含一个 LLM 节点，而不具备工具调用能力。

​
动态工具

使用动态工具时，智能体可用的工具集在运行时进行修改，而不是预先全部定义好。并非每个工具都适合所有情况。工具过多可能会使模型不堪重负（上下文溢出）并增加错误；工具过少则会限制能力。动态工具选择可以根据认证状态、用户权限、功能标志或对话阶段来适配可用的工具集。 根据工具是否预先已知，有两种处理方法：
当所有可能的工具在智能体创建时都已知时，您可以预先注册它们，并根据状态、权限或上下文动态过滤哪些工具暴露给模型。
仅在某些对话里程碑之后才启用高级工具
import { createMiddleware, tool } from "langchain";
import { createDeepAgent } from "deepagents";

const stateBasedTools = createMiddleware({
    name: "StateBasedTools",
    wrapModelCall: (request, handler) => {
        // Read from State: check authentication and conversation length
        const state = request.state as typeof request.state & {
            authenticated?: boolean;
        };
        const isAuthenticated = state.authenticated ?? false;
        const messageCount = state.messages.length;

        let filteredTools = request.tools;

        // Only enable sensitive tools after authentication
        if (!isAuthenticated) {
            filteredTools = request.tools.filter(
                (t: any) => typeof t.name === "string" && t.name.startsWith("public_"),
            );
        } else if (messageCount < 5) {
            filteredTools = request.tools.filter(
                (t: any) => typeof t.name === "string" && t.name !== "advanced_search",
            );
        }

        return handler({ ...request, tools: filteredTools });
    },
});

const agent = await createDeepAgent({
    model: "claude-sonnet-4-20250514",
    tools: tools,
    middleware: [stateBasedTools] as any,
});
此方法适用于：
  • 所有可能工具在编译/启动时已知
  • 您希望根据权限、功能标志或对话状态进行过滤
  • 工具是静态的，但它们的可用性是动态的
请参阅 动态选择工具 获取更多示例。
要了解更多关于工具的信息，请参阅 工具。

​
工具错误处理

要自定义工具错误的处理方式，请在自定义中间件中使用 wrapToolCall 钩子。 
import { createAgent, createMiddleware, ToolMessage } from "langchain";

const handleToolErrors = createMiddleware({
  name: "HandleToolErrors",
  wrapToolCall: async (request, handler) => {
    try {
      return await handler(request);
    } catch (error) {
      // Return a custom error message to the model
      return new ToolMessage({
        content: `Tool error: Please check your input and try again. (${error})`,
        tool_call_id: request.toolCall.id!,
      });
    }
  },
});

const agent = createAgent({
  model: "gpt-5.4",
  tools: [
    /* ... */
  ],
  middleware: [handleToolErrors],
});
当工具失败时，智能体将返回一个带有自定义错误消息的 ToolMessage。

​
ReAct 循环中的工具使用

智能体遵循 ReAct（“推理 + 行动”）模式，在简短的推理步骤与有针对性的工具调用之间交替，并将所得观察结果反馈给后续决策，直到能够给出最终答案。
提示词： 找出当前最受欢迎的无线耳机并验证其是否有货。
================================ Human Message =================================

Find the most popular wireless headphones right now and check if they're in stock
  • 推理：“受欢迎程度具有时效性，我需要使用提供的搜索工具。”
  • 行动：调用 search_products("wireless headphones")
================================== Ai Message ==================================
Tool Calls:
  search_products (call_abc123)
 Call ID: call_abc123
  Args:
    query: wireless headphones

================================= Tool Message =================================

Found 5 products matching "wireless headphones". Top 5 results: WH-1000XM5, ...
  • 推理：“在回答之前，我需要确认排名第一的商品的库存情况。”
  • 行动：调用 check_inventory("WH-1000XM5")
================================== Ai Message ==================================
Tool Calls:
  check_inventory (call_def456)
 Call ID: call_def456
  Args:
    product_id: WH-1000XM5

================================= Tool Message =================================

Product WH-1000XM5: 10 units in stock
  • 推理：“我已经获得了最受欢迎的型号及其库存状态。现在可以回答用户的问题了。”
  • 行动：生成最终答案
================================== Ai Message ==================================

I found wireless headphones (model WH-1000XM5) with 10 units in stock...

​
系统提示

您可以通过提供提示词来塑造智能体处理任务的方式。systemPrompt 参数可以作为字符串提供。 
const agent = createAgent({
  model,
  tools,
  systemPrompt: "You are a helpful assistant. Be concise and accurate.",
});
如果不提供 systemPrompt，智能体将直接从消息中推断其任务。 systemPrompt 参数接受 string 或 SystemMessage。使用 SystemMessage 可以让您更好地控制提示词结构，这对于诸如 Anthropic 的提示词缓存 等特定于提供商的功能非常有用：
import { createAgent } from "langchain";
import { SystemMessage, HumanMessage } from "@langchain/core/messages";

const literaryAgent = createAgent({
  model: "google_genai:gemini-3.1-pro-preview",
  systemPrompt: new SystemMessage({
    content: [
      {
        type: "text",
        text: "You are an AI assistant tasked with analyzing literary works.",
      },
      {
        type: "text",
        text: "<the entire contents of 'Pride and Prejudice'>",
        cache_control: { type: "ephemeral" }
      }
    ]
  })
});

const result = await literaryAgent.invoke({
  messages: [new HumanMessage("Analyze the major themes in 'Pride and Prejudice'.")]
});
带有 { type: "ephemeral" } 的 cache_control 字段告诉 Anthropic 缓存该内容块，从而减少使用相同系统提示词的重复请求的延迟和成本。

​
动态系统提示词

对于需要根据运行时上下文或智能体状态修改系统提示词的更高级用例，您可以使用 中间件。 
import * as z from "zod";
import { createAgent, dynamicSystemPromptMiddleware } from "langchain";

const contextSchema = z.object({
  userRole: z.enum(["expert", "beginner"]),
});

const agent = createAgent({
  model: "gpt-5.4",
  tools: [/* ... */],
  contextSchema,
  middleware: [
    dynamicSystemPromptMiddleware<z.infer<typeof contextSchema>>((state, runtime) => {
      const userRole = runtime.context.userRole || "user";
      const basePrompt = "You are a helpful assistant.";

      if (userRole === "expert") {
        return `${basePrompt} Provide detailed technical responses.`;
      } else if (userRole === "beginner") {
        return `${basePrompt} Explain concepts simply and avoid jargon.`;
      }
      return basePrompt;
    }),
  ],
});

// The system prompt will be set dynamically based on context
const result = await agent.invoke(
  { messages: [{ role: "user", content: "Explain machine learning" }] },
  { context: { userRole: "expert" } }
);
有关消息类型和格式的更多详细信息，请参阅 消息。有关完整的中间件文档，请参阅 中间件。

​
名称

为智能体设置可选的 name。当在 多智能体系统 中将智能体作为子图添加时，这用作节点标识符。 
const agent = createAgent({
  model,
  tools,
  name: "research_assistant",
});
智能体名称建议使用 snake_case（例如 research_assistant 而不是 Research Assistant）。一些模型提供商会拒绝包含空格或特殊字符的名称并报错。仅使用字母数字字符、下划线和连字符可确保在所有提供商之间的兼容性。这也同样适用于 工具名称。

​
调用

您可以通过向其 State 传递更新来调用智能体。所有智能体的状态中都包含一个 消息序列；要调用智能体，请传递一条新消息。 
await agent.invoke({
  messages: [{ role: "user", content: "What's the weather in San Francisco?" }],
})
有关从智能体流式传输步骤和/或 Token 的信息，请参阅 流式传输 指南。 此外，智能体遵循 LangGraph 的 Graph API，并支持所有相关方法，例如 stream 和 invoke。
使用 LangSmith 来追踪、调试和评估您的智能体。

​
进阶概念

​
结构化输出

在某些情况下，您可能希望智能体以特定格式返回输出。LangChain 通过 responseFormat 参数提供了一种简单、通用的方式来实现这一点。 
import * as z from "zod";
import { createAgent } from "langchain";

const ContactInfo = z.object({
  name: z.string(),
  email: z.string(),
  phone: z.string(),
});

const agent = createAgent({
  model: "gpt-5.4",
  responseFormat: ContactInfo,
});

const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "Extract contact info from: John Doe, john@example.com, (555) 123-4567",
    },
  ],
});

console.log(result.structuredResponse);
// {
//   name: 'John Doe',
//   email: 'john@example.com',
//   phone: '(555) 123-4567'
// }
要了解结构化输出，请参阅 结构化输出。

​
内存

智能体通过消息状态自动维护对话历史。您还可以配置智能体使用自定义状态模式，以便在对话期间记忆额外信息。 存储在状态中的信息可以被视为智能体的 短期记忆：
import { z } from "zod/v4";
import { StateSchema, MessagesValue } from "@langchain/langgraph";
import { createAgent } from "langchain";

const CustomAgentState = new StateSchema({
  messages: MessagesValue,
  userPreferences: z.record(z.string(), z.string()),
});

const customAgent = createAgent({
  model: "gpt-5.4",
  tools: [],
  stateSchema: CustomAgentState,
});
要了解更多关于记忆的信息，请参阅 记忆。有关实现跨会话持久化的长期记忆的信息，请参阅 长期记忆。

​
流式处理

我们已经了解了如何通过 invoke 调用智能体以获取最终响应。如果智能体执行多个步骤，这可能需要一些时间。为了显示中间进度，我们可以随着消息的产生进行流式传输。 
const stream = await agent.stream(
  {
    messages: [{
      role: "user",
      content: "Search for AI news and summarize the findings"
    }],
  },
  { streamMode: "values" }
);

for await (const chunk of stream) {
  // Each chunk contains the full state at that point
  const latestMessage = chunk.messages.at(-1);
  if (latestMessage?.content) {
    console.log(`Agent: ${latestMessage.content}`);
  } else if (latestMessage?.tool_calls) {
    const toolCallNames = latestMessage.tool_calls.map((tc) => tc.name);
    console.log(`Calling tools: ${toolCallNames.join(", ")}`);
  }
}
有关流式传输的更多详细信息，请参阅 流式传输。

​
中间件

中间件 提供了强大的扩展性，用于在执行的不同阶段自定义智能体行为。您可以使用中间件来：
  • 在模型调用前处理状态（例如消息剪裁、上下文注入）
  • 修改或验证模型的响应（例如护栏、内容过滤）
  • 使用自定义逻辑处理工具执行错误
  • 根据状态或上下文实现动态模型选择
  • 添加自定义日志记录、监控或分析
中间件无缝集成到智能体的执行中，允许您在关键点拦截和修改数据流，而无需更改核心智能体逻辑。
有关包括 beforeModel、afterModel 和 wrapToolCall 等钩子在内的全面中间件文档，请参阅 中间件。
将这些文档连接到 Claude、VSCode 等，以获得实时答案。
在 GitHub 上编辑此页面 或 提交问题。
© . This site is unofficial and not affiliated with LangChain, Inc.