跳到主要内容

构建检索增强生成 (RAG) 应用：第 1 部分

大型语言模型 (LLM) 支持的最强大的应用之一是复杂的问答 (Q&A) 聊天机器人。这些应用可以回答关于特定来源信息的问题。这些应用使用一种称为检索增强生成的技术，或 RAG。

这是一个多部分教程

  • 第 1 部分（本指南）介绍 RAG 并逐步完成最小的实现。
  • 第 2 部分 扩展了实现，以适应对话式交互和多步骤检索过程。

本教程将展示如何构建一个简单的基于文本数据源的问答应用。在此过程中，我们将回顾典型的问答架构，并重点介绍用于更高级问答技术的其他资源。我们还将了解 LangSmith 如何帮助我们跟踪和理解我们的应用。随着我们的应用复杂性增加，LangSmith 将变得越来越有用。

如果您已经熟悉基本检索，您可能也会对这篇 不同检索技术的高级概述 感兴趣。

注意：这里我们专注于非结构化数据的问答。如果您对基于结构化数据的 RAG 感兴趣，请查看我们关于 基于 SQL 数据的问答 的教程。

概述​

典型的 RAG 应用有两个主要组成部分

索引：用于从源摄取数据并对其建立索引的管道。这通常离线发生。

检索和生成：实际的 RAG 链，它在运行时获取用户查询，并从索引中检索相关数据，然后将其传递给模型。

注意：本教程的索引部分将主要遵循 语义搜索教程。

从原始数据到答案的最常见完整序列如下所示

索引​

  1. 加载：首先我们需要加载我们的数据。这通过 文档加载器 完成。
  2. 分割：文本分割器 将大型 Documents 分解为更小的块。这对于索引数据和将其传递到模型中都很有用，因为大型块更难搜索，并且无法容纳在模型的有限上下文窗口中。
  3. 存储：我们需要一个地方来存储和索引我们的分割块，以便稍后可以对其进行搜索。这通常使用 向量数据库 和 嵌入模型 完成。

index_diagram

检索和生成​

  1. 检索：给定用户输入，使用 检索器 从存储中检索相关分割块。
  2. 生成：聊天模型 / LLM 使用提示生成答案，该提示既包含问题又包含检索到的数据

retrieval_diagram

一旦我们索引了数据，我们将使用 LangGraph 作为我们的编排框架来实现检索和生成步骤。

设置​

Jupyter Notebook​

本教程和其他教程可能最方便在 Jupyter notebooks 中运行。在交互式环境中学习指南是更好地理解它们的好方法。有关如何安装的说明，请参阅 此处。

安装​

本指南需要以下依赖项

yarn add langchain @langchain/core @langchain/langgraph

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

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

组件​

我们将需要从 LangChain 的集成套件中选择三个组件。

聊天模型

选择您的聊天模型

安装依赖项

提示

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

yarn add @langchain/groq

添加环境变量

GROQ_API_KEY=your-api-key

实例化模型

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

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

嵌入模型

选择您的嵌入模型

安装依赖项

yarn add @langchain/openai
OPENAI_API_KEY=your-api-key
import { OpenAIEmbeddings } from "@langchain/openai";

const embeddings = new OpenAIEmbeddings({
  model: "text-embedding-3-large"
});

以及 向量数据库

选择您的向量数据库

安装依赖项

yarn add langchain
import { MemoryVectorStore } from "langchain/vectorstores/memory";

const vectorStore = new MemoryVectorStore(embeddings);

预览​

在本指南中，我们将构建一个应用，用于回答关于网站内容的问题。我们将使用的具体网站是 Lilian Weng 的 LLM Powered Autonomous Agents 博客文章，这使我们能够询问关于文章内容的问题。

我们可以创建一个简单的索引管道和 RAG 链，用大约 50 行代码来完成此操作。

import "cheerio";
import { CheerioWebBaseLoader } from "@langchain/community/document_loaders/web/cheerio";
import { Document } from "@langchain/core/documents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { pull } from "langchain/hub";
import { Annotation, StateGraph } from "@langchain/langgraph";
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";


