Skip to main content
Open In ColabOpen on GitHub

构建一个检索增强生成（RAG）应用：第二部分

在许多问答应用中，我们希望允许用户进行来回对话，这意味着应用需要某种“记忆”来存储过去的问题和答案，并且需要一些逻辑将这些内容整合到当前的思考中。

这是多部分教程的第二部分：

  • Part 1 介绍RAG并逐步讲解一个最小实现。
  • Part 2（本指南）扩展了实现，以适应对话式交互和多步骤检索过程。

在这里，我们专注于添加用于整合历史消息的逻辑。 这涉及到聊天历史的管理。

我们将介绍两种方法：

  1. Chains，其中我们最多执行一个检索步骤；
  2. Agents，在其中我们赋予LLM执行多个检索步骤的自主权。
note

这里介绍的方法利用了现代工具调用功能中的聊天模型。有关支持工具调用功能的模型列表，请参见此页面。

对于外部知识源，我们将使用与RAG教程第一部分中相同的LLM驱动的自主代理博客文章，作者是Lilian Weng。

设置​

组件​

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

pip install -qU 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 ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")
pip install -qU 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")
pip install -qU langchain-core
from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embeddings)

依赖项​

此外，我们将使用以下包：

%%capture --no-stderr
%pip install --upgrade --quiet langgraph langchain-community beautifulsoup4

LangSmith​

您使用LangChain构建的许多应用程序将包含多个步骤，涉及多次LLM调用。随着这些应用程序变得越来越复杂，能够检查您的链或代理内部究竟发生了什么变得至关重要。实现这一点的最佳方法是使用LangSmith。

请注意，LangSmith 不是必需的，但它很有帮助。如果您确实想使用 LangSmith，在您通过上述链接注册后，请确保设置您的环境变量以开始记录跟踪：

os.environ["LANGCHAIN_TRACING_V2"] = "true"
if not os.environ.get("LANGCHAIN_API_KEY"):
    os.environ["LANGCHAIN_API_KEY"] = getpass.getpass()

链​

让我们首先回顾一下我们在第一部分中构建的向量存储，它索引了Lilian Weng的一篇LLM驱动的自主代理博客文章。

import bs4
from langchain import hub
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
from typing_extensions import List, TypedDict

# 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)

在RAG教程的第一部分中，我们将用户输入、检索到的上下文和生成的答案表示为状态中的单独键。对话体验可以自然地使用一系列消息来表示。除了来自用户和助手的消息外，检索到的文档和其他工件可以通过工具消息整合到消息序列中。这促使我们使用一系列消息来表示RAG应用程序的状态。具体来说，我们将有

  1. 用户输入作为HumanMessage;
  2. 向量存储查询作为带有工具调用的AIMessage；
  3. 检索到的文档作为ToolMessage;
  4. 最终响应为 AIMessage。

这种状态模型非常通用，为了方便起见，LangGraph 提供了一个内置版本：

from langgraph.graph import MessagesState, StateGraph

graph_builder = StateGraph(MessagesState)
API Reference:StateGraph

利用工具调用与检索步骤交互还有另一个好处，即检索的查询是由我们的模型生成的。这在对话环境中尤为重要，因为用户查询可能需要基于聊天历史进行上下文化。例如，考虑以下对话：

人类：“什么是任务分解？”

AI: "任务分解涉及将复杂任务分解为更小、更简单的步骤，以便代理或模型更容易管理。"

人类：“常见的方法有哪些？”

在这种情况下，模型可以生成诸如"common approaches to task decomposition"的查询。工具调用自然地促进了这一点。正如在RAG教程的查询分析部分所述，这使得模型能够将用户查询重写为更有效的搜索查询。它还支持不涉及检索步骤的直接响应（例如，响应用户的通用问候）。

让我们将我们的检索步骤转化为一个工具：

from langchain_core.tools import tool


@tool(response_format="content_and_artifact")
def retrieve(query: str):
    """Retrieve information related to a query."""
    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join(
        (f"Source: {doc.metadata}\n" f"Content: {doc.page_content}")
        for doc in retrieved_docs
    )
    return serialized, retrieved_docs
