跳到主要内容

如何使用旧版 LangChain Agents (AgentExecutor)

先决条件

本指南假设您熟悉以下概念

语言模型本身无法执行操作 - 它们只是输出文本。代理是使用 LLM 作为推理引擎的系统，以确定要采取哪些操作以及这些操作的输入应该是什么。然后可以将这些操作的结果反馈到代理中，并且它确定是否需要更多操作，或者是否可以完成。

在本教程中，我们将构建一个可以与多个不同工具交互的代理：一个是本地数据库，另一个是搜索引擎。您将能够向此代理提问，观看它调用工具，并与其进行对话。

信息

本节将介绍如何使用 LangChain Agents 构建。LangChain Agents 非常适合入门，但超过一定程度后，您可能需要它们不提供的灵活性和控制力。对于使用更高级的代理，我们建议您查看 LangGraph。

概念​

我们将涵盖的概念包括： - 使用语言模型，特别是它们的工具调用能力 - 创建检索器以向我们的代理公开特定信息 - 使用搜索工具在线查找内容 - 聊天历史记录，它允许聊天机器人“记住”过去的交互，并在回复后续问题时考虑这些交互。 - 使用 LangSmith 调试和追踪您的应用程序

设置​

Jupyter Notebook​

本指南（以及文档中的大多数其他指南）使用 Jupyter notebooks，并假设读者也是如此。Jupyter notebooks 非常适合学习如何使用 LLM 系统，因为通常情况下，事情可能会出错（意外输出、API 宕机等），并且在交互式环境中阅读指南是更好地理解它们的好方法。

本教程和其他教程可能最方便在 Jupyter notebook 中运行。有关如何安装的说明，请参阅此处。

安装​

要安装 LangChain（和用于 Web 加载器的 cheerio），请运行

yarn add langchain @langchain/core cheerio

有关更多详细信息，请参阅我们的安装指南。

LangSmith​

您使用 LangChain 构建的许多应用程序将包含多个步骤，其中包含多次 LLM 调用。随着这些应用程序变得越来越复杂，能够检查链或代理内部到底发生了什么是至关重要的。执行此操作的最佳方法是使用 LangSmith。

在上面的链接注册后，请务必设置您的环境变量以开始记录追踪

export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="..."

# Reduce tracing latency if you are not in a serverless environment
# export LANGCHAIN_CALLBACKS_BACKGROUND=true

定义工具​

我们首先需要创建要使用的工具。我们将使用两个工具：Tavily（用于在线搜索），然后是在我们将创建的本地索引上的检索器

Tavily​

我们在 LangChain 中内置了一个工具，可以轻松地将 Tavily 搜索引擎用作工具。请注意，这需要 API 密钥 - 它们有一个免费层级，但如果您没有密钥或不想创建密钥，您可以随时忽略此步骤。

创建 API 密钥后，您需要将其导出为

export TAVILY_API_KEY="..."
import "cheerio"; // This is required in notebooks to use the `CheerioWebBaseLoader`
import { TavilySearchResults } from "@langchain/community/tools/tavily_search";

const search = new TavilySearchResults({
  maxResults: 2,
});

await search.invoke("what is the weather in SF");
`[{"title":"Weather in San Francisco","url":"https://www.weatherapi.com/","content":"{'location': {'n`... 1358 more characters

检索器​

我们还将创建一个在我们自己的数据上的检索器。有关此处每个步骤的更深入解释，请参阅本教程。

import { CheerioWebBaseLoader } from "@langchain/community/document_loaders/web/cheerio";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";

const loader = new CheerioWebBaseLoader(
  "https://langsmith.langchain.ac.cn/overview"
);
const docs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
const documents = await splitter.splitDocuments(docs);
const vectorStore = await MemoryVectorStore.fromDocuments(
  documents,
  new OpenAIEmbeddings()
);
const retriever = vectorStore.asRetriever();

(await retriever.invoke("how to upload a dataset"))[0];
Document {
  pageContent: 'description="A sample dataset in LangSmith.")client.create_examples(    inputs=[        {"postfix": '... 891 more characters,
  metadata: {
    source: "https://langsmith.langchain.ac.cn/overview",
    loc: { lines: { from: 4, to: 4 } }
  },
  id: undefined
}

现在我们已经填充了将要进行检索的索引，我们可以轻松地将其转换为工具（代理正确使用它所需的格式）