// Load and chunk contents of blog
const pTagSelector = "p";
const cheerioLoader = new CheerioWebBaseLoader(
  "https://lilianweng.github.io/posts/2023-06-23-agent/",
  {
    selector: pTagSelector
  }
);

const docs = await cheerioLoader.load();

const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000, chunkOverlap: 200
});
const allSplits = await splitter.splitDocuments(docs);


// Index chunks
await vectorStore.addDocuments(allSplits)

// Define prompt for question-answering
const promptTemplate = await pull<ChatPromptTemplate>("rlm/rag-prompt");

// Define state for application
const InputStateAnnotation = Annotation.Root({
  question: Annotation<string>,
});

const StateAnnotation = Annotation.Root({
  question: Annotation<string>,
  context: Annotation<Document[]>,
  answer: Annotation<string>,
});

// Define application steps
const retrieve = async (state: typeof InputStateAnnotation.State) => {
  const retrievedDocs = await vectorStore.similaritySearch(state.question)
  return { context: retrievedDocs };
};


const generate = async (state: typeof StateAnnotation.State) => {
  const docsContent = state.context.map(doc => doc.pageContent).join("\n");
  const messages = await promptTemplate.invoke({ question: state.question, context: docsContent });
  const response = await llm.invoke(messages);
  return { answer: response.content };
};


// Compile application and test
const graph = new StateGraph(StateAnnotation)
  .addNode("retrieve", retrieve)
  .addNode("generate", generate)
  .addEdge("__start__", "retrieve")
  .addEdge("retrieve", "generate")
  .addEdge("generate", "__end__")
  .compile();
let inputs = { question: "What is Task Decomposition?" };

const result = await graph.invoke(inputs);
console.log(result.answer);
Task decomposition is the process of breaking down complex tasks into smaller, more manageable steps. This can be achieved through various methods, including prompting large language models (LLMs) or using task-specific instructions. Techniques like Chain of Thought (CoT) and Tree of Thoughts further enhance this process by structuring reasoning and exploring multiple possibilities at each step.

查看 LangSmith 跟踪。

详细步骤​

让我们逐步了解上面的代码，以真正理解发生了什么。

1. 索引​

注意

本节是 语义搜索教程 内容的缩写版本。如果您对 文档加载器、嵌入 和 向量数据库 感到舒适，请随意跳到下一节关于 检索和生成。

加载文档​

我们首先需要加载博客文章内容。我们可以使用 DocumentLoaders 来完成此操作，它们是从源加载数据并返回 Documents 列表的对象。Document 是一个对象，其中包含一些 pageContent (string) 和 metadata (Record<string, any>)。

在本例中，我们将使用 CheerioWebBaseLoader，它使用 cheerio 从 Web URL 加载 HTML 表单并将其解析为文本。我们可以将自定义选择器传递给构造函数，以仅解析特定元素

import "cheerio";
import { CheerioWebBaseLoader } from "@langchain/community/document_loaders/web/cheerio";

const pTagSelector = "p";
const cheerioLoader = new CheerioWebBaseLoader(
  "https://lilianweng.github.io/posts/2023-06-23-agent/",
  {
    selector: pTagSelector,
  }
);

const docs = await cheerioLoader.load();

console.assert(docs.length === 1);
console.log(`Total characters: ${docs[0].pageContent.length}`);
Total characters: 22360
console.log(docs[0].pageContent.slice(0, 500));
Building agents with LLM (large language model) as its core controller is a cool concept. Several proof-of-concepts demos, such as AutoGPT, GPT-Engineer and BabyAGI, serve as inspiring examples. The potentiality of LLM extends beyond generating well-written copies, stories, essays and programs; it can be framed as a powerful general problem solver.In a LLM-powered autonomous agent system, LLM functions as the agent’s brain, complemented by several key components:A complicated task usually involv

深入了解​

DocumentLoader：从源加载数据作为 Documents 列表的类。

分割文档​

我们加载的文档超过 42k 个字符，这太长了，无法放入许多模型的上下文窗口中。即使对于那些可以将整篇文章放入其上下文窗口的模型，模型也可能难以在非常长的输入中找到信息。

为了处理这个问题，我们将 Document 分割成块，用于嵌入和向量存储。这应该有助于我们在运行时仅检索博客文章的最相关部分。

