LangChain实战

2025-03-16

参考: 一文入门 langchain.js，从 0-1 实现智能客服系统

LangChain.js 是 LangChain 的 JavaScript / TypeScript 版本，它是一个用于构建基于大语言模型（LLMs）的应用程序的开发框架。LangChain 最早是 Python 版本，后来推出了 JS 版本，以便前端和全栈开发者也能方便地构建智能应用。
各种大模型(LLMs)本身提供 HTTP/WS 等多种方式提供服务，为什么还需要使用 LangChain.js 访问大模型呢？

优势

相比直接调用大模型接口，LangChain.js 有很多优势：

对 Prompt 管理和链式执行很友好
内置 Agent 支持（调用工具）
对接多种数据源（RAG）
模块化能力强，适合构建复杂链条
跨平台能力好

对 Prompt 管理和链式执行很友好

LangChain.js 提供 PromptTemplate、Chain、Memory 等模块可以让开发人员管理复杂prompt 模板、复用提示词逻辑、支持上下文记忆（这一点非常重要）、以及串联多个步骤形成链条等功能。这些开箱即用的功能让程序员将精力聚焦在业务开发上。

LangChain.js 的 PromptTemplate 是用来管理和组织 Prompt（提示词）模板的核心工具。帮助构建、复用、动态插值 prompt，非常适合构建复杂的 LLM 调用逻辑

在 AI 程序开发中，我们直接写 prompt 的格式是这样的

1	const prompt = `请写一封主题为"${topic}"的中文邮件，语气要正式。`

这虽然简单，但在构建复杂的 AI 应用时，容易出现：多个 prompt 写重复代码，Prompt 结构不清晰，维护麻烦，变量插值不安全或不一致等问题

而使用 LangChain.js 后，可以利用它定义一个结构清晰的模板：

const formatted = await prompt.format({
  topic: "会议通知",
  tone: "正式",
});

最后的formatted结果是:

1	请写一封主题为"`会议通知`"的中文邮件，语气要正式。

上面说的是简单模板，下面看看复杂模板的例子:

const template = `
你是一位{role}。

请根据以下任务生成内容：
任务描述：{task}

要求：
1. 语言风格：{style}
2. 字数限制：{length}字以内

请开始：
`;

const prompt = new PromptTemplate({
  template,
  inputVariables: ["role", "task", "style", "length"],
});

“role”, “task”, “style”, “length”等都支持变量输入，显著提高模板准确性。上面的模板与LLMChain 联用

import { LLMChain } from "langchain/chains";
import { ChatOpenAI } from "langchain/chat_models/openai";

const llm = new ChatOpenAI({ temperature: 0.7 });

const chain = new LLMChain({
  llm,
  prompt,
});

const result = await chain.call({
  role: "营销专家",
  task: "推广一款新型运动饮料",
  style: "轻松幽默",
  length: "100",
});

这就完成了一个完整的「Prompt → 调用模型 → 返回结果」链条。

LangChain.js 中的 Chain 是整个框架的核心之一，它代表的是一个可组合、可复用的推理过程。你可以把它理解为一条「流水线」，每一步都基于上一步的结果，可以串联多个模块、多个大模型、多个工具，最终完成一个任务。
在 LangChain.js 里，Chain 是一个有输入、有输出的执行单元，通常包含以下几个部分：

输入（input）：来自用户或上一步链条的结果
处理逻辑（prompt、模型调用、工具调用等）
输出（output）：用于展示、保存、或传给下一个 Chain

Chain 的类型有很多，LLMChain 是最常用的链。使用PromptTemplate 构建提示词，喂给 AI 模型，生成结果。如下所示

import { LLMChain } from "langchain/chains";
import { PromptTemplate } from "langchain/prompts";
import { ChatOpenAI } from "langchain/chat_models/openai";

const prompt = new PromptTemplate({
  template: "写一篇关于{topic}的科普文章，语气要{tone}。",
  inputVariables: ["topic", "tone"],
});

const model = new ChatOpenAI({ temperature: 0.7 });