import { z } from "zod";
import { tool } from "@langchain/core/tools";

const retrieverTool = tool(
  async ({ input }, config) => {
    const docs = await retriever.invoke(input, config);
    return docs.map((doc) => doc.pageContent).join("\n\n");
  },
  {
    name: "langsmith_search",
    description:
      "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
    schema: z.object({
      input: z.string(),
    }),
  }
);

工具​

现在我们已经创建了这两个工具，我们可以创建一个工具列表，供下游使用。

const tools = [search, retrieverTool];

使用语言模型​

接下来，让我们学习如何使用语言模型来调用工具。LangChain 支持许多不同的语言模型，您可以互换使用 - 选择您想要使用的模型！

选择您的聊天模型

安装依赖项

提示

请参阅 本节，了解有关安装集成包的通用说明.

yarn add @langchain/groq

添加环境变量

GROQ_API_KEY=your-api-key

实例化模型

import { ChatGroq } from "@langchain/groq";

const model = new ChatGroq({
  model: "llama-3.3-70b-versatile",
  temperature: 0
});

您可以通过传入消息列表来调用语言模型。默认情况下，响应是 content 字符串。

const response = await model.invoke([
  {
    role: "user",
    content: "hi!",
  },
]);

response.content;
"Hello! How can I assist you today?"

现在我们可以了解启用此模型进行工具调用的情况。为了启用它，我们使用 .bind 为语言模型提供这些工具的知识

const modelWithTools = model.bindTools(tools);

我们现在可以调用模型了。让我们首先使用正常消息调用它，看看它如何响应。我们可以查看 content 字段以及 tool_calls 字段。

const responseWithTools = await modelWithTools.invoke([
  {
    role: "user",
    content: "Hi!",
  },
]);

console.log(`Content: ${responseWithTools.content}`);
console.log(`Tool calls: ${responseWithTools.tool_calls}`);
Content: Hello! How can I assist you today?
Tool calls:

现在，让我们尝试使用一些期望调用工具的输入来调用它。

const responseWithToolCalls = await modelWithTools.invoke([
  {
    role: "user",
    content: "What's the weather in SF?",
  },
]);

console.log(`Content: ${responseWithToolCalls.content}`);
console.log(
  `Tool calls: ${JSON.stringify(responseWithToolCalls.tool_calls, null, 2)}`
);
Content:
Tool calls: [
  {
    "name": "tavily_search_results_json",
    "args": {
      "input": "current weather in San Francisco"
    },
    "type": "tool_call",
    "id": "call_gtJ5rrjXswO8EIvePrxyGQbR"
  }
]

我们可以看到现在没有内容，但有一个工具调用！它希望我们调用 Tavily Search 工具。

这还没有调用该工具 - 它只是告诉我们要调用。为了实际调用它，我们将需要创建我们的代理。

创建代理​

现在我们已经定义了工具和 LLM，我们可以创建代理了。我们将使用工具调用代理 - 有关此类代理以及其他选项的更多信息，请参阅本指南。

我们可以首先选择要用于指导代理的提示

import { ChatPromptTemplate } from "@langchain/core/prompts";

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant"],
  ["placeholder", "{chat_history}"],
  ["human", "{input}"],
  ["placeholder", "{agent_scratchpad}"],
]);