与 语义搜索教程 中一样，我们使用 RecursiveCharacterTextSplitter，它将使用常见的分隔符（如换行符）递归地分割文档，直到每个块都达到适当的大小。这是通用文本用例的推荐文本分割器。

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";

const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
const allSplits = await splitter.splitDocuments(docs);
console.log(`Split blog post into ${allSplits.length} sub-documents.`);
Split blog post into 29 sub-documents.

深入了解​

TextSplitter：将 Documents 列表分割成更小块的对象。DocumentTransformers 的子类。 - 探索 Context-aware splitters，它保留原始 Document 中每个分割块的位置（“上下文”）： - Markdown 文件 - 代码 (15+ 种语言) - 接口：基本接口的 API 参考。

DocumentTransformer：对 Documents 列表执行转换的对象。 - 文档：关于如何使用 DocumentTransformers 的详细文档 - 集成 - 接口：基本接口的 API 参考。

存储文档​

现在我们需要索引我们的 66 个文本块，以便我们可以在运行时搜索它们。按照 语义搜索教程，我们的方法是 嵌入 每个文档分割块的内容，并将这些嵌入插入到 向量数据库 中。给定输入查询，我们可以随后使用向量搜索来检索相关文档。

我们可以使用在 教程开始时 选择的向量数据库和嵌入模型，在一个命令中嵌入和存储我们所有的文档分割块。

await vectorStore.addDocuments(allSplits);

深入了解​

Embeddings：文本嵌入模型的包装器，用于将文本转换为嵌入。 - 文档：关于如何使用嵌入的详细文档。 - 集成：超过 30 种集成可供选择。 - 接口：基本接口的 API 参考。

VectorStore：向量数据库的包装器，用于存储和查询嵌入。 - 文档：关于如何使用向量数据库的详细文档。 - 集成：超过 40 种集成可供选择。 - 接口：基本接口的 API 参考。

这完成了管道的 索引 部分。此时，我们有一个可查询的向量数据库，其中包含我们博客文章的块状内容。给定用户问题，我们理想情况下应该能够返回回答该问题的博客文章片段。

2. 检索和生成​

现在让我们编写实际的应用逻辑。我们想要创建一个简单的应用，它接受用户问题，搜索与该问题相关的文档，将检索到的文档和初始问题传递给模型，并返回答案。

对于生成，我们将使用在 教程开始时 选择的聊天模型。

我们将使用 LangChain 提示中心（此处）中检查过的 RAG 提示。

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

const promptTemplate = await pull<ChatPromptTemplate>("rlm/rag-prompt");

// Example:
const example_prompt = await promptTemplate.invoke({
  context: "(context goes here)",
  question: "(question goes here)",
});
const example_messages = example_prompt.messages;

console.assert(example_messages.length === 1);
example_messages[0].content;
You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
Question: (question goes here)
Context: (context goes here)
Answer:

我们将使用 LangGraph 将检索和生成步骤联系在一起，形成一个单一的应用。这将带来许多好处

  • 我们可以定义一次应用逻辑，并自动支持多种调用模式，包括流式传输、异步和批量调用。
  • 我们通过 LangGraph 平台 获得简化的部署。
  • LangSmith 将自动跟踪我们应用的步骤。
  • 我们可以轻松地向我们的应用添加关键功能，包括 持久化 和 人工参与审批，只需最少的代码更改。

要使用 LangGraph，我们需要定义三件事

  1. 我们应用的状态；
  2. 我们应用的节点（即，应用步骤）；
  3. 我们应用的“控制流”（例如，步骤的顺序）。

状态：​

我们应用的 状态 控制着什么数据输入到应用中，在步骤之间传输，以及由应用输出。

对于简单的 RAG 应用，我们只需跟踪输入问题、检索到的上下文和生成的答案。

在此处阅读有关定义图状态的更多信息 此处。

import { Document } from "@langchain/core/documents";
import { Annotation } from "@langchain/langgraph";

const InputStateAnnotation = Annotation.Root({
  question: Annotation<string>,
});

const StateAnnotation = Annotation.Root({
  question: Annotation<string>,
  context: Annotation<Document[]>,
  answer: Annotation<string>,
});