const chain = new LLMChain({ llm: model, prompt });

const res = await chain.call({
  topic: "量子计算",
  tone: "通俗易懂",
});

console.log(res.text);

SimpleSequentialChain 是顺序链，把多个 LLMChain 串起来，前一个的输出是后一个的输入。

import { SimpleSequentialChain } from "langchain/chains";

// chain1: 根据主题生成文章大纲
// chain2: 根据大纲生成文章内容

const chain = new SimpleSequentialChain({
  chains: [chain1, chain2],
  verbose: true,
});

const res = await chain.run("人工智能教育");

一步一步处理的流程，比如先写大纲 → 再扩写内容 → 再润色。

MultiPromptChain 是多 prompt 选择链，根据输入的不同选择不同prompt 来调用模型，适合场景切换。

1 2	// 如果你输入是“写代码”，就用编码 prompt； // 如果你输入是“写诗”，就用文艺 prompt。

RetrievalQAChain 是基于知识库问答，结合向量数据库和文档检索，实现 RAG（检索增强生成）

import { RetrievalQAChain } from "langchain/chains";
import { ChatOpenAI } from "langchain/chat_models/openai";

const chain = RetrievalQAChain.fromLLM(model, retriever);

const res = await chain.call({
  query: "ComfyUI 如何使用节点连接？",
});

ConversationalChain 是带记忆的对话链，用于实现多轮对话的上下文记忆，适用于聊天机器人

上面说了这么多内置的 Chain,实际上 LangChain.js 支持自定义 Chain,根据你的业务场景，通过继承 BaseChain 自定义链，或者组合多个 Chain、Tool、Agent构建高级流程

LangChain.js 中最后一个重要的模块是Memory模块。大家使用 ChatGPT 时经常会对一个问题进行多轮对话，小伙伴们开发这类产品时需要将多轮对话的内容传给 AI 模型，这样才利于AI 模型解决问题，而LangChain.js的Memory模块就是在多轮对话中保存和管理上下文信息，并在每次调用 LLM（大语言模型）时自动注入这些上下文内容。

在 LangChain 中，无论是 Runnable、Chain 还是 Agent，都可以通过 Memory 插件实现上下文记忆功能。

下面是一些常用的 Memory:

BufferMemory 保存对话的完整历史。
ConversationSummaryMemory 将对话内容通过 LLM 压缩为摘要，节省 token
BufferWindowMemory 和 BufferMemory 类似，但只保留最近 N 条对话，控制上下文大小。
ChatMessageHistory 这是一个更底层的模块，BufferMemory 也用它来管理历史消息。可以自定义实现，比如保存到数据库、Redis 等。

通过一个例子熟悉如何使用 Memory 模块:

import { ConversationChain } from "langchain/chains";
import { ChatOpenAI } from "langchain/chat_models/openai";

const model = new ChatOpenAI({ temperature: 0 });
const chain = new ConversationChain({ llm: model, memory });

const res1 = await chain.call({ input: "你好！" });
const res2 = await chain.call({ input: "刚刚我们聊到哪了？" });

第二次调用时，它会自动带上第一次的上下文。

内置 Agent 支持

LangChain.js 中的 Agent 是其最强大也最复杂的部分之一，允许开发人员构建可以“思考”和“行动”的智能体。这些 Agent 可以根据用户输入自动选择合适的工具（Tools）来执行任务，是实现 AI 助理、RPA、智能搜索等高级功能的关键。

在LangChain.js中，Agent 是一种可以动态选择工具并调用它们来完成任务的架构。它不是一段静态的 Chain，而是一个具有决策能力的系统。它会分析输入 → 决定用哪个工具 → 使用工具获得结果 → 再判断是否继续。

Agent 的核心组成部分：

LLM（大语言模型）：负责思考与决策
Tools（工具）：可以调用的实际功能，比如搜索、计算、数据库查询等
AgentExecutor：驱动 Agent 运行的引擎
Memory（可选）：用于保存历史，提高上下文智能

下面以 ZeroShotAgent 举例演示如何构建简单的 Agent:

import { initializeAgentExecutorWithOptions } from "langchain/agents";
import { ChatOpenAI } from "langchain/chat_models/openai";
import { Calculator } from "langchain/tools/calculator";

const model = new ChatOpenAI({ temperature: 0 });
const tools = [new Calculator()];

const executor = await initializeAgentExecutorWithOptions(tools, model, {
  agentType: "zero-shot-react-description",
});

const result = await executor.call({ input: "What is 25% of (456 * 34)?" });
console.log(result.output);

上面是一个简单的推理 Agent。有关 Agent 更多使用内容，请阅读官方文档

对接多种数据源（RAG）

RAG 是 Retrieval-Augmented Generation 的缩写，中文常翻译为“检索增强生成”。它是一种结合了信息检索和生成式 AI（如大型语言模型）的技术，广泛用于构建问答系统、文档助手、知识库问答等应用。

传统大模型（如 GPT）是“封闭式”的：它只能回答它训练数据中包含的信息。而 RAG 增强了这个过程：

Retrieval（检索）：首先从一个外部知识库（可以是文档、数据库、网页等）中，根据用户的问题检索出最相关的内容。
Augmented（增强）：把检索到的内容作为上下文输入，拼接到用户的问题前，一起交给语言模型处理。
Generation（生成）：模型结合上下文内容，生成更加准确、有依据的回答。

多数据源是什么呢？在现实生活中，我们的知识来方方面面，包括不限于：

文档（PDF、Markdown、TXT）
数据库（MySQL、MongoDB 等）
API 数据（如天气、股票、内部业务系统）
向量数据库（Pinecone、Weaviate、Supabase 等）
云存储（如 Notion、Google Drive、S3）
… 等等

LangChain.js 对接多种数据源是说 LangChain.js 从多个不同的数据源中并行或统一检索信息，整合为上下文，让模型回答更全面。

对接多种数据源会用到下列组件：

Retriever 检索器，从某个数据源中检索文档
VectorStore 向量数据库，用于相似度搜索
DocumentLoader 数据加载器，从不同格式中读取文档
Chain 串联多个组件形成问答流程
MultiRetriever 支持多个 Retriever 的组合（LangChain 的高级特性）

比如从各类文档中检索数据

1
2
3

import { PDFLoader } from "langchain/document_loaders/fs/pdf";
const loader = new PDFLoader("file.pdf");
const docs = await loader.load();

从数据库中检索数据:

import mysql from "mysql2/promise";

const connection = await mysql.createConnection({ host, user, password, database });
const [rows] = await connection.execute("SELECT * FROM knowledge_base");

const docs = rows.map(row => ({
  pageContent: row.content,
  metadata: { source: "mysql", id: row.id }
}));

从 Web/API 中检索数据:

import axios from "axios";

const res = await axios.get("https://api.com/data");
const docs = res.data.items.map(item => ({
  pageContent: item.description,
  metadata: { source: "api", id: item.id }
}));

将上面的数据源通过嵌入模型、构建向量库

import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "langchain/embeddings/openai";

const allDocs = [...docsFromPDF, ...docsFromMySQL, ...docsFromAPI];
const vectorStore = await MemoryVectorStore.fromDocuments(allDocs, new OpenAIEmbeddings());

const retriever = vectorStore.asRetriever();

最后构建RAG流程:

import { RetrievalQAChain } from "langchain/chains";

const chain = RetrievalQAChain.fromLLM(openai, multiRetriever);

const res = await chain.call({ query: "关于A和B的知识是什么？" });
console.log(res.text);

对接多种数据源主要解决什么问题？

因为每个LLM的训练的知识不是最新的，如果要获取今天或者昨天的数据，大模型不能提供，那么通过LangChain.js 去网络中搜索对应的知识，进行向量化、再思考优化回复问题，这样做到闭环

模块化能力强，适合构建复杂链条

笔者前面讲述了LangChain.js 的prompt 模版、Chain 和对接多数据源，可以发现这些都是 LangChain.js 提供的各种模块做的，所以说LangChain.js的模块化能力强。