console.log(prompt.promptMessages);
[
  SystemMessagePromptTemplate {
    lc_serializable: true,
    lc_kwargs: {
      prompt: PromptTemplate {
        lc_serializable: true,
        lc_kwargs: {
          inputVariables: [],
          templateFormat: "f-string",
          template: "You are a helpful assistant"
        },
        lc_runnable: true,
        name: undefined,
        lc_namespace: [ "langchain_core", "prompts", "prompt" ],
        inputVariables: [],
        outputParser: undefined,
        partialVariables: undefined,
        templateFormat: "f-string",
        template: "You are a helpful assistant",
        validateTemplate: true,
        additionalContentFields: undefined
      }
    },
    lc_runnable: true,
    name: undefined,
    lc_namespace: [ "langchain_core", "prompts", "chat" ],
    inputVariables: [],
    additionalOptions: {},
    prompt: PromptTemplate {
      lc_serializable: true,
      lc_kwargs: {
        inputVariables: [],
        templateFormat: "f-string",
        template: "You are a helpful assistant"
      },
      lc_runnable: true,
      name: undefined,
      lc_namespace: [ "langchain_core", "prompts", "prompt" ],
      inputVariables: [],
      outputParser: undefined,
      partialVariables: undefined,
      templateFormat: "f-string",
      template: "You are a helpful assistant",
      validateTemplate: true,
      additionalContentFields: undefined
    },
    messageClass: undefined,
    chatMessageClass: undefined
  },
  MessagesPlaceholder {
    lc_serializable: true,
    lc_kwargs: { variableName: "chat_history", optional: true },
    lc_runnable: true,
    name: undefined,
    lc_namespace: [ "langchain_core", "prompts", "chat" ],
    variableName: "chat_history",
    optional: true
  },
  HumanMessagePromptTemplate {
    lc_serializable: true,
    lc_kwargs: {
      prompt: PromptTemplate {
        lc_serializable: true,
        lc_kwargs: {
          inputVariables: [Array],
          templateFormat: "f-string",
          template: "{input}"
        },
        lc_runnable: true,
        name: undefined,
        lc_namespace: [ "langchain_core", "prompts", "prompt" ],
        inputVariables: [ "input" ],
        outputParser: undefined,
        partialVariables: undefined,
        templateFormat: "f-string",
        template: "{input}",
        validateTemplate: true,
        additionalContentFields: undefined
      }
    },
    lc_runnable: true,
    name: undefined,
    lc_namespace: [ "langchain_core", "prompts", "chat" ],
    inputVariables: [ "input" ],
    additionalOptions: {},
    prompt: PromptTemplate {
      lc_serializable: true,
      lc_kwargs: {
        inputVariables: [ "input" ],
        templateFormat: "f-string",
        template: "{input}"
      },
      lc_runnable: true,
      name: undefined,
      lc_namespace: [ "langchain_core", "prompts", "prompt" ],
      inputVariables: [ "input" ],
      outputParser: undefined,
      partialVariables: undefined,
      templateFormat: "f-string",
      template: "{input}",
      validateTemplate: true,
      additionalContentFields: undefined
    },
    messageClass: undefined,
    chatMessageClass: undefined
  },
  MessagesPlaceholder {
    lc_serializable: true,
    lc_kwargs: { variableName: "agent_scratchpad", optional: true },
    lc_runnable: true,
    name: undefined,
    lc_namespace: [ "langchain_core", "prompts", "chat" ],
    variableName: "agent_scratchpad",
    optional: true
  }
]

现在，我们可以使用 LLM、提示和工具初始化代理。代理负责接收输入并决定要采取的操作。至关重要的是，Agent 不执行这些操作 - 这由 AgentExecutor 完成（下一步）。有关如何考虑这些组件的更多信息，请参阅我们的概念指南。

请注意，我们传入的是 model，而不是 modelWithTools。这是因为 createToolCallingAgent 将在后台为我们调用 .bind。

import { createToolCallingAgent } from "langchain/agents";

const agent = await createToolCallingAgent({ llm: model, tools, prompt });

最后，我们将代理（大脑）与 AgentExecutor 内的工具（将重复调用代理并执行工具）结合起来。

import { AgentExecutor } from "langchain/agents";

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

运行代理​

我们现在可以在一些查询上运行代理！请注意，目前，这些都是无状态查询（它不会记住以前的交互）。

首先，让我们看看在不需要调用工具时它是如何响应的

await agentExecutor.invoke({ input: "hi!" });
{ input: "hi!", output: "Hello! How can I assist you today?" }

为了确切了解幕后发生了什么（并确保它没有调用工具），我们可以查看 LangSmith 追踪

现在让我们在一个应该调用检索器的示例上试用一下

await agentExecutor.invoke({ input: "how can langsmith help with testing?" });
{
  input: "how can langsmith help with testing?",
  output: "LangSmith can assist with testing in several ways, particularly for applications built using large l"... 1474 more characters
}

让我们看一下 LangSmith 追踪，以确保它实际上正在调用它。

现在让我们尝试一个需要调用搜索工具的

await agentExecutor.invoke({ input: "whats the weather in sf?" });
{
  input: "whats the weather in sf?",
  output: "The current weather in San Francisco is as follows:\n" +
    "\n" +
    "- **Temperature**: 15.6°C (60.1°F)\n" +
    "- **Conditio"... 303 more characters
}