节点（应用步骤）​

让我们从两个步骤的简单序列开始：检索和生成。

import { concat } from "@langchain/core/utils/stream";

const retrieve = async (state: typeof InputStateAnnotation.State) => {
  const retrievedDocs = await vectorStore.similaritySearch(state.question);
  return { context: retrievedDocs };
};

const generate = async (state: typeof StateAnnotation.State) => {
  const docsContent = state.context.map((doc) => doc.pageContent).join("\n");
  const messages = await promptTemplate.invoke({
    question: state.question,
    context: docsContent,
  });
  const response = await llm.invoke(messages);
  return { answer: response.content };
};

我们的检索步骤只是使用输入问题运行相似性搜索，生成步骤将检索到的上下文和原始问题格式化为聊天模型的提示。

控制流​

最后，我们将我们的应用编译成一个单一的 graph 对象。在本例中，我们只是将检索和生成步骤连接成一个单一的序列。

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

const graph = new StateGraph(StateAnnotation)
  .addNode("retrieve", retrieve)
  .addNode("generate", generate)
  .addEdge("__start__", "retrieve")
  .addEdge("retrieve", "generate")
  .addEdge("generate", "__end__")
  .compile();

LangGraph 还附带内置实用程序，用于可视化您应用的控制流

// Note: tslab only works inside a jupyter notebook. Don't worry about running this code yourself!
import * as tslab from "tslab";

const image = await graph.getGraph().drawMermaidPng();
const arrayBuffer = await image.arrayBuffer();

await tslab.display.png(new Uint8Array(arrayBuffer));

graph_img_rag

我需要使用 LangGraph 吗？

构建 RAG 应用不需要 LangGraph。实际上，我们可以通过调用各个组件来实现相同的应用逻辑

let question = "...";

const retrievedDocs = await vectorStore.similaritySearch(question);
const docsContent = retrievedDocs.map((doc) => doc.pageContent).join("\n");
const messages = await promptTemplate.invoke({
  question: question,
  context: docsContent,
});
const answer = await llm.invoke(messages);

LangGraph 的好处包括

  • 支持多种调用模式：如果我们想要流式传输输出令牌，或流式传输各个步骤的结果，则需要重写此逻辑；
  • 通过 LangSmith 自动支持跟踪，并通过 LangGraph 平台 支持部署；
  • 支持持久化、人工参与审批和其他功能。

许多用例需要在对话体验中使用 RAG，这样用户可以通过有状态的对话接收上下文相关的答案。正如我们将在教程的 第 2 部分 中看到的那样，LangGraph 对状态的管理和持久化极大地简化了这些应用。

使用方法​

让我们测试一下我们的应用！LangGraph 支持多种调用模式，包括同步、异步和流式传输。

调用

let inputs = { question: "What is Task Decomposition?" };

const result = await graph.invoke(inputs);
console.log(result.context.slice(0, 2));
console.log(`\nAnswer: ${result["answer"]}`);
[
  Document {
    pageContent: 'hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.Task decomposition can be done (1) by LLM with simple prompting like "Steps for XYZ.\\n1.", "What are the subgoals for achieving XYZ?", (2) by using task-specific instructions; e.g. "Write a story outline." for writing a novel, or (3) with human inputs.Another quite distinct approach, LLM+P (Liu et al. 2023), involves relying on an external classical planner to do long-horizon planning. This approach utilizes the Planning Domain',
    metadata: {
      source: 'https://lilianweng.github.io/posts/2023-06-23-agent/',
      loc: [Object]
    },
    id: undefined
  },
  Document {
    pageContent: 'Building agents with LLM (large language model) as its core controller is a cool concept. Several proof-of-concepts demos, such as AutoGPT, GPT-Engineer and BabyAGI, serve as inspiring examples. The potentiality of LLM extends beyond generating well-written copies, stories, essays and programs; it can be framed as a powerful general problem solver.In a LLM-powered autonomous agent system, LLM functions as the agent’s brain, complemented by several key components:A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.Chain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.Tree of Thoughts (Yao et al.',
    metadata: {
      source: 'https://lilianweng.github.io/posts/2023-06-23-agent/',
      loc: [Object]
    },
    id: undefined
  }
]