LangChain.js 提供了很多“独立的功能模块”，各个功能模块都解耦独立，可以像拼积木一样任意组合、替换、嵌套，来构建自己的 AI 工作流。

LangChain.js 常见的“独立的功能模块”如下：

模块名	作用
LLM	调用大语言模型（如 OpenAI、Claude、LLama）
PromptTemplate	生成提示词模板
Chain	串联模块形成“处理链”
Retriever	用于从向量库等中检索文档
Memory记录对话历史等上下文
Tool	插件能力，可调用 API、函数等
Agent	智能体，拥有思考和调用工具的能力
VectorStore	向量数据库（如 Pinecone、Weaviate）
DocumentLoader	加载不同格式数据为文档

根据自己的产品业务，选择不同的模块进行拼接，搭建出 AI 应用

跨平台能力好

LangChain.js 的跨平台能力非常强，这是它相较于 Python 版本的一个突出优势。它能够在 Web 前端、Node.js 服务端、移动端甚至 Serverless 环境中灵活运行，为开发 AI 产品（如网页 AI 助理、移动应用、浏览器插件等）提供了极大的便利。

我们知道很多 AI 工具都是用 Python 写的，相关的生态工具也是 Python 写的。LangChain.js 完全使用 TypeScript/JavaScript 编写，没有 Python 库依赖，不需要额外环境配置。适合前端开发者直接上手，尤其是做 MPA、SPA、PWA、小程序、Expo和 Electron等，非常适合前端开发人员使用。

LangChain.js 核心知识点

1. 文档加载器（Document Loaders）

用于从各种来源加载文档，包括PDF、HTML、文本文件等。

// server/services/documentLoader.js
import { CSVLoader } from "@langchain/community/document_loaders/fs/csv";
import { DocxLoader } from "@langchain/community/document_loaders/fs/docx";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { JSONLoader } from "langchain/document_loaders/fs/json";
import { TextLoader } from "langchain/document_loaders/fs/text";

// 根据文件类型选择加载器
switch (ext) {
  case ".txt":
  case ".md":
    loader = new TextLoader(filePath);
    break;
  case ".pdf":
    loader = new PDFLoader(filePath);
    break;
  case ".csv":
    loader = new CSVLoader(filePath);
    break;
  case ".json":
    loader = new JSONLoader(filePath);
    break;
  case ".docx":
    loader = new DocxLoader(filePath);
    break;
}

// 加载文档
const docs = await loader.load();

2. 文本分割器（Text Splitters）

将长文本分割成适合向量存储的小块

// server/services/vectorStore.js
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";

/**
 * 创建文本分割器
 * @param {number} chunkSize 文本块大小
 * @param {number} chunkOverlap 重叠大小
 * @returns {RecursiveCharacterTextSplitter} 文本分割器
 */
export function createTextSplitter(chunkSize = 500, chunkOverlap = 50) {
  return new RecursiveCharacterTextSplitter({
    chunkSize,
    chunkOverlap,
  });
}

/**
 * 将文档拆分成较小的块
 */
export async function splitDocuments(documents, textSplitter) {
  if (!textSplitter) {
    textSplitter = createTextSplitter();
  }
  
  // 拆分所有文档
  const splitDocs = [];

  for (const doc of documents) {
    const splits = await textSplitter.splitDocuments([doc]);
    splitDocs.push(...splits);
  }

  console.log(`将 ${documents.length} 个文档分割为 ${splitDocs.length} 个块`);
  return splitDocs;
}

3. 向量存储（Vector Stores）

存储文档的向量表示，支持相似度搜索。

/ server/services/vectorStore.js
import { MemoryVectorStore } from "langchain/vectorstores/memory";

/**
 * 从序列化数据加载内存向量存储
 */
export async function loadVectorStore(storePath, embeddings) {
  const jsonPath = `${storePath}.json`;

  // 读取序列化数据
  const serialized = fs.readFileSync(jsonPath, "utf-8");
  const data = JSON.parse(serialized);

  // 创建新的内存向量存储
  const vectorStore = new MemoryVectorStore(embeddings);

  // 手动设置内存向量
  vectorStore.memoryVectors = data.vectors;
  vectorStore.documentIds = data.documentIds;

  return vectorStore;
}

