跳到主要内容

概览

LLM 最强大的应用之一是复杂的问答 (Q&A) 聊天机器人。这些应用程序可以回答关于特定来源信息的问题。这些应用程序使用一种称为检索增强生成 (Retrieval Augmented Generation),或 RAG 的技术。 本教程将展示如何构建一个基于非结构化文本数据源的简单问答应用程序。我们将演示:
  1. 一个 RAG 代理,它使用简单的工具执行搜索。这是一个很好的通用实现。
  2. 一个两步 RAG ,每个查询只使用一次 LLM 调用。这对于简单查询来说是一种快速有效的方法。

概念

我们将涵盖以下概念
  • 索引:一个用于从源摄取数据并对其进行索引的管道。这通常在单独的进程中进行。
  • 检索与生成:实际的 RAG 过程,在运行时接收用户查询,从索引中检索相关数据,然后将其传递给模型。
一旦我们索引了数据,我们将使用一个 代理 作为我们的编排框架来实现检索和生成步骤。
本教程的索引部分将主要遵循 语义搜索教程如果您的数据已经可以搜索(即您有一个执行搜索的函数),或者您对该教程中的内容感到满意,请随意跳到 检索与生成 部分

预览

在本指南中,我们将构建一个应用程序来回答有关网站内容的问题。我们将使用的特定网站是 Lilian Weng 的 LLM Powered Autonomous Agents 博客文章,它允许我们提出关于文章内容的问题。 我们可以创建一个简单的索引管道和 RAG 链,在大约 40 行代码中完成此操作。完整代码片段请参见下文:
import bs4
from langchain.agents import AgentState, create_agent
from langchain_community.document_loaders import WebBaseLoader
from langchain.messages import MessageLikeRepresentation
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load and chunk contents of the blog
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs=dict(
        parse_only=bs4.SoupStrainer(
            class_=("post-content", "post-title", "post-header")
        )
    ),
)
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
all_splits = text_splitter.split_documents(docs)

# Index chunks
_ = vector_store.add_documents(documents=all_splits)

# Construct a tool for retrieving context
@tool(response_format="content_and_artifact")
def retrieve_context(query: str):
    """Retrieve information to help answer a query."""
    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join(
        (f"Source: {doc.metadata}\nContent: {doc.page_content}")
        for doc in retrieved_docs
    )
    return serialized, retrieved_docs

tools = [retrieve_context]
# If desired, specify custom instructions
prompt = (
    "You have access to a tool that retrieves context from a blog post. "
    "Use the tool to help answer user queries."
)
agent = create_agent(model, tools, system_prompt=prompt)
query = "What is task decomposition?"
for step in agent.stream(
    {"messages": [{"role": "user", "content": query}]},
    stream_mode="values",
):
    step["messages"][-1].pretty_print()
================================ Human Message =================================

What is task decomposition?
================================== Ai Message ==================================
Tool Calls:
  retrieve_context (call_xTkJr8njRY0geNz43ZvGkX0R)
 Call ID: call_xTkJr8njRY0geNz43ZvGkX0R
  Args:
    query: task decomposition
================================= Tool Message =================================
Name: retrieve_context

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Task decomposition can be done by...

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Component One: Planning...
================================== Ai Message ==================================

Task decomposition refers to...
查看 LangSmith 追踪

设置

安装

本教程需要这些 langchain 依赖项
pip install langchain langchain-text-splitters langchain-community bs4
有关更多详细信息,请参阅我们的 安装指南

LangSmith

您使用 LangChain 构建的许多应用程序将包含多个步骤和多次 LLM 调用。随着这些应用程序变得越来越复杂,能够检查您的链或代理内部到底发生了什么变得至关重要。最好的方法是使用 LangSmith 在您通过上面的链接注册后,请务必设置您的环境变量以开始记录追踪:
export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="..."
或者,在 Python 中设置它们
import getpass
import os

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = getpass.getpass()

组件

我们需要从 LangChain 的集成套件中选择三个组件。 选择一个聊天模型:
  • OpenAI
  • Anthropic
  • Azure
  • Google Gemini
  • AWS Bedrock
👉 阅读 OpenAI 聊天模型集成文档
pip install -U "langchain[openai]"
import os
from langchain.chat_models import init_chat_model

os.environ["OPENAI_API_KEY"] = "sk-..."