Answer: Task decomposition is the process of breaking down complex tasks into smaller, more manageable steps. This can be achieved through various methods, including prompting large language models (LLMs) to outline steps or using task-specific instructions. Techniques like Chain of Thought (CoT) and Tree of Thoughts further enhance this process by structuring reasoning and exploring multiple possibilities at each step.

流式传输步骤

console.log(inputs);
console.log("\n====\n");
for await (const chunk of await graph.stream(inputs, {
  streamMode: "updates",
})) {
  console.log(chunk);
  console.log("\n====\n");
}
{ question: 'What is Task Decomposition?' }

====

{
  retrieve: { context: [ [Document], [Document], [Document], [Document] ] }
}

====

{
  generate: {
    answer: 'Task decomposition is the process of breaking down complex tasks into smaller, more manageable steps. This can be achieved through various methods, including prompting large language models (LLMs) or using task-specific instructions. Techniques like Chain of Thought (CoT) and Tree of Thoughts further enhance this process by structuring reasoning and exploring multiple possibilities at each step.'
  }
}

====

流式传输 令牌 (需要 @langchain/core>>= 0.3.24 和 @langchain/langgraph>>= 0.2.34 与上述实现)

const stream = await graph.stream(inputs, { streamMode: "messages" });

for await (const [message, _metadata] of stream) {
  process.stdout.write(message.content + "|");
}
|Task| decomposition| is| the| process| of| breaking| down| complex| tasks| into| smaller|,| more| manageable| steps|.| This| can| be| achieved| through| various| methods|,| including| prompting| large| language| models| (|LL|Ms|)| to| outline| steps| or| using| task|-specific| instructions|.| Techniques| like| Chain| of| Thought| (|Co|T|)| and| Tree| of| Thoughts| further| enhance| this| process| by| struct|uring| reasoning| and| exploring| multiple| possibilities| at| each| step|.||
注意

使用当前实现，在 generate 步骤中使用 .invoke 流式传输令牌，需要 @langchain/core >= 0.3.24 和 @langchain/langgraph >= 0.2.34。有关详细信息，请参阅 此处。

返回来源​

请注意，通过将检索到的上下文存储在图的状态中，我们在状态的 "context" 字段中恢复了模型生成的答案的来源。有关更多详细信息，请参阅 本指南，了解如何返回来源。

深入了解​

聊天模型 接收一系列消息并返回一条消息。

自定义提示

如上所示，我们可以从提示中心加载提示（例如，此 RAG 提示）。提示也可以轻松自定义。例如

const template = `Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Use three sentences maximum and keep the answer as concise as possible.
Always say "thanks for asking!" at the end of the answer.

{context}

Question: {question}

Helpful Answer:`;

const promptTemplateCustom = ChatPromptTemplate.fromMessages([
  ["user", template],
]);

查询分析​

到目前为止，我们正在使用原始输入查询执行检索。但是，允许模型生成用于检索目的的查询有一些优点。例如

  • 除了语义搜索，我们可以构建结构化过滤器（例如，“查找自 2020 年以来的文档。”）；
  • 模型可以将用户查询（可能是多方面的或包含不相关的语言）重写为更有效的搜索查询。

查询分析 使用模型从原始用户输入转换或构建优化的搜索查询。我们可以轻松地将查询分析步骤合并到我们的应用中。为了说明目的，让我们向向量数据库中的文档添加一些元数据。我们将向文档添加一些（人为设计的）部分，我们稍后可以在其上进行过滤。

const totalDocuments = allSplits.length;
const third = Math.floor(totalDocuments / 3);

allSplits.forEach((document, i) => {
  if (i < third) {
    document.metadata["section"] = "beginning";
  } else if (i < 2 * third) {
    document.metadata["section"] = "middle";
  } else {
    document.metadata["section"] = "end";
  }
});

allSplits[0].metadata;
{
  source: 'https://lilianweng.github.io/posts/2023-06-23-agent/',
  loc: { lines: { from: 1, to: 1 } },
  section: 'beginning'
}

