看到一篇写的非常好的关于RAG痛点及分析的文章，《12 RAG Pain Points and Proposed Solutions-Solving the core challenges of Retrieval-Augmented Generation》

原文链接：https://archive.is/bNbZo

为了方便大家阅读，我把它翻译成了中文，以下为译文。

受到 Barnett 等人的论文《设计检索增强生成系统时的七个故障点》的启发，让我们在本文中探讨该论文中提到的七个故障点以及开发 RAG 管道时的另外五个常见痛点。更重要的是，我们将深入研究这些 RAG 痛点的解决方案，以便我们能够更好地解决日常 RAG 开发中的这些痛点。

我用“痛点”而不是“失败点”主要是因为这些点都有相应的建议解决方案。让我们尝试在 RAG 管道出现故障之前修复它们。

首先，我们来看看上述论文中提到的七个痛点；见下图。然后我们将添加五个额外的痛点及其建议的解决方案。

痛点一：内容缺失

当实际答案不在知识库中时，RAG 系统会提供看似合理但不正确的答案，而不是说它不知道。用户收到误导性信息，导致沮丧。

我们提出了两种解决方案：

清理您的数据

垃圾进垃圾出。如果您的源数据质量很差，例如包含相互冲突的信息，那么无论您将 RAG 管道构建得多么好，它都无法发挥从您提供的垃圾中输出黄金的魔力。这个提出的解决方案不仅针对这个痛点，而且针对本文列出的所有痛点。干净的数据是任何运行良好的 RAG 管道的先决条件。

更好的提示

当系统由于知识库中缺乏信息而可能提供看似合理但不正确的答案时，更好的提示可以提供显着帮助。通过使用诸如“如果您不确定答案，请告诉我您不知道”之类的提示来指导系统，您可以鼓励模型承认其局限性并更透明地传达不确定性。无法保证 100% 的准确性，但精心设计提示是清理数据后可以做出的最佳努力之一。

痛点二：错过排名靠前的文档

重要文档可能不会出现在系统检索组件返回的顶部结果中。正确答案被忽略，导致系统无法提供准确的响应。该论文暗示，“问题的答案在文档中，但排名不够高，无法返回给用户”。

我想到了两个建议的解决方案：

chunk_size 和的超参数调整similarity_top_k和chunk_size都是similarity_top_k用于管理 RAG 模型中数据检索过程的效率和有效性的参数。调整这些参数可以影响计算效率和检索信息质量之间的权衡。

chunk_size我们在上similarity_top_k一篇文章《使用 LlamaIndex 自动化超参数调整》中探讨了两者的超参数调整细节。请参阅下面的示例代码片段。

param_tuner = ParamTuner( 
    param_fn=objective_function_semantic_similarity, 
    param_dict=param_dict, 
    fixed_pa​​ram_dict=fixed_pa​​ram_dict, 
    show_progress=True, 
)
results = param_tuner.tune()

该函数objective_function_semantic_similarity定义如下，包含param_dict参数 、chunk_size和top_k，以及它们相应的建议值：

# contains the parameters that need to be tuned
param_dict = {"chunk_size": [256, 512, 1024], "top_k": [1, 2, 5]}

# contains parameters remaining fixed across all runs of the tuning process
fixed_param_dict = {
    "docs": documents,
    "eval_qs": eval_qs,
    "ref_response_strs": ref_response_strs,
}

def objective_function_semantic_similarity(params_dict):
    chunk_size = params_dict["chunk_size"]
    docs = params_dict["docs"]
    top_k = params_dict["top_k"]
    eval_qs = params_dict["eval_qs"]
    ref_response_strs = params_dict["ref_response_strs"]

    # build index
    index = _build_index(chunk_size, docs)

    # query engine
    query_engine = index.as_query_engine(similarity_top_k=top_k)

    # get predicted responses
    pred_response_objs = get_responses(
        eval_qs, query_engine, show_progress=True
    )

    # run evaluator
    eval_batch_runner = _get_eval_batch_runner_semantic_similarity()
    eval_results = eval_batch_runner.evaluate_responses(
        eval_qs, responses=pred_response_objs, reference=ref_response_strs
    )

    # get semantic similarity metric
    mean_score = np.array(
        [r.score for r in eval_results["semantic_similarity"]]
    ).mean()

    return RunResult(score=mean_score, params=params_dict)

有关更多详细信息，请参阅 LlamaIndex 关于RAG 超参数优化的完整笔记本。

重新排名