API Reference:tool

查看本指南以获取有关创建工具的更多详细信息。

我们的图将由三个节点组成：

  1. 一个处理用户输入的节点，要么为检索器生成查询，要么直接响应；
  2. 用于执行检索步骤的检索工具节点；
  3. 使用检索到的上下文生成最终响应的节点。

我们在下面构建它们。请注意，我们利用了另一个预构建的LangGraph组件，ToolNode，它执行工具并将结果作为ToolMessage添加到状态中。

from langchain_core.messages import SystemMessage
from langgraph.prebuilt import ToolNode


# Step 1: Generate an AIMessage that may include a tool-call to be sent.
def query_or_respond(state: MessagesState):
    """Generate tool call for retrieval or respond."""
    llm_with_tools = llm.bind_tools([retrieve])
    response = llm_with_tools.invoke(state["messages"])
    # MessagesState appends messages to state instead of overwriting
    return {"messages": [response]}


# Step 2: Execute the retrieval.
tools = ToolNode([retrieve])


# Step 3: Generate a response using the retrieved content.
def generate(state: MessagesState):
    """Generate answer."""
    # Get generated ToolMessages
    recent_tool_messages = []
    for message in reversed(state["messages"]):
        if message.type == "tool":
            recent_tool_messages.append(message)
        else:
            break
    tool_messages = recent_tool_messages[::-1]

    # Format into prompt
    docs_content = "\n\n".join(doc.content for doc in tool_messages)
    system_message_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, say that you "
        "don't know. Use three sentences maximum and keep the "
        "answer concise."
        "\n\n"
        f"{docs_content}"
    )
    conversation_messages = [
        message
        for message in state["messages"]
        if message.type in ("human", "system")
        or (message.type == "ai" and not message.tool_calls)
    ]
    prompt = [SystemMessage(system_message_content)] + conversation_messages

    # Run
    response = llm.invoke(prompt)
    return {"messages": [response]}
API Reference:SystemMessage | ToolNode

最后，我们将应用程序编译成一个单一的graph对象。在这种情况下，我们只是将步骤连接成一个序列。我们还允许第一个query_or_respond步骤“短路”，如果它没有生成工具调用，则直接响应用户。这使得我们的应用程序能够支持对话体验——例如，响应可能不需要检索步骤的通用问候。

from langgraph.graph import END
from langgraph.prebuilt import ToolNode, tools_condition

graph_builder.add_node(query_or_respond)
graph_builder.add_node(tools)
graph_builder.add_node(generate)

graph_builder.set_entry_point("query_or_respond")
graph_builder.add_conditional_edges(
    "query_or_respond",
    tools_condition,
    {END: END, "tools": "tools"},
)
graph_builder.add_edge("tools", "generate")
graph_builder.add_edge("generate", END)

graph = graph_builder.compile()
API Reference:ToolNode | tools_condition
from IPython.display import Image, display

display(Image(graph.get_graph().draw_mermaid_png()))

让我们测试我们的应用程序。

请注意，它能够适当地响应不需要额外检索步骤的消息：

input_message = "Hello"

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

Hello
================================== Ai Message ==================================

Hello! How can I assist you today?

在执行搜索时，我们可以流式传输步骤以观察查询生成、检索和答案生成：

input_message = "What is Task Decomposition?"

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

What is Task Decomposition?
================================== Ai Message ==================================
Tool Calls:
  retrieve (call_dLjB3rkMoxZZxwUGXi33UBeh)
 Call ID: call_dLjB3rkMoxZZxwUGXi33UBeh
  Args:
    query: Task Decomposition
================================= Tool Message =================================
Name: retrieve

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Fig. 1. Overview of a LLM-powered autonomous agent system.
Component One: Planning#
A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.
Task Decomposition#
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.

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: 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.
================================== Ai Message ==================================

Task Decomposition is the process of breaking down a complicated task into smaller, manageable steps. It often involves techniques like Chain of Thought (CoT), which encourages models to think step by step, enhancing performance on complex tasks. This approach allows for a clearer understanding of the task and aids in structuring the problem-solving process.