我们将需要更新向量数据库中的文档。我们将为此使用一个简单的 MemoryVectorStore，因为我们将使用它的一些特定功能（即，元数据过滤）。有关您选择的向量数据库的相关功能，请参阅向量数据库 集成文档。

import { MemoryVectorStore } from "langchain/vectorstores/memory";

const vectorStoreQA = new MemoryVectorStore(embeddings);
await vectorStoreQA.addDocuments(allSplits);

接下来让我们为我们的搜索查询定义一个模式。我们将为此目的使用 结构化输出。这里我们将查询定义为包含字符串查询和文档部分（“开头”、“中间”或“结尾”），但这可以根据您的喜好进行定义。

import { z } from "zod";

const searchSchema = z.object({
  query: z.string().describe("Search query to run."),
  section: z.enum(["beginning", "middle", "end"]).describe("Section to query."),
});

const structuredLlm = llm.withStructuredOutput(searchSchema);

最后，我们向我们的 LangGraph 应用添加一个步骤，以从用户的原始输入生成查询

const StateAnnotationQA = Annotation.Root({
  question: Annotation<string>,
  search: Annotation<z.infer<typeof searchSchema>>,
  context: Annotation<Document[]>,
  answer: Annotation<string>,
});

const analyzeQuery = async (state: typeof InputStateAnnotation.State) => {
  const result = await structuredLlm.invoke(state.question);
  return { search: result };
};

const retrieveQA = async (state: typeof StateAnnotationQA.State) => {
  const filter = (doc) => doc.metadata.section === state.search.section;
  const retrievedDocs = await vectorStore.similaritySearch(
    state.search.query,
    2,
    filter
  );
  return { context: retrievedDocs };
};

const generateQA = async (state: typeof StateAnnotationQA.State) => {
  const docsContent = state.context.map((doc) => doc.pageContent).join("\n");
  const messages = await promptTemplate.invoke({
    question: state.question,
    context: docsContent,
  });
  const response = await llm.invoke(messages);
  return { answer: response.content };
};

const graphQA = new StateGraph(StateAnnotationQA)
  .addNode("analyzeQuery", analyzeQuery)
  .addNode("retrieveQA", retrieveQA)
  .addNode("generateQA", generateQA)
  .addEdge("__start__", "analyzeQuery")
  .addEdge("analyzeQuery", "retrieveQA")
  .addEdge("retrieveQA", "generateQA")
  .addEdge("generateQA", "__end__")
  .compile();
// Note: tslab only works inside a jupyter notebook. Don't worry about running this code yourself!
import * as tslab from "tslab";

const image = await graphQA.getGraph().drawMermaidPng();
const arrayBuffer = await image.arrayBuffer();

await tslab.display.png(new Uint8Array(arrayBuffer));

graph_img_rag_qa

我们可以通过专门询问文章结尾的上下文来测试我们的实现。请注意，模型在其答案中包含了不同的信息。

let inputsQA = {
  question: "What does the end of the post say about Task Decomposition?",
};

console.log(inputsQA);
console.log("\n====\n");
for await (const chunk of await graphQA.stream(inputsQA, {
  streamMode: "updates",
})) {
  console.log(chunk);
  console.log("\n====\n");
}
{
  question: 'What does the end of the post say about Task Decomposition?'
}

====

{
  analyzeQuery: { search: { query: 'Task Decomposition', section: 'end' } }
}

====

{ retrieveQA: { context: [ [Document], [Document] ] } }

====

{
  generateQA: {
    answer: 'The end of the post emphasizes the importance of task decomposition by outlining a structured approach to organizing code into separate files and functions. It highlights the need for clarity and compatibility among different components, ensuring that each part of the architecture is well-defined and functional. This methodical breakdown aids in maintaining best practices and enhances code readability and manageability.'
  }
}

====

在流式传输步骤和 LangSmith 跟踪 中，我们现在可以观察到馈送到检索步骤的结构化查询。

查询分析是一个丰富的问题，具有广泛的方法。有关更多示例，请参阅 操作指南。

后续步骤​

我们已经介绍了构建基于数据的基本问答应用的步骤

在教程的 第 2 部分 中，我们将扩展此处的实现，以适应对话式交互和多步骤检索过程。

延伸阅读

此页是否对您有帮助？


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