4. 检索器（Retrievers）

从向量存储中检索相关文档。

// 从server/services/queryService.js的createQAChain函数中提取
const PROMPT = PromptTemplate.fromTemplate(template);

// 创建问答链
return new RetrievalQAChain({
  combineDocumentsChain: loadQAStuffChain(llm, { prompt: PROMPT }),
  retriever: vectorStore.asRetriever(), // 向量库
  returnSourceDocuments: true,
});

5. 链（Chains）

将多个组件连接起来，形成端到端的应用流程。

LangChain.js 提供了多种专用链，用于解决不同场景的问题：

RetrievalChain (createRetrievalChain) - 融合记忆的对话检索链

结合了对话历史记忆和文档检索功能，用于构建能够记住上下文的问答系统，也是本项目中使用到的链。在 LangChain.js 最新版本中，使用 createRetrievalChain 和 createStuffDocumentsChain 函数构建这种链：

import { createRetrievalChain } from "langchain/chains/retrieval";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
import { BufferMemory } from "langchain/memory";

// 创建记忆实例
const memory = new BufferMemory({
  memoryKey: "chat_history",
  returnMessages: true,
  inputKey: "question",
  outputKey: "text",
});

// 创建文档合并链
const documentChain = await createStuffDocumentsChain({
  llm,
  prompt: PromptTemplate.fromTemplate(qaTemplate),
});

// 创建检索链
const chain = createRetrievalChain({
  retriever: vectorStore.asRetriever(),
  combineDocsChain: documentChain,
  memory,
  returnSourceDocuments: true,
});

// 首次查询
const result1 = await chain.invoke({
  question: "什么是向量数据库?"
});

// 后续查询(自动包含对话历史)
const result2 = await chain.invoke({
  question: "它有哪些优势?"
});

SequentialChain - 按顺序执行的多步链

允许多个链按照特定顺序执行，前一个链的输出可以作为后一个链的输入。

import { SequentialChain, LLMChain } from "langchain/chains";

// 第一个链：生成产品特性
const featureChain = new LLMChain({
  llm: model,
  prompt: PromptTemplate.fromTemplate("列出{product}的三个主要特性"),
  outputKey: "features",
});

// 第二个链：根据特性写营销文案
const copywritingChain = new LLMChain({
  llm: model,
  prompt: PromptTemplate.fromTemplate("根据这些特性为{product}写一段营销文案:\n{features}"),
  outputKey: "marketing_copy",
});

// 组合成顺序链
const overallChain = new SequentialChain({
  chains: [featureChain, copywritingChain],
  inputVariables: ["product"],
  outputVariables: ["marketing_copy"],
});

const result = await overallChain.invoke({
  product: "智能手表",
});

RouterChain - 智能路由链

根据输入内容动态选择应该使用哪条链进行处理，适合构建能处理多种不同任务的系统。

import { LLMRouterChain, RouterOutputParser } from "langchain/chains";

const productChain = new LLMChain({/*...产品查询链...*/});
const supportChain = new LLMChain({/*...客服支持链...*/});
const feedbackChain = new LLMChain({/*...用户反馈链...*/});

const routerChain = LLMRouterChain.fromLLM(
  model,
  RouterOutputParser.fromZodSchema(z.object({
    destination: z.enum(["product", "support", "feedback"]),
    next_inputs: z.object({
      query: z.string(),
    }),
  }))
);

const chain = new MultiRouteChain({
  routerChain,
  destinationChains: {
    product: productChain,
    support: supportChain,
    feedback: feedbackChain,
  },
  defaultChain: new LLMChain({/*...默认链...*/}),
});

const result = await chain.invoke({
  input: "我想了解你们的新产品"
});

以下是 LangChain.js 中其他常用的链类型，可以根据不同需求选择使用：

LLMChain - 最基础的提示词处理链