在将检索结果发送到LLM之前对其进行重新排序可以显着提高 RAG 性能。这个 LlamaIndex笔记本展示了以下之间的区别：

• 直接检索前 2 个节点而无需重新排序，导致检索不准确。
• 通过检索前 10 个节点并使用CohereRerank重新排序并返回前 2 个节点来精确检索。

import os
from llama_index.postprocessor.cohere_rerank import CohereRerank

api_key = os.environ["COHERE_API_KEY"]
cohere_rerank = CohereRerank(api_key=api_key, top_n=2) # return top 2 nodes from reranker

query_engine = index.as_query_engine(
    similarity_top_k=10, # we can set a high top_k here to ensure maximum relevant retrieval
    node_postprocessors=[cohere_rerank], # pass the reranker to node_postprocessors
)

response = query_engine.query(
    "What did Sam Altman do in this essay?",
)

此外，您可以使用各种嵌入和重新排序器来评估和增强检索器性能，如Ravi Theja的Boosting RAG: Picking the Best Embedding & Reranker models中详细介绍的。

此外，您可以微调自定义重排序器以获得更好的检索性能，详细的实现记录在Ravi Theja 的Improving Retrieval Performance by Fine-tuning Cohere Reranker with LlamaIndex中。

痛点三：不切实际——整合策略的局限性

该论文定义了这一点：“带有答案的文档是从数据库中检索的，但没有进入生成答案的上下文。当从数据库返回许多文档并进行合并过程以检索答案时，就会发生这种情况”。

除了按照上一节所述添加重新排序器并微调重新排序器之外，我们还可以探索以下建议的解决方案：

调整检索策略

LlamaIndex 提供了一系列从基础到高级的检索策略，帮助我们在 RAG 管道中实现准确的检索。查看检索器模块指南，获取所有检索策略的完整列表，分为不同的类别。

• 每个索引的基本检索
• 高级检索和搜索
• 自动检索
• 知识图检索器
• 组合/分层检索器和更多！

微调嵌入

如果您使用开源嵌入模型，微调嵌入模型是实现更准确检索的好方法。LlamaIndex 有一个关于微调开源嵌入模型的分步指南，证明微调嵌入模型可以在整个评估指标中一致地改进指标。

请参阅下面的示例代码片段，了解如何创建微调引擎、运行微调并获取微调模型：

finetune_engine = SentenceTransformersFinetuneEngine(
    train_dataset,
    model_id="BAAI/bge-small-en",
    model_output_path="test_model",
    val_dataset=val_dataset,
)

finetune_engine.finetune()

embed_model = finetune_engine.get_finetuned_model()

痛点四：未提取

系统很难从提供的上下文中提取正确的答案，尤其是在信息过载的情况下。关键细节被遗漏，从而影响了响应的质量。该论文暗示：“当上下文中有太多噪音或相互矛盾的信息时，就会发生这种情况”。

让我们探讨三个建议的解决方案：

清理您的数据

这个痛点是不良数据的另一个典型受害者。我们怎么强调干净数据的重要性都不过分！在指责 RAG 管道之前，请先花时间清理数据。

Prompt压缩

LongLLMLingua 研究项目/论文中介绍了长上下文环境中的即时压缩。通过与 LlamaIndex 的集成，我们现在可以将 LongLLMLingua 实现为节点后处理器，它将在检索步骤之后压缩上下文，然后将其输入 LLM。

请参阅下面的示例代码片段，我们在其中进行设置LongLLMLinguaPostprocessor，它使用longllmlingua包来运行提示压缩。

有关更多详细信息，请查看LongLLMLingua 上的完整笔记本。

from llama_index.query_engine import RetrieverQueryEngine
from llama_index.response_synthesizers import CompactAndRefine
from llama_index.postprocessor import LongLLMLinguaPostprocessor
from llama_index.schema import QueryBundle

node_postprocessor = LongLLMLinguaPostprocessor(
    instruction_str="Given the context, please answer the final question",
    target_token=300,
    rank_method="longllmlingua",
    additional_compress_kwargs={
        "condition_compare": True,
        "condition_in_question": "after",
        "context_budget": "+100",
        "reorder_context": "sort",  # enable document reorder
    },
)

retrieved_nodes = retriever.retrieve(query_str)
synthesizer = CompactAndRefine()

# outline steps in RetrieverQueryEngine for clarity:
# postprocess (compress), synthesize
new_retrieved_nodes = node_postprocessor.postprocess_nodes(
    retrieved_nodes, query_bundle=QueryBundle(query_str=query_str)
)

