精通代理性RAG：实施自我评估机制以增强信息检索的5个步骤

开发 Agentic RAG 的端到端教程

随着 LLM 的发展，模型已经能够理解大量数据并进行逻辑推理。伴随这些发展而来的最重要的进步之一是检索增强生成（RAG）系统。

LLM 接受过非常大的数据集的训练，但它们受到训练数据的限制。

假设你有一家公司。你有一些政策文件。为了让你的员工找到正确的答案，他们要么需要非常了解这些文件，要么需要在文件中搜索答案。你想用聊天机器人让这个系统更简单。随着 LLM 的发展，你可以使用它，但 LLM 并不了解你的数据。当你问它任何关于这些主题的问题时，它很可能会产生幻觉。你需要用微调来教你的数据，这是一个漫长而昂贵的过程。或者你可以使用 RAG 系统。多亏了 RAG 系统，LLM 可以在你的文档中搜索，并根据这些文档给出它的答案。

听起来很棒，对吧？当然，事情并没有那么简单。传统的 RAG 系统根据用户的查询检索相关的文档或信息片段，并通过将这些信息转发给 LLM 来提供答案。但是，这种方法可能不适用于复杂的信息需求或模棱两可的查询。这就是*“Agentic RAG”*概念发挥作用的地方。

Agentic RAG 是一个高级系统，它在传统 RAG 系统中增加了自主决策规划和自我评估能力，使信息检索过程更加智能和灵活。这些系统可以重新表述用户的查询，评估不同的信息来源，并衡量自身答案的准确性和质量。

在本文中，我们将以 Agentic RAG 系统为例，该系统可以根据特定文章为用户问题提供全面而准确的答案。在我们的示例中，我们使用 OpenAI 的 GPT-4 模型，它将能够理解给定的文章，在必要时执行网络搜索，重新表述查询并评估其自身的答案。我准备了这个例子，以便每个人都能了解 Agentic RAG 的一些信息和方法。它可以改进或添加不同的方法。

RAG 系统的基础知识

检索增强生成（RAG）是一种允许 LLM 访问训练数据以外的信息来源的方法。一个传统的 RAG 系统由三个基本组件组成：

• • 检索器： 一个组件，根据用户查询从数据库中检索相关的文档或信息片段。
• • 生成器： 通常是 LLM。它使用检索到的文档和用户查询生成答案。
• • 索引器： 预处理文档并将其存储在向量数据库中，以便高效访问。

传统 RAG 系统的局限性

正如我们一开始提到的，RAG 系统有很多优点和缺点。

1. 1. 它们按原样使用用户查询。它们无法进行改进，因此很难获得答案。
2. 2. 它们可能不适用于复杂的问题。
3. 3. 它们无法控制其产生的答案的质量或准确性。

Agent 的基础知识

Agent 是可以自己做出决策、执行这些决策并评估其正确性的系统。

• • 它们可以做出自主决策
• • 它们可以规划
• • 它们可以为不同的任务使用不同的工具，它们可以选择使用哪些工具
• • 它们逐步解决问题，并在必要时可以改变策略

Agentic RAG 的基础知识

Agentic RAG 使用 Agent 来消除传统 RAG 系统的局限性。

• • 更准确的答案： 通过多次验证和自我评估降低了产生幻觉的风险。
• • 全面的信息访问： 通过结合不同的来源和策略，可以访问更全面的信息。
• • 适应性： 根据用户查询的质量或复杂性调整方法。
• • 透明度： 可以清楚地说明思维过程和信息来源。

实践项目

在前面的章节中，我们讨论了 Agentic RAG 的基础知识。现在是时候将它们付诸实践了。

系统架构

• • LLM 引擎： 基于 GPT-4 的语言模型。
• • 文档访问链： RetrievalQA 链，从文章数据库中检索相关内容。
• • 网络搜索工具： 使用 Tavily API 执行网络搜索的组件。
• • 查询重构模块： 使模糊查询更具体的函数。
• • 自我评估机制： 评估生成的答案的质量的模块。
• • Agent 编排器： 编排不同工具使用的 LangChain Agent。
• • 记忆系统： 存储对话历史的 ConversationBufferMemory。

数据准备和索引

首先，让我们导入将要使用的所有库。

import fitz
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.tools import Tool
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, Tool, AgentType
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory
import os

os.environ["TAVILY_API_KEY"] = "your-api-key"

我们的 Agentic RAG 示例的基础是准确高效的数据准备和索引过程。此过程包括处理、分割和将我们的 PDF 文章转换为向量数据库。

首先，我们将使用 PyMuPDF 库从 PDF 格式的文档中提取内容。

def extract_text_from_pdf(pdf_path):
    doc = fitz.open(pdf_path)
    text = "\n".join([page.get_text() for page in doc])
    return text

text = extract_text_from_pdf("pdf_files/article_2.pdf")

此函数从给定 PDF 文件的所有页面中提取文本并将其合并。

PDF 中的文本可能非常长。完整地处理如此长的数据也效率低下。 因此，我们使用 LangChain 的 RecursiveCharacterTextSplitter 类将文本分割成更小、更易于管理的部分：

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
docs = text_splitter.create_documents([text])

这里：

• • chunk_size=500：它确保每段文本包含最多 500 个字符。
• • chunk_overlap=50：它通过确保连续部分之间有 50 个字符的重叠来防止由于分割句子或段落而丢失含义。

我们还使用 OpenAIEmbeddings() 类将文本转换为嵌入。

embeddings = OpenAIEmbeddings()

完成所有这些操作后，我们通过将每个文本片段转换为向量表示来创建 FAISS 向量数据库，以有效地查询片段文本：