model = init_chat_model("gpt-4.1")
选择一个嵌入模型
  • OpenAI
  • Azure
  • Google Gemini
  • Google Vertex
  • AWS
  • HuggingFace
  • Ollama
  • Cohere
  • MistralAI
  • Nomic
  • NVIDIA
  • Voyage AI
  • IBM watsonx
  • Fake
pip install -U "langchain-openai"
import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
选择一个向量存储
  • 内存中
  • AstraDB
  • Chroma
  • FAISS
  • Milvus
  • MongoDB
  • PGVector
  • PGVectorStore
  • Pinecone
  • Qdrant
pip install -U "langchain-core"
from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embeddings)

1. 索引

本节是 语义搜索教程 中内容的缩写版本。如果您的数据已经索引并可供搜索(即您有一个执行搜索的函数),或者如果您熟悉 文档加载器嵌入向量存储,请随意跳到下一节 检索与生成
索引通常按以下方式工作
  1. 加载:首先我们需要加载我们的数据。这通过 文档加载器 完成。
  2. 拆分文本拆分器 将大型 Documents 拆分为更小的块。这对于索引数据和将其传递到模型都很有用,因为大型块更难搜索,并且不适合模型的有限上下文窗口。
  3. 存储:我们需要一个地方来存储和索引我们的拆分,以便以后可以对其进行搜索。这通常使用 VectorStoreEmbeddings 模型来完成。
index_diagram

加载文档

我们首先需要加载博客文章内容。我们可以为此使用 DocumentLoaders,它们是加载源数据并返回 Document 对象列表的对象。 在这种情况下,我们将使用 WebBaseLoader,它使用 urllib 从网页 URL 加载 HTML,并使用 BeautifulSoup 将其解析为文本。我们可以通过 bs_kwargs 将参数传递给 BeautifulSoup 解析器来定制 HTML -> 文本解析(参见 BeautifulSoup 文档)。在这种情况下,只有带有“post-content”、“post-title”或“post-header”类的 HTML 标签是相关的,所以我们将删除所有其他标签。
import bs4
from langchain_community.document_loaders import WebBaseLoader

# Only keep post title, headers, and content from the full HTML.
bs4_strainer = bs4.SoupStrainer(class_=("post-title", "post-header", "post-content"))
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs={"parse_only": bs4_strainer},
)
docs = loader.load()

assert len(docs) == 1
print(f"Total characters: {len(docs[0].page_content)}")
Total characters: 43131
print(docs[0].page_content[:500])
      LLM Powered Autonomous Agents

Date: June 23, 2023  |  Estimated Reading Time: 31 min  |  Author: Lilian Weng


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.
Agent System Overview#
In
深入了解 DocumentLoader:从源加载数据作为 Documents 列表的对象。
  • 集成:160+ 种集成可供选择。
  • BaseLoader:基础接口的 API 参考。

拆分文档

我们加载的文档有超过 4.2 万个字符,这对于许多模型的上下文窗口来说太长了。即使对于那些能够将完整文章放入其上下文窗口的模型,模型也可能难以在很长的输入中找到信息。 为了解决这个问题,我们将 Document 拆分为多个块,用于嵌入和向量存储。这应该有助于我们在运行时只检索博客文章中最相关的部分。 语义搜索教程 中一样,我们使用 RecursiveCharacterTextSplitter,它将使用常见的分隔符(如换行符)递归地拆分文档,直到每个块达到适当的大小。这是通用文本用例推荐的文本拆分器。
from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # chunk size (characters)
    chunk_overlap=200,  # chunk overlap (characters)
    add_start_index=True,  # track index in original document
)
all_splits = text_splitter.split_documents(docs)

print(f"Split blog post into {len(all_splits)} sub-documents.")
Split blog post into 66 sub-documents.
深入了解 TextSplitter:将 Document 对象列表拆分为更小的块以进行存储和检索的对象。

存储文档

现在我们需要索引我们的 66 个文本块,以便我们可以在运行时对其进行搜索。遵循 语义搜索教程,我们的方法是 嵌入 每个文档拆分的内容,并将这些嵌入插入到 向量存储 中。给定输入查询,我们就可以使用向量搜索来检索相关文档。 我们可以使用在教程开头选择的向量存储和嵌入模型,在一个命令中嵌入和存储所有文档拆分。
document_ids = vector_store.add_documents(documents=all_splits)