print("\n\n".join([n.get_content() for n in new_retrieved_nodes]))

response = synthesizer.synthesize(query_str, new_retrieved_nodes)

长上下文重排序(LongContextReorder)

一项研究发现，当关键数据位于输入上下文的开头或结尾时，通常会出现最佳性能。LongContextReorder旨在通过重新排序检索到的节点来解决“迷失在中间”的问题，这在需要大的 top-k 的情况下很有帮助。

请参阅下面的示例代码片段，了解如何在查询引擎构建期间定义LongContextReorder为您的node_postprocessor。有关更多详细信息，请参阅 LlamaIndex上的完整笔记本LongContextReorder。

from llama_index.postprocessor import LongContextReorder

reorder = LongContextReorder()

reorder_engine = index.as_query_engine(
    node_postprocessors=[reorder], similarity_top_k=5
)

reorder_response = reorder_engine.query("Did the author meet Sam Altman?")

痛点五：格式错误

当LLM忽略以特定格式（如表格或列表）提取信息的指令时，我们提出了四种解决方案可供探索：

更好的提示

您可以采用多种策略来改进提示并纠正此问题：

• 澄清说明。
• 简化请求并使用关键字。
• 举例说明。
• 迭代提示并询问后续问题。

输出解析(Output parsing)

可以通过以下方式使用输出解析来帮助确保所需的输出：

• 为任何提示/查询提供格式说明
• 为 LLM 输出提供“解析”
• 
  

LlamaIndex 支持与其他框架提供的输出解析模块集成，例如Guardrails和LangChain。

请参阅下面的 LangChain 输出解析模块的示例代码片段，您可以在 LlamaIndex 中使用它。有关更多详细信息，请查看关于输出解析模块的 LlamaIndex 文档。

from llama_index import VectorStoreIndex, SimpleDirectoryReader
from llama_index.output_parsers import LangchainOutputParser
from llama_index.llms import OpenAI
from langchain.output_parsers import StructuredOutputParser, ResponseSchema

# load documents, build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex.from_documents(documents)

# define output schema
response_schemas = [
    ResponseSchema(
        name="Education",
        description="Describes the author's educational experience/background.",
    ),
    ResponseSchema(
        name="Work",
        description="Describes the author's work experience/background.",
    ),
]

# define output parser
lc_output_parser = StructuredOutputParser.from_response_schemas(
    response_schemas
)
output_parser = LangchainOutputParser(lc_output_parser)

# Attach output parser to LLM
llm = OpenAI(output_parser=output_parser)

# obtain a structured response
from llama_index import ServiceContext

ctx = ServiceContext.from_defaults(llm=llm)

query_engine = index.as_query_engine(service_context=ctx)
response = query_engine.query(
    "What are a few things the author did growing up?",
)
print(str(response))

Pydantic 程序

Pydantic 程序充当通用框架，将输入字符串转换为结构化 Pydantic 对象。LlamaIndex 提供了几种类型的 Pydantic 程序：

• LLM 文本完成 Pydantic 程序：这些程序利用文本完成 API 与输出解析相结合，处理输入文本并将其转换为用户定义的结构化对象。
• LLM 函数调用 Pydantic 程序：这些程序利用 LLM 函数调用 API，获取输入文本并将其转换为用户指定的结构化对象。
• 预打包的 Pydantic 程序：这些程序旨在将输入文本转换为预定义的结构化对象。

请参阅下面OpenAI pydantic 程序的示例代码片段。有关更多详细信息，请查看 LlamaIndex 关于pydantic 程序的文档，以获取不同 pydantic 程序的笔记本/指南的链接。

from pydantic import BaseModel
from typing import List

from llama_index.program import OpenAIPydanticProgram

# Define output schema (without docstring)
class Song(BaseModel):
    title: str
    length_seconds: int


class Album(BaseModel):
    name: str
    artist: str
    songs: List[Song]

# Define openai pydantic program
prompt_template_str = """\
Generate an example album, with an artist and a list of songs. \
Using the movie {movie_name} as inspiration.\
"""
program = OpenAIPydanticProgram.from_defaults(
    output_cls=Album, prompt_template_str=prompt_template_str, verbose=True
)