查看LangSmith跟踪这里。

聊天历史的有状态管理​

note

本教程的这一部分之前使用了RunnableWithMessageHistory抽象。您可以在v0.2文档中访问该版本的文档。

截至LangChain的v0.3版本发布，我们建议LangChain用户利用LangGraph持久化将memory集成到新的LangChain应用中。

如果你的代码已经依赖于RunnableWithMessageHistory或BaseChatMessageHistory，你不需要做任何更改。我们不打算在不久的将来弃用此功能，因为它适用于简单的聊天应用程序，并且任何使用RunnableWithMessageHistory的代码将继续按预期工作。

请参阅如何迁移到LangGraph Memory了解更多详情。

在生产环境中，问答应用程序通常会将聊天记录持久化到数据库中，并能够适当地读取和更新它。

LangGraph 实现了一个内置的 持久层，使其非常适合支持多次对话的聊天应用。

为了管理多个对话轮次和线程，我们只需要在编译应用程序时指定一个检查点。因为图中的节点正在将消息附加到状态中，所以我们将在多次调用之间保留一致的聊天历史记录。

LangGraph 自带一个简单的内存检查点，我们在下面使用它。有关更多详细信息，包括如何使用不同的持久化后端（例如 SQLite 或 Postgres），请参阅其 文档。

有关如何管理消息历史的详细演练，请前往如何添加消息历史（内存）指南。

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
graph = graph_builder.compile(checkpointer=memory)

# Specify an ID for the thread
config = {"configurable": {"thread_id": "abc123"}}
API Reference:MemorySaver

我们现在可以像之前一样调用：

input_message = "What is Task Decomposition?"

for step in graph.stream(
    {"messages": [{"role": "user", "content": input_message}]},
    stream_mode="values",
    config=config,
):
    step["messages"][-1].pretty_print()
================================ Human Message =================================

What is Task Decomposition?
================================== Ai Message ==================================
Tool Calls:
  retrieve (call_JZb6GLD812bW2mQsJ5EJQDnN)
 Call ID: call_JZb6GLD812bW2mQsJ5EJQDnN
  Args:
    query: Task Decomposition
================================= Tool Message =================================
Name: retrieve

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Fig. 1. Overview of a LLM-powered autonomous agent system.
Component One: Planning#
A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.
Task Decomposition#
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.

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: 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.
================================== Ai Message ==================================

Task Decomposition is a technique used to break down complicated tasks into smaller, manageable steps. It involves using methods like Chain of Thought (CoT) prompting, which encourages the model to think step by step, enhancing performance on complex tasks. This process helps to clarify the model's reasoning and makes it easier to tackle difficult problems.
input_message = "Can you look up some common ways of doing it?"

for step in graph.stream(
    {"messages": [{"role": "user", "content": input_message}]},
    stream_mode="values",
    config=config,
):
    step["messages"][-1].pretty_print()
================================ Human Message =================================

Can you look up some common ways of doing it?
================================== Ai Message ==================================
Tool Calls:
  retrieve (call_kjRI4Y5cJOiB73yvd7dmb6ux)
 Call ID: call_kjRI4Y5cJOiB73yvd7dmb6ux
  Args:
    query: common methods of task decomposition
================================= Tool Message =================================
Name: retrieve

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: 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.

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Fig. 1. Overview of a LLM-powered autonomous agent system.
Component One: Planning#
A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.
Task Decomposition#
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.
================================== Ai Message ==================================

Common ways of performing Task Decomposition include: (1) using Large Language Models (LLMs) with simple prompts like "Steps for XYZ" or "What are the subgoals for achieving XYZ?", (2) employing task-specific instructions such as "Write a story outline" for specific tasks, and (3) incorporating human inputs to guide the decomposition process.

请注意，第二个问题中模型生成的查询包含了对话上下文。

这里的LangSmith跟踪特别有信息量，因为我们可以看到在每一步中，聊天模型能看到哪些消息。