print(document_ids[:3])
['07c18af6-ad58-479a-bfb1-d508033f9c64', '9000bf8e-1993-446f-8d4d-f4e507ba4b8f', 'ba3b5d14-bed9-4f5f-88be-44c88aedc2e6']
深入了解 Embeddings:文本嵌入模型的包装器,用于将文本转换为嵌入。
  • 集成:30+ 种集成可供选择。
  • 接口:基础接口的 API 参考。
VectorStore:向量数据库的包装器,用于存储和查询嵌入。
  • 集成:40+ 种集成可供选择。
  • 接口:基础接口的 API 参考。
这完成了管道的 索引 部分。此时,我们有一个可查询的向量存储,其中包含我们博客文章的块化内容。给定用户问题,我们应该能够理想地返回回答该问题的博客文章片段。

2. 检索与生成

RAG 应用程序通常按以下方式工作
  1. 检索:给定用户输入,使用 Retriever 从存储中检索相关拆分。
  2. 生成模型 使用包含问题和检索到的数据的提示生成答案
retrieval_diagram 现在让我们编写实际的应用程序逻辑。我们希望创建一个简单的应用程序,它接受用户问题,搜索与该问题相关的文档,将检索到的文档和初始问题传递给模型,并返回答案。 我们将演示:
  1. 一个 RAG 代理,它使用简单的工具执行搜索。这是一个很好的通用实现。
  2. 一个两步 RAG ,每个查询只使用一次 LLM 调用。这对于简单查询来说是一种快速有效的方法。

RAG 代理

RAG 应用程序的一种形式是作为一个简单的 代理,带有一个检索信息的工具。我们可以通过实现一个包装我们向量存储的 工具 来组装一个最小的 RAG 代理。
from langchain.tools import tool

@tool(response_format="content_and_artifact")
def retrieve_context(query: str):
    """Retrieve information to help answer a query."""
    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join(
        (f"Source: {doc.metadata}\nContent: {doc.page_content}")
        for doc in retrieved_docs
    )
    return serialized, retrieved_docs
在这里,我们使用 工具装饰器 来配置工具,将原始文档作为 工件 附加到每个 ToolMessage。这将使我们能够访问应用程序中的文档元数据,与发送给模型的字符串化表示分开。
检索工具不限于单个字符串 query 参数,如上例所示。您可以通过添加参数(例如,类别)来强制 LLM 指定额外的搜索参数
from typing import Literal

def retrieve_context(query: str, section: Literal["beginning", "middle", "end"]):
给定我们的工具,我们可以构建代理
from langchain.agents import create_agent


tools = [retrieve_context]
# If desired, specify custom instructions
prompt = (
    "You have access to a tool that retrieves context from a blog post. "
    "Use the tool to help answer user queries."
)
agent = create_agent(model, tools, system_prompt=prompt)
我们来测试一下。我们构建了一个通常需要迭代检索步骤才能回答的问题
query = (
    "What is the standard method for Task Decomposition?\n\n"
    "Once you get the answer, look up common extensions of that method."
)

for event in agent.stream(
    {"messages": [{"role": "user", "content": query}]},
    stream_mode="values",
):
    event["messages"][-1].pretty_print()
================================ Human Message =================================

What is the standard method for Task Decomposition?

Once you get the answer, look up common extensions of that method.
================================== Ai Message ==================================
Tool Calls:
  retrieve_context (call_d6AVxICMPQYwAKj9lgH4E337)
 Call ID: call_d6AVxICMPQYwAKj9lgH4E337
  Args:
    query: standard method for Task Decomposition
================================= Tool Message =================================
Name: retrieve_context

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Task decomposition can be done...

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Component One: Planning...
================================== Ai Message ==================================
Tool Calls:
  retrieve_context (call_0dbMOw7266jvETbXWn4JqWpR)
 Call ID: call_0dbMOw7266jvETbXWn4JqWpR
  Args:
    query: common extensions of the standard method for Task Decomposition
================================= Tool Message =================================
Name: retrieve_context

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Task decomposition can be done...

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Component One: Planning...
================================== Ai Message ==================================

The standard method for Task Decomposition often used is the Chain of Thought (CoT)...
请注意,代理
  1. 生成一个查询以搜索任务分解的标准方法;
  2. 收到答案后,生成第二个查询以搜索其常见的扩展;
  3. 收到所有必要的上下文后,回答问题。