将提示模板与语言模型结合的最基础链，是许多其他链的基础组件。

import { LLMChain } from "langchain/chains";
import { PromptTemplate } from "@langchain/core/prompts";

const prompt = PromptTemplate.fromTemplate(
  "请为{product}写一个简短的产品描述，面向{audience}用户"
);

const chain = new LLMChain({
  llm: model,
  prompt: prompt
});

const result = await chain.invoke({
  product: "智能音箱",
  audience: "年轻人"
});

RetrievalQAChain - 基础检索问答链

用于从向量存储中检索文档并生成答案：

// server/services/queryService.js
import { RetrievalQAChain, loadQAStuffChain } from "langchain/chains";

/**
 * 创建问答链
 */
export async function createQAChain(
  llm,
  vectorStore,
  promptTemplate,
  sessionId
) {
  // 获取历史记录
  let historyText = "";
  if (sessionId) {
    try {
      historyText = await getFormattedHistory(sessionId);
    } catch (error) {
      console.error("获取历史记录失败:", error);
    }
  }

  // 默认提示模板
  let template;
  if (sessionId && historyText) {
    // 带上下文的提示模板
    template =
      promptTemplate ||
      `请根据以下信息回答用户的问题。如果无法从提供的信息中找到答案，请明确告知您不知道，不要编造信息。

信息:
{context}

对话历史:
${historyText}

用户问题: {question}

请用中文简明扼要地回答:`;
  } else {
    // 无上下文的提示模板
    template =
      promptTemplate ||
      `请根据以下信息回答用户的问题。如果无法从提供的信息中找到答案，请明确告知您不知道，不要编造信息。

信息:
{context}

用户问题: {question}

请用中文简明扼要地回答:`;
  }

  const PROMPT = PromptTemplate.fromTemplate(template);

  // 创建问答链
  return new RetrievalQAChain({
    combineDocumentsChain: loadQAStuffChain(llm, { prompt: PROMPT }),
    retriever: vectorStore.asRetriever(),
    returnSourceDocuments: true,
  });
}

这些链可以根据实际需求组合使用，LangChain.js 的强大之处就在于它提供了高度模块化的组件，使开发者能够灵活构建各种复杂的LLM应用。在本项目中，我们主要使用了 RetrievalChain 来实现基于知识库的问答功能，结合 BufferMemory 实现多轮对话能力。

6. 代理（Agents）

能够根据用户输入动态选择工具和执行步骤的系统。在本项目中，使用了 LangChain 的代理功能实现智能路由和增强回答能力：

// server/services/agentService.js
import { Serper } from "@langchain/community/tools/serper";
import { Tool } from "@langchain/core/tools";
import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
import { createEmbeddingModel } from "./embeddings.js";
import { addToMemory, getMemoryForSession } from "./memoryService.js";
import { createChatModel } from "./queryService.js";
import { loadVectorStore, similaritySearch } from "./vectorStore.js";

/**
 * 创建一个自定义的知识库工具
 * @param {string} vectorStorePath 向量存储路径
 * @param {number} similarityThreshold 相似度阈值
 * @returns {Tool} 知识库工具
 */
export function createKnowledgeBaseTool(
  vectorStorePath,
  similarityThreshold = 0.6
) {
  class KnowledgeBaseTool extends Tool {
    name = "knowledge_base";
    description = "用于在知识库中搜索相关内容。输入是用户查询文本。";
    vectorStorePath;
    threshold;

    constructor(vectorStorePath, threshold) {
      super();
      this.vectorStorePath = vectorStorePath;
      this.threshold = threshold;
    }

    async _call(query) {
      try {
        const embeddings = createEmbeddingModel();
        const vectorStore = await loadVectorStore(
          this.vectorStorePath,
          embeddings
        );

        // 执行相似度搜索
        const results = await similaritySearch(
          vectorStore,
          query,
          4,
          this.threshold
        );

        if (results.length === 0) {
          return "在知识库中未找到相关信息。";
        }

        // 提取结果内容并格式化
        const formattedResults = results
          .map(([doc, score], index) => {
            return `[${index + 1}] 相关度: ${score.toFixed(2)}\n${
              doc.pageContent
            }\n来源: ${doc.metadata.source || "未知"}\n`;
          })
          .join("\n");

        return `在知识库中找到以下相关内容:\n${formattedResults}`;
      } catch (error) {
        console.error("知识库搜索失败:", error);
        return `知识库搜索出错: ${error.message}`;
      }
    }
  }

  return new KnowledgeBaseTool(vectorStorePath, similarityThreshold);
}