代理​

Agents 利用LLMs的推理能力在执行过程中做出决策。使用代理可以让你在检索过程中减少额外的判断。尽管它们的行为比上述“链”更不可预测，但它们能够为查询执行多个检索步骤，或对单个搜索进行迭代。

下面我们组装一个最小的RAG代理。使用LangGraph的预构建的ReAct代理构造函数，我们可以在一行代码中完成。

tip

查看LangGraph的Agentic RAG教程以获取更高级的公式。

from langgraph.prebuilt import create_react_agent

agent_executor = create_react_agent(llm, [retrieve], checkpointer=memory)
API Reference:create_react_agent

让我们检查一下图表：

display(Image(agent_executor.get_graph().draw_mermaid_png()))

与我们之前的实现的关键区别在于，这里工具调用会循环回到原始的LLM调用，而不是一个结束运行的最终生成步骤。模型可以使用检索到的上下文来回答问题，或者生成另一个工具调用以获取更多信息。

让我们来测试一下。我们构建了一个通常需要一系列迭代检索步骤来回答的问题：

config = {"configurable": {"thread_id": "def234"}}

input_message = (
    "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_executor.stream(
    {"messages": [{"role": "user", "content": input_message}]},
    stream_mode="values",
    config=config,
):
    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 (call_Y3YaIzL71B83Cjqa8d2G0O8N)
 Call ID: call_Y3YaIzL71B83Cjqa8d2G0O8N
  Args:
    query: standard method for Task Decomposition
================================= Tool Message =================================
Name: retrieve

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: 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.

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Fig. 1. Overview of a LLM-powered autonomous agent system.
Component One: Planning#
A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.
Task Decomposition#
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.
================================== Ai Message ==================================
Tool Calls:
  retrieve (call_2JntP1x4XQMWwgVpYurE12ff)
 Call ID: call_2JntP1x4XQMWwgVpYurE12ff
  Args:
    query: common extensions of Task Decomposition methods
================================= Tool Message =================================
Name: retrieve

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: 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.

Source: {'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
Content: Fig. 1. Overview of a LLM-powered autonomous agent system.
Component One: Planning#
A complicated task usually involves many steps. An agent needs to know what they are and plan ahead.
Task Decomposition#
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.
================================== Ai Message ==================================

The standard method for task decomposition involves using techniques such as Chain of Thought (CoT), where a model is instructed to "think step by step" to break down complex tasks into smaller, more manageable components. This approach enhances model performance by allowing for more thorough reasoning and planning. Task decomposition can be accomplished through various means, including:

1. Simple prompting (e.g., asking for steps to achieve a goal).
2. Task-specific instructions (e.g., asking for a story outline).
3. Human inputs to guide the decomposition process.

### Common Extensions of Task Decomposition Methods:

1. **Tree of Thoughts**: This extension builds on CoT by not only decomposing the problem into thought steps but also generating multiple thoughts at each step, creating a tree structure. The search process can employ breadth-first search (BFS) or depth-first search (DFS), with each state evaluated by a classifier or through majority voting.

These extensions aim to enhance reasoning capabilities and improve the effectiveness of task decomposition in various contexts.

请注意代理：

  1. 生成一个查询以搜索任务分解的标准方法；
  2. 接收到答案后，生成第二个查询以搜索其常见扩展；
  3. 在接收到所有必要的上下文后，回答问题。

我们可以在LangSmith trace中看到完整的步骤序列，以及延迟和其他元数据。

下一步​

我们已经介绍了构建一个基本对话问答应用程序的步骤：

  • 我们使用链来构建一个可预测的应用程序，该应用程序为每个用户输入生成最多一个查询；
  • 我们使用代理构建了一个可以在一系列查询上进行迭代的应用程序。

要探索不同类型的检索器和检索策略，请访问retrievers部分的操作指南。

有关LangChain对话记忆抽象的详细演练，请访问如何添加消息历史（记忆）指南。

要了解更多关于代理的信息，请查看概念指南和LangGraph的代理架构页面。

这个页面有帮助吗？