我们可以在 LangSmith 追踪 中看到完整的步骤序列,以及延迟和其他元数据。
您可以使用 LangGraph 框架直接添加更深层次的控制和自定义——例如,您可以添加步骤来评估文档相关性并重写搜索查询。请查看 LangGraph 的 Agentic RAG 教程 以获取更高级的公式。

RAG 链

在上述 代理 RAG 公式中,我们允许 LLM 酌情生成 工具调用 来帮助回答用户查询。这是一个很好的通用解决方案,但也存在一些权衡:
✅ 优点⚠️ 缺点
仅在需要时搜索——LLM 可以处理问候语、后续问题和简单查询,而不会触发不必要的搜索。两次推理调用——执行搜索时,需要一次调用来生成查询,另一次调用来生成最终响应。
上下文搜索查询——通过将搜索视为具有 query 输入的工具,LLM 会创建包含对话上下文的自己的查询。控制减少——LLM 可能会在实际需要时跳过搜索,或者在不必要时发出额外搜索。
允许多次搜索——LLM 可以执行多次搜索以支持单个用户查询。
另一种常见方法是两步链,我们总是运行一次搜索(可能使用原始用户查询)并将结果作为单个 LLM 查询的上下文。这导致每个查询只进行一次推理调用,以牺牲灵活性为代价降低了延迟。 在这种方法中,我们不再循环调用模型,而是进行一次通过。 我们可以通过从代理中删除工具并将检索步骤合并到自定义提示中来实施此链:
from langchain.agents.middleware import dynamic_prompt, ModelRequest

@dynamic_prompt
def prompt_with_context(request: ModelRequest) -> str:
    """Inject context into state messages."""
    last_query = request.state["messages"][-1].text
    retrieved_docs = vector_store.similarity_search(last_query)

    docs_content = "\n\n".join(doc.page_content for doc in retrieved_docs)

    system_message = (
        "You are a helpful assistant. Use the following context in your response:"
        f"\n\n{docs_content}"
    )

    return system_message


agent = create_agent(model, tools=[], middleware=[prompt_with_context])
我们来试试看
query = "What is task decomposition?"
for step in agent.stream(
    {"messages": [{"role": "user", "content": query}]},
    stream_mode="values",
):
    step["messages"][-1].pretty_print()
================================ Human Message =================================

What is task decomposition?
================================== Ai Message ==================================

Task decomposition is...
LangSmith 追踪 中,我们可以看到检索到的上下文被并入模型提示。 这是一种快速有效的方法,适用于受限设置中的简单查询,我们通常确实希望通过语义搜索运行用户查询以获取额外上下文。
上述 RAG 链 将检索到的上下文合并到该运行的单个系统消息中。代理式 RAG 形式一样,我们有时希望在应用程序状态中包含原始源文档,以便访问文档元数据。我们可以通过以下方式实现两步链:
  1. 向状态添加一个键以存储检索到的文档
  2. 通过 模型前置钩子 添加新节点来填充该键(并注入上下文)。
from typing import Any
from langchain_core.documents import Document
from langchain.agents.middleware import AgentMiddleware, AgentState


class State(AgentState):
    context: list[Document]


class RetrieveDocumentsMiddleware(AgentMiddleware[State]):
    state_schema = State

    def before_model(self, state: AgentState) -> dict[str, Any] | None:
        last_message = state["messages"][-1]
        retrieved_docs = vector_store.similarity_search(last_message.text)

        docs_content = "\n\n".join(doc.page_content for doc in retrieved_docs)

        augmented_message_content = (
            f"{last_message.text}\n\n"
            "Use the following context to answer the query:\n"
            f"{docs_content}"
        )
        return {
            "messages": [last_message.model_copy(update={"content": augmented_message_content})],
            "context": retrieved_docs,
        }


agent = create_agent(
    llm,
    tools=[],
    middleware=[RetrieveDocumentsMiddleware()],
)

后续步骤

现在我们已经通过 create_agent 实现了一个简单的 RAG 应用程序,我们可以轻松地添加新功能并深入探索
以编程方式连接这些文档到 Claude、VSCode 等,通过 MCP 获取实时答案。
© . This site is unofficial and not affiliated with LangChain, Inc.