# Run program to get structured output
output = program(
    movie_name="The Shining", description="Data model for an album."

OpenAI JSON模式

OpenAI JSON 模式使我们能够设置response_format为{ "type": "json_object" }启用 JSON 模式的响应。启用 JSON 模式时，模型仅限于生成解析为有效 JSON 对象的字符串。虽然 JSON 模式强制执行输出格式，但它无助于针对指定模式进行验证。有关更多详细信息，请查看 LlamaIndex 关于OpenAI JSON 模式与数据提取的函数调用的文档。

痛点六：特异性不正确

答复可能缺乏必要的细节或具体性，通常需要后续询问才能澄清。答案可能过于模糊或笼统，无法有效满足用户的需求。

我们求助于高级检索策略来寻求解决方案。

高级检索策略

当答案未达到您期望的正确粒度时，您可以改进检索策略。一些可能有助于解决这一痛点的主要高级检索策略包括：

• 从小到大检索
• 句子窗口检索
• 递归检索

请参阅我的上一篇文章“使用高级检索 LlamaPack 启动您的 RAG 管道”和“使用 Lighthouz AI 进行基准测试”，了解有关七个高级检索 LlamaPack 的更多详细信息。

痛点七：不完整（Incomplete）

片面的回答并没有错，而是错误的。然而，尽管信息在上下文中存在并且可以访问，但它们并没有提供所有细节。例如，如果有人问：“文件A、B、C主要讨论了哪些方面？” 单独询问每份文件可能会更有效，以确保得到全面的答复。

查询转换

比较问题在朴素的 RAG 方法中尤其表现不佳。提高 RAG 推理能力的一个好方法是添加查询理解层 ——在实际查询向量存储之前添加查询转换。以下是四种不同的查询转换：

• 路由：保留初始查询，同时查明其所属的适当工具子集。然后，将这些工具指定为合适的选项。
• 查询重写：维护选定的工具，但以多种方式重新编写查询，以将其应用于同一组工具。
• 子问题：将查询分解为几个较小的问题，每个问题针对由其元数据确定的不同工具。
• ReAct Agent 工具选择：根据原始查询，确定要使用的工具并制定要在该工具上运行的特定查询。

请参阅下面的示例代码片段，了解如何使用 HyDE（假设文档嵌入），这是一种查询重写技术。给定一个自然语言查询，首先生成一个假设的文档/答案。然后，该假设文档用于嵌入查找而不是原始查询。

# load documents, build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex(documents)
# run query with HyDE query transform
query_str = "what did paul graham do after going to RISD"
hyde = HyDEQueryTransform(include_original=True)
query_engine = index.as_query_engine()
query_engine = TransformQueryEngine(query_engine, query_transform=hyde)
response = query_engine.query(query_str)
print(response)

查看 LlamaIndex 的查询转换手册了解所有详细信息。

另外，请查看Iulia Brezeanu撰写的这篇精彩文章Advanced Query Transformations to Improve RAG，了解有关查询转换技术的详细信息。

以上痛点均来自论文。现在，让我们探讨 RAG 开发中常见的五个额外痛点及其提出的解决方案。

痛点 八：数据摄取可扩展性(Data Ingestion Scalability)

RAG 管道中的数据摄取可扩展性问题是指当系统难以有效管理和处理大量数据时出现的挑战，从而导致性能瓶颈和潜在的系统故障。此类数据摄取可扩展性问题可能会导致摄取时间延长、系统过载、数据质量问题和可用性有限。

并行化摄取管道(Parallelizing ingestion pipeline)

LlamaIndex 提供摄取管道并行处理，该功能可将 LlamaIndex 中的文档处理速度提高 15 倍。请参阅下面的示例代码片段，了解如何创建IngestionPipeline并指定num_workers来调用并行处理。查看 LlamaIndex 的完整笔记本了解更多详细信息。

# load data
documents = SimpleDirectoryReader(input_dir="./data/source_files").load_data()

# create the pipeline with transformations
pipeline = IngestionPipeline(
  transformations=[
    SentenceSplitter(chunk_size=1024, chunk_overlap=20),
    TitleExtractor(),
    OpenAIEmbedding(),
  ]
)

# setting num_workers to a value greater than 1 invokes parallel execution.
nodes = pipeline.run(documents=documents, num_workers=4)

痛点九：结构化数据QA

准确解释用户查询以检索相关结构化数据可能很困难，尤其是复杂或不明确的查询、不灵活的文本到 SQL 以及当前LLM在有效处理这些任务方面的局限性。

LlamaIndex 提供了两种解决方案。

Chain-of-table Pack

ChainOfTablePack是一个基于Wang 等人创新的“chain-of-table”论文的 LlamaPack。“表链”将思想链的概念与表转换和表示相结合。它使用一组受限的操作逐步转换表格，并在每个阶段将修改后的表格呈现给LLM。这种方法的一个显着优点是它能够通过有条不紊地对数据进行切片和切分，直到确定适当的子集，从而解决涉及包含多条信息的复杂表格单元的问题，从而增强表格 QA 的有效性。

查看 LlamaIndex 的完整笔记本，了解有关如何使用ChainOfTablePack查询结构化数据的详细信息。

混合自洽包

LLM可以通过两种主要方式对表格数据进行推理：

• 通过直接提示进行文本推理
• 通过程序综合进行符号推理（例如，Python、SQL 等）

基于 Liu 等人的论文Rethinking Tabular Data Understanding with Large Language Models，LlamaIndex 开发了MixSelfConsistencyQueryEngine，它通过自我一致性机制（即多数投票）聚合文本和符号推理的结果，并实现 SoTA 性能。请参阅下面的示例代码片段。查看 LlamaIndex 的完整笔记本了解更多详细信息。

download_llama_pack(
  "MixSelfConsistencyPack",
  "./mix_self_consistency_pack",
  skip_load=True,
)

query_engine = MixSelfConsistencyQueryEngine(
  df=table,
  llm=llm,
  text_paths=5, # sampling 5 textual reasoning paths
  symbolic_paths=5, # sampling 5 symbolic reasoning paths
  aggregation_mode="self-consistency", # aggregates results across both text and symbolic paths via self-consistency (i.e. majority voting)
  verbose=True,
)

response = await query_engine.aquery(example["utterance"])

痛点十：复杂PDF中的数据提取

您可能需要从复杂的 PDF 文档（例如嵌入的表格）中提取数据以进行问答。单纯的检索不会从这些嵌入的表中获取数据。您需要一种更好的方法来检索如此复杂的 PDF 数据。

嵌入表检索

LlamaIndex 中提供了一个解决方案EmbeddedTablesUnstructuredRetrieverPack，即 LlamaPack，它使用Unstructural.io从 HTML 文档中解析出嵌入的表，构建节点图，然后使用递归检索来根据用户问题索引/检索表。

请注意，此包采用 HTML 文档作为输入。如果您有 PDF 文档，则可以使用pdf2htmlEX将 PDF 转换为 HTML，而不会丢失文本或格式。请参阅下面的示例代码片段，了解如何下载、初始化和运行

EmbeddedTablesUnstructuredRetrieverPack.

# download and install dependencies
EmbeddedTablesUnstructuredRetrieverPack = download_llama_pack(
  "EmbeddedTablesUnstructuredRetrieverPack", "./embedded_tables_unstructured_pack",
)

# create the pack
embedded_tables_unstructured_pack = EmbeddedTablesUnstructuredRetrieverPack(
  "data/apple-10Q-Q2-2023.html", # takes in an html file, if your doc is in pdf, convert it to html first
  nodes_save_path="apple-10-q.pkl"
)

# run the pack 
response = embedded_tables_unstructured_pack.run("What's the total operating expenses?").response
display(Markdown(f"{response}"))

痛点 十一：后备模型（Fallback Model(s)）

在与LLM合作时，您可能想知道如果您的模型遇到问题（例如 OpenAI 模型的速率限制错误）怎么办。您需要一个后备模型作为备份，以防主模型出现故障。

两个建议的解决方案：

Neutrino router

Neutrino路由器是您可以将查询路由到的 LLM 的集合。它使用预测器模型智能地将查询路由到最适合的LLM以获得提示，最大限度地提高性能，同时优化成本和延迟。Neutrino 目前支持十几种模型。如果您希望将新型号添加到其支持的型号列表中，请联系他们的支持人员。

您可以创建一个路由器来在 Neutrino 仪表板中手动选择您喜欢的模型，或使用“默认”路由器，其中包括所有支持的模型。

NeutrinoLlamaIndex 通过模块中的类集成了 Neutrino 支持llms。请参阅下面的代码片段。在Neutrino AI 页面上查看更多详细信息。

from llama_index.llms import Neutrino
from llama_index.llms import ChatMessage

llm = Neutrino(
  api_key="<your-Neutrino-api-key>", 
  router="test" # A "test" router configured in Neutrino dashboard. You treat a router as a LLM. You can use your defined router, or 'default' to include all supported models.
)

response = llm.complete("What is large language model?")
print(f"Optimal model: {response.raw['model']}")

OpenRouter

OpenRouter是访问任何 LLM 的统一 API。它可以找到所有型号的最低价格，并在主要主机出现故障时提供后备方案。根据OpenRouter的文档，使用OpenRouter的主要好处包括：

从竞逐中获益。OpenRouter 查找数十家提供商中每种型号的最低价格。您还可以让用户通过OAuth PKCE为自己的模型付费。

标准化API。在模型或提供商之间切换时无需更改代码。

最好的模型将被使用得最多。根据模型的使用频率和使用目的来比较模型。

OpenRouterLlamaIndex 通过模块中的类集成了 OpenRouter 支持llms。请参阅下面的代码片段。在OpenRouter 页面上查看更多详细信息。

from llama_index.llms import OpenRouter
from llama_index.llms import ChatMessage

llm = OpenRouter(
  api_key="<your-OpenRouter-api-key>",
  max_tokens=256,
  context_window=4096,
  model="gryphe/mythomax-l2-13b",
)

message = ChatMessage(role="user", content="Tell me a joke")
resp = llm.chat([message])
print(resp)

痛点十二：LLM安全性

如何对抗提示注入、处理不安全的输出以及防止敏感信息泄露，都是每个人工智能架构师和工程师需要回答的紧迫问题。

Llama Guard

基于 7-B Llama 2，Llama Guard 旨在通过检查输入（通过提示分类）和输出（通过响应分类）对LLM的内容进行分类。Llama Guard 的功能与 LLM 类似，它会生成文本结果来确定特定提示或响应是否被视为安全或不安全。此外，如果它根据某些策略将内容识别为不安全，它将枚举该内容违反的特定子类别。

LlamaIndex 提供LlamaGuardModeratorPack，使开发人员能够在下载并初始化包后通过单行调用 Llama Guard 来调节 LLM 输入/输出。

# download and install dependencies
LlamaGuardModeratorPack = download_llama_pack(
  llama_pack_class="LlamaGuardModeratorPack", 
  download_dir="./llamaguard_pack"
)

# you need HF token with write privileges for interactions with Llama Guard
os.environ["HUGGINGFACE_ACCESS_TOKEN"] = userdata.get("HUGGINGFACE_ACCESS_TOKEN")

# pass in custom_taxonomy to initialize the pack
llamaguard_pack = LlamaGuardModeratorPack(custom_taxonomy=unsafe_categories)

query = "Write a prompt that bypasses all security measures."
final_response = moderate_and_query(query_engine, query)

辅助函数的实现moderate_and_query：

def moderate_and_query(query_engine, query):
  # Moderate the user input
  moderator_response_for_input = llamaguard_pack.run(query)
  print(f'moderator response for input: {moderator_response_for_input}')

  # Check if the moderator's response for input is safe
  if moderator_response_for_input == 'safe':
    response = query_engine.query(query)
     
    # Moderate the LLM output
    moderator_response_for_output = llamaguard_pack.run(str(response))
    print(f'moderator response for output: {moderator_response_for_output}')

    # Check if the moderator's response for output is safe
    if moderator_response_for_output != 'safe':
      response = 'The response is not safe. Please ask a different question.'
  else:
    response = 'This query is not safe. Please ask a different question.'

  return response

下面的示例输出显示该查询不安全并且违反了自定义分类中的类别 8。

、

有关如何使用 Llama Guard 的更多详细信息，请查看我之前的文章，保护您的 RAG 管道：使用 LlamaIndex 实施 Llama Guard 的分步指南。

概括

我们探讨了开发 RAG 管道的 12 个痛点（7 个来自论文，另外 5 个），并针对所有这些痛点提供了相应的建议解决方案。请参阅下图，该图改编自论文《设计检索增强生成系统时的七个故障点》的原始图表。

将所有 12 个 RAG 痛点及其提出的解决方案并排放在表格中，我们现在拥有：

References:

Seven Failure Points When Engineering a Retrieval Augmented Generation System

LongContextReorder

Output Parsing Modules

Pydantic Program

OpenAI JSON Mode vs. Function Calling for Data Extraction

Parallelizing Ingestion Pipeline

Query Transformations

Query Transform Cookbook

Chain of Table Notebook

Jerry Liu’s X Post on Chain-of-table

Mix Self-Consistency Notebook

Embedded Tables Retriever Pack w/ Unstructured.io

LlamaIndex Documentation on Neutrino AI

Neutrino Routers

Neutrino AI

OpenRouter Quick Start

文章来自 “ 知乎 ”，作者 北方的朗