我们可以查看 LangSmith 追踪，以确保它有效地调用了搜索工具。

添加内存​

如前所述，此代理是无状态的。这意味着它不记得以前的交互。为了给它记忆，我们需要传入以前的 chat_history。

注意：由于我们正在使用的提示，输入变量需要命名为 chat_history。如果我们使用不同的提示，我们可以更改变量名称。

// Here we pass in an empty list of messages for chat_history because it is the first message in the chat
await agentExecutor.invoke({ input: "hi! my name is bob", chat_history: [] });
{
  input: "hi! my name is bob",
  chat_history: [],
  output: "Hello Bob! How can I assist you today?"
}
await agentExecutor.invoke({
  chat_history: [
    { role: "user", content: "hi! my name is bob" },
    { role: "assistant", content: "Hello Bob! How can I assist you today?" },
  ],
  input: "what's my name?",
});
{
  chat_history: [
    { role: "user", content: "hi! my name is bob" },
    {
      role: "assistant",
      content: "Hello Bob! How can I assist you today?"
    }
  ],
  input: "what's my name?",
  output: "Your name is Bob. How can I help you today, Bob?"
}

如果我们想自动跟踪这些消息，我们可以将其包装在 RunnableWithMessageHistory 中。

由于我们有多个输入，我们需要指定两件事

  • inputMessagesKey：用于添加到对话历史记录的输入键。
  • historyMessagesKey：用于将加载的消息添加到其中的键。

有关如何使用此功能的更多信息，请参阅本指南。

import { ChatMessageHistory } from "@langchain/community/stores/message/in_memory";
import { BaseChatMessageHistory } from "@langchain/core/chat_history";
import { RunnableWithMessageHistory } from "@langchain/core/runnables";

const store = {};

function getMessageHistory(sessionId: string): BaseChatMessageHistory {
  if (!(sessionId in store)) {
    store[sessionId] = new ChatMessageHistory();
  }
  return store[sessionId];
}

const agentWithChatHistory = new RunnableWithMessageHistory({
  runnable: agentExecutor,
  getMessageHistory,
  inputMessagesKey: "input",
  historyMessagesKey: "chat_history",
});

await agentWithChatHistory.invoke(
  { input: "hi! I'm bob" },
  { configurable: { sessionId: "<foo>" } }
);
{
  input: "hi! I'm bob",
  chat_history: [
    HumanMessage {
      "content": "hi! I'm bob",
      "additional_kwargs": {},
      "response_metadata": {}
    },
    AIMessage {
      "content": "Hello Bob! How can I assist you today?",
      "additional_kwargs": {},
      "response_metadata": {},
      "tool_calls": [],
      "invalid_tool_calls": []
    }
  ],
  output: "Hello Bob! How can I assist you today?"
}
await agentWithChatHistory.invoke(
  { input: "what's my name?" },
  { configurable: { sessionId: "<foo>" } }
);
{
  input: "what's my name?",
  chat_history: [
    HumanMessage {
      "content": "hi! I'm bob",
      "additional_kwargs": {},
      "response_metadata": {}
    },
    AIMessage {
      "content": "Hello Bob! How can I assist you today?",
      "additional_kwargs": {},
      "response_metadata": {},
      "tool_calls": [],
      "invalid_tool_calls": []
    },
    HumanMessage {
      "content": "what's my name?",
      "additional_kwargs": {},
      "response_metadata": {}
    },
    AIMessage {
      "content": "Your name is Bob! How can I help you today, Bob?",
      "additional_kwargs": {},
      "response_metadata": {},
      "tool_calls": [],
      "invalid_tool_calls": []
    }
  ],
  output: "Your name is Bob! How can I help you today, Bob?"
}

示例 LangSmith 追踪： https://smith.langchain.com/public/98c8d162-60ae-4493-aa9f-992d87bd0429/r

下一步​

总结！在本快速入门中，我们介绍了如何创建简单的代理。代理是一个复杂的主题，有很多东西要学习！

信息

本节介绍了如何使用 LangChain Agents 构建。LangChain Agents 非常适合入门，但超过一定程度后，您可能需要它们不提供的灵活性和控制力。对于使用更高级的代理，我们建议您查看 LangGraph。

您还可以参阅本指南，以帮助迁移到 LangGraph。

此页是否对您有帮助？


您也可以留下详细的反馈 在 GitHub 上.