/**
 * 使用Agent执行智能查询
 * @param {string} query 用户查询
 * @param {Object} options 选项
 * @returns {Promise<object>} 查询结果
 */
export async function executeAgentQuery(query, options) {
  const {
    vectorStorePath,
    apiKey,
    apiEndpoint,
    modelName = "gpt-3.5-turbo",
    similarityThreshold = 0.6,
    sessionId = null,
    verbose = false,
  } = options;

  try {
    console.log(
      `使用Agent执行智能查询: "${query.substring(0, 100)}${
        query.length > 100 ? "..." : ""
      }"`
    );

    // 创建LLM模型
    const llm = createChatModel(apiKey, modelName, apiEndpoint);

    // 创建工具集合
    const tools = [
      // 网络搜索工具
      new Serper({
        apiKey: process.env.SERPER_API_KEY,
        gl: "cn", // 地区设置为中国
        hl: "zh-cn", // 语言设置为中文
      }),
      // 知识库搜索工具
      createKnowledgeBaseTool(vectorStorePath, similarityThreshold),
    ];

    // 获取会话记忆
    const memory = sessionId ? getMemoryForSession(sessionId) : null;

    // 初始化Agent - 使用新的API创建Agent
    const agent = await createOpenAIFunctionsAgent({
      llm,
      tools,
      verbose: verbose || process.env.DEBUG === "true",
    });

    const executor = AgentExecutor.fromAgentAndTools({
      agent,
      tools,
      memory,
      verbose: verbose || process.env.DEBUG === "true",
      maxIterations: 5, // 最大迭代次数，防止无限循环
    });

    console.log("Agent已初始化，开始执行查询...");

    // 执行查询
    const result = await executor.invoke({
      input: `${query} 请根据问题内容，判断应该使用网络搜索还是知识库搜索，或者两者都使用。请用中文回答，保持回答简洁明了。`,
    });

    const answer = result.output;

    // 如果有会话ID，将对话添加到记忆中
    if (sessionId) {
      await addToMemory(sessionId, query, answer);
    }

    return {
      answer,
      source: "agent",
      usedGeneralModel: false,
      usedWebSearch: true,
      usedKnowledgeBase: true,
    };
  } catch (error) {
    console.error("Agent执行查询失败:", error);
    throw error;
  }
}

在本项目中，代理系统通过以下方式增强了智能客服能力：

工具集成：将网络搜索和知识库搜索集成为工具，供代理使用
动态决策：代理会根据用户问题的性质，自动决定使用哪种工具
统一接口：通过 executeAgentQuery 函数提供与普通查询相同的接口，便于集成
思维链追踪：支持 verbose 模式，可以查看代理的决策过程，便于调试

LangChain.js 使用场景

构建智能问答系统（例如 ChatGPT 接入企业知识库）
Agent 应用（模型会调用搜索、数据库、API）
多轮对话系统（例如客服机器人）
智能总结、翻译、内容生成

LangChain.js在项目中的应用价值

LangChain.js 作为一个强大的LLM应用开发框架，在本项目中展现出以下优势：

组件化开发：提供了丰富的预构建组件，如文档加载器、文本分割器、向量存储等
链式调用：能够将多个处理步骤组合为统一的调用链，简化复杂流程
提示词工程：内置提示词模板系统，便于管理和优化与LLM的交互
代理系统：支持基于工具的智能代理，使AI能够根据需要选择不同功能
多模型支持：与多种LLM和嵌入模型兼容，提供更大的灵活性