vectorstore = FAISS.from_documents(docs, embeddings)
vectorstore.save_local("faiss_index")

FAISS（Facebook AI 相似性搜索）是一个旨在对高维向量执行高效相似性搜索的库。

应用程序运行时，我们按如下方式加载先前创建的 FAISS 索引：

vectorstore = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
retriever = vectorstore.as_retriever()

通过将加载的向量数据库转换为检索器对象，我们可以有效地找到与用户查询相关的文本片段。

此数据准备和索引过程构成了我们 Agentic RAG 系统的信息检索基础。

Agentic RAG

首先，我们初始化所选的 LLM 模型。在我们的例子中，它是 gpt-4。

llm = ChatOpenAI(model="gpt-4")

接下来，我们需要创建 RetrievalQA chain，以便能够从文章数据库中检索信息。

retrieval_qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True
)

该链接受用户查询，提取相关文档，并通过 LLM 生成响应。

我们还使用 TavilySearchResults 来搜索文章中未找到的信息。此工具与 Tavily API 集成，为每个查询返回两个最相关的结果。为此，您必须首先访问 Tavily 网站，创建一个帐户，并获取一个 API 密钥。否则，它将报错。

search = TavilySearchResults(max_results=2)

接下来，我们有一个自定义函数，我们将添加它。此函数将模糊或一般的输入改写得更具体。

def query_reformulation(query):
    response = llm.predict("Rewrite this query to be more specific: " + query)
    return response

此函数向 LLM 发送请求以优化查询。例如，它可以将一个通用查询（如“什么是人工智能？”）转换为一个更具体的查询（如“文章中描述的 AI 技术的主要特征和应用是什么？”）。

我们还有另一个函数。此函数将允许系统评估其生成的答案。

def self_evaluate(input_text):
    parts = input_text.split("|||")
    query = parts[0]
    response = parts[1]
    sources = parts[2] if len(parts) > 2 else ""

    evaluation_prompt = f"""
    Evaluate the following response to the query:

    QUERY: {query}
    RESPONSE: {response}
    SOURCES: {sources}

    Assess based on:
    1. Factual accuracy (Does it match the sources?)
    2. Completeness (Does it address all aspects of the query?)
    3. Relevance (Is the information relevant to the query?)
    4. Hallucination (Does it contain information not supported by sources?)

    Return a confidence score from 0-10 and explanation.
    """

    evaluation = llm.predict(evaluation_prompt)
    return evaluation

此函数评估答案的准确性、全面性、相关性和幻觉。评估包括 0–10 的置信度评分和解释。

现在我们已经定义了所有函数，我们可以将我们的工具收集在一起。

tools = [
    Tool(
        name="Article Retrieval",
        func=lambda q: retrieval_qa_chain({"query": q})["result"],
        description="Retrieve knowledge from the article database."
    ),
    Tool(
        name="Web search",
        func=search,
        description="If the requested information cannot be found in the documents, it specifies this and performs a web search."
    ),
    Tool(
        name="Query reformulation",
        func=query_reformulation,
        description="Reformulate a query to be more specific and targeted."
    )
]

我们的工具包括文章检索、网络搜索和查询重构。代理将决定在什么情况下使用哪个工具。

我们还从 LangChanin 库中添加了 ConversationBufferMemory 以保留与用户的聊天记录。

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

现在我们已经创建了所有组件，是时候启动代理了。

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    memory=memory
)

这里 Agent 类型 STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION 创建一个可以逐步推理并根据情况使用工具的代理。

现在是运行我们的代理的时候了。为此，我们编写了一个可用于自我评估的函数。

def get_evaluated_response(query):
    response = agent.run(query)

    try:
        result = retrieval_qa_chain({"query": query})
        sources = [doc.page_content for doc in result.get("source_documents", [])]
        sources_text = "\n".join(sources)
    except Exception as e:
        sources_text = "No sources available"

    evaluation = self_evaluate(f"{query}|||{response}|||{sources_text}")

    return {
        "query": query,
        "response": response,
        "evaluation": evaluation,
        "sources": sources_text
    }

此函数获取代理的响应并对其进行评估，并从那里返回响应。

我们可以使用下面的函数查看自我评估的响应和代理的响应。

def transparent_response(query):
    result = get_evaluated_response(query)

    return f"""
    Response: {result['response']}

    Confidence assessment: {result['evaluation']}
    """

现在让我们试试。

我提供的文章是关于多智能体系统的调查。

print(transparent_response("What is multi agent system?"))

当我们像上面那样运行我们的系统时，我们得到以下输出。我无法在这里显示所有输出，因为它们会太长，但代理理解它需要从文章中回答我们的问题，并为此使用了“文章检索”工具。然后他为我们创建了一个最终答案。自我评估评估了创建的结果，并给出了 9.75 分（满分 10 分）。

让我们尝试一个不在文章中的不同例子。

print(transparent_response("How is the current weather in Istanbul?"))

正如您所看到的，这一次代理理解它需要使用网络工具并从那里给我们带来了答案。但是我们的置信度得分很低，因为没有共享资源。这是需要优化的一个部分。

现在让我们问一些 LLM 已经知道的事情。

print(transparent_response("When was YouTube founded?"))

系统告诉我们它已经拥有此信息，并直接给出答案，而无需使用任何工具。我们的置信度得分非常高。

我们的最后一个例子是尝试查询重构。为此，我输入了一个非常模糊的输入。

print(transparent_response("bake cake"))

代理试图通过改写输入使其更有效，然后使用网络搜索工具。