2026 年你需要了解的 RAG 全解析

核心概念、架构与更多实践…

随着2025年的过去,各类基于 LLM 的系统架构已被广泛采用,并在诸多任务上展现出高效性。其中,Retrieval-Augmented Generation (RAG) 无疑是每位 AI 从业者都必须掌握的关键架构。

鉴于其重要性以及原始 RAG 框架在研究与生产系统中的快速演进,本文力求兼顾实用与系统性。

每当我写这类重要 AI 主题时,都会尽量深入,覆盖核心概念、技术、取舍与真实系统中的实操细节。这既是我偏好的学习方式,也因为在多个来源之间来回切换并不利于高效学习。当然,博客并非教科书,深度与广度之间总要权衡。

RAG 起源于 2020 年 NeurIPS/Meta 的工作,展示了如何将稠密神经检索器与 seq2seq 生成器结合来回答知识密集型问题。该论文定义了核心变体,并在 QA 任务上取得显著提升。自那以后,RAG 在工业界与学术界被广泛使用,衍生出众多改进与新变体。

本文属于 「Master LLMs」 系列的一部分。我们将从第一性原理到高级实现全面梳理 RAG。无论你是在构建基于 LLM 的应用,还是在设计企业级 AI 架构,都能获得关于 RAG 的工作机制、适用场景及落地优化的实用洞见。


什么是 RAG,它解决了什么问题?

Retrieval-Augmented Generation 是一种在生成回答前,先利用_外部_知识库来优化 LLM 输出的 AI 架构。它不再只依赖模型训练中学到的知识,而是从外部来源(如数据库)检索最新信息,并据此生成更准确、最新的答案。

从本质上说,RAG 针对传统语言模型的三大限制:

  • 幻觉(Hallucination)问题:标准 LLM 只基于训练中学到的模式生成文本。当被问到超出训练数据或需要严格事实准确性的问题时,常会自信却错误地作答。

  • 知识截止(Knowledge Cutoff)问题:每个语言模型都有训练截止日期。2024 年初训练的模型无法了解 2024 年末或 2025 年的事件。

  • 领域特化(Domain Specificity)挑战:将 LLM 微调到医疗、法律、企业内部知识等专业领域,通常需要巨大的计算资源、海量标注数据以及高昂的基础设施投入。

RAG 通过将回答建立在外部、最新数据库中检索到的文档之上来解决这些问题。与其通过 Finetuning 把所有知识都「装进」模型,RAG 允许模型在推理时(inference time)访问当前的、特定领域的信息。

RAG 的核心理念很优雅:不再把所有知识都编码在模型参数里,而是将知识存储(可检索数据库)与推理能力(LLM)解耦。这使得 AI 系统更具适配性,也更可验证。


RAG 如何工作:核心架构与组成

任何 RAG 系统都通过一条组件流水线来运行,每个组件在将用户问题转化为准确、具备上下文依据的回答时扮演关键角色。我们先从基础架构讲起,再逐步扩展到高级技巧。

下面把 RAG 架构拆分为几个关键阶段。

阶段一:数据准备与摄入(Ingestion)

在回答任何问题之前,RAG 系统必须先摄入并准备外部知识源。和所有 LLM 应用一样,数据质量至关重要。我在本系列其他文章里多次强调过这一点,对 RAG 同样适用。

清单:Master LLMs: A Practical Guide from Fundamentals to Mastery | Curated by Hamza Boulahia |...

如果这一阶段的数据质量很差,无论后续使用怎样的检索或生成方法,结果都会大打折扣。

这一基础阶段包括若干关键步骤:

Document Loading

流程从文档加载器开始,它从不同来源摄入数据(例如 PDF、Word 文档、网页、数据库、API 等)。

文档加载器负责格式化解析,例如:

  • 使用 Web scrapers 从网页中提取主体内容

  • 使用 OCR 模型将 PDF 转为 markdown(更适合 LLM 的格式)

  • 使用 CSV/Excel 解析器保留表格数据的列结构与关系


Text Chunking

原始文档(如 100 页的 PDF 报告)通常过大,无法一次性送入 LLM 处理。因此需要把文档切分为较小、可摄入的 chunks。

Chunker 会将文档切分为单独看也有意义的片段。这看似简单,实则是构建 RAG 系统时最重要的决策之一。Chunk 既要足够大以承载完整的语义(不要把段落截断在半句),又要足够小以保持相关性,并适配模型的上下文窗口限制。

常见的 chunking 策略包括:

  • Fixed-size chunking:按字符、词或 tokens 间隔切分,通常加入重叠以在边界处保留上下文(例如 500 tokens,重叠 50 tokens)

  • Sentence-based chunking:按自然语言边界(句子)切分,保证语义完整性

  • Recursive chunking:优先按段落边界切,退化再按句子,最后按固定长度兜底

  • Semantic chunking:利用 embeddings 识别话题切换点,围绕概念边界切分


Embedding Generation

完成切分后,将每个文本片段转换为数值向量表示(embedding),以捕捉其语义含义。常用 embedding 模型包括 OpenAI 的 text-embedding-3、Sentence-BERT、Cohere 的 embed 等。

这些稠密向量通常有数百到上千维,语义相近的文本会得到相似的向量。

选择合适的 embedding 模型至关重要,因为它会:

  • 决定语义检索的质量:embedding 越好,检索到的结果越相关

  • 影响系统效率与成本:向量维度影响存储占用,以及向量相似度搜索的速度/成本


Vector Indexing

嵌入后的 chunks 会存入专用的 Vector Database(或 Vector Store)。在原型验证阶段,你可以用简单的内存结构(如 Python 字典或文件索引)来存储,但面向规模化与优化,通常选用 Weaviate、Chroma、Pinecone、Qdrant、FAISS 等。

这些数据库围绕 similarity search 做了深度优化,能快速从中检索出与用户查询最相关的 chunks。


阶段二:查询时检索(Query Time Retrieval)

当用户提交查询时,检索流程开始:

  1. 核心机制:首先使用与建库时相同的 embedding 模型将查询转换为向量。随后数据库将此查询向量与数以百万计的 chunk 向量进行比较。

  2. 搜索过程:比较通过 Approximate Nearest Neighbor (ANN) 完成,它利用专门的索引技术(如 Weaviate 中的 HNSW graphs)来在高维空间中找到与查询最接近的向量,从而避免逐一比较_所有_向量的高昂成本。

  3. 相似度度量:通常使用 Cosine Similarity 来度量向量的「接近度」(关注向量方向/夹角)。

  4. Metadata Filtering:高级系统会在检索前或检索过程中使用元数据进行过滤,例如按文档类型、时间范围或用户权限过滤,确保结果既相关又可授权。

这一过程极其迅速,数据库可以在毫秒级返回最语义相关的 chunks(即「最近邻」),从而支撑 RAG 这类实时应用。

更深入了解检索器与工作机制,可参考:

Top Retriever Methods That Outperform Cosine Similarity


阶段三:增强与生成(Augmentation and Generation)

当相关上下文检索完毕,系统会通过 prompt engineering 构造增强提示(augmented prompt)。

示例:将检索到的 chunks 与用户问题按结构化模板拼接:

Context Information:
[Retrieved Chunk 1]
[Retrieved Chunk 2]
[Retrieved Chunk 3]

User Question: [Original Query]

Instructions: Answer the question based on the provided context. 
If the context doesn't contain enough information to answer the question, 
say so explicitly. Include citations to specific context sections.

LLM 生成:将增强后的提示发送给语言模型(如 GPT-4、Claude、Llama、Gemini 等),由其综合检索信息并生成带引用的回答。


核心组件小结


选择合适组件的实用考量

1. 选择 Embedding 模型

如上节所述,embedding 模型对检索质量影响很大,需考虑:

  1. 领域特化:通用模型如 OpenAI 的 text-embedding-3-small、sentence-transformers all-MiniLM-L6-v2 适合广泛场景;但在专业领域(如医学)使用更针对的模型(如 BioBERT)能显著提升效果。

  2. 维度取舍:更高维(1536+)可表达更细致的语义,但需要更多存储与算力;较小维度(384–768)通常能以较小质量损失换取更快搜索。

  3. 多语种需求:如 Cohere 的多语种 embeddings 或 BGE-M3 能处理多语言,适合全球化应用。

选型时可参考 BEIR(Benchmarking IR)或 MTEB(Massive Text Embedding Benchmark)等通用基准,但我更推荐:

  1. 针对你的场景做小规模测试集。准备 20–30 个真实代表性查询,为每个查询手动标注 3–5 个应当检索到的文档,作为 ground truth。

  2. 测试不同 embedding 模型,看它们能否稳定在 Top 结果中返回期望文档。

  3. 追踪 recall@5、MRR(Mean Reciprocal Rank)等指标。

这种面向领域的测试,比通用榜单更能反映「你的数据与查询模式」下的真实表现。

2. 确定最优 Chunk 大小

Chunk 大小最终取决于任务。例如 FAQ 聊天机器人可用更小的 chunk;而财报分析型 RAG 可能需要更大一点。

但有些通用注意点:

  1. 过小(< ~128 tokens):片段上下文不足,信息支离破碎,检索相关性差。

  2. 过大(> ~1024 tokens):片段包含多个主题,降低检索精度;且多段检索时容易触达上下文窗口上限。

  3. 折中范围(256–512 tokens):多数应用在此范围表现良好,既有足够上下文,又能维持较高检索精度。

Overlap 策略:相邻 chunk 保持 10–20% 重叠,可避免关键信息被分割,但会增加存储。

与 embedding 选型一样,最佳 chunk 大小应通过试验并跟踪 MRR、NDCG(Normalized Discounted Cumulative Gain)等指标来确定。


从零搭建你的第一个 RAG:实操示例

我们用 LangChain 与 Gemini 构建一个回答公司 Remote Working Policy 的 Q&A 机器人。可在 Colab 运行此 notebook。无需上传 PDF,运行笔记本会自动生成。

使用 LangChain

依赖:

!pip install -qU langchain langchain-community langchain-text-splitters 
!pip install -qU langchain-huggingface langchain-google-genai langchain-openai
!pip install -qU faiss-cpu pypdf fpdf sentence-transformers

导入:

# Libraries for PDF creation
from fpdf import FPDF
import textwrap

# Libraries for RAG
import os
from langchain_community.document_loaders import PyPDFDirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_community.vectorstores import FAISS

加载文档:使用 PyPDFDirectoryLoader 递归加载目录中的所有 PDF,自动处理抽取与元数据,适合多 PDF 作为 RAG 来源(更适合纯文本 PDF)。

# Load documents
print("Loading documents...")
loader = PyPDFDirectoryLoader("./company_docs/")
documents = loader.load()
print(f"Loaded {len(documents)} documents (1 doc for each page)")

递归切分并重叠:RecursiveCharacterTextSplitter 优先按自然边界(段落、句子)切分,最后按字符长度兜底,适合本场景。

# Chunk documents
print("Chunking documents...")
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", " ", ""]
)
chunks = text_splitter.split_documents(documents)
print(f"Created {len(chunks)} chunks")

用 FAISS 创建向量数据库与检索器:用轻量 embedding 模型 all-MiniLM-L6-v2 计算每个 chunk 的向量,然后用 FAISS 创建向量存储,并转为 retriever 用于相似度搜索。

# Create embeddings and FAISS vector store
print("Creating embeddings and FAISS vector database...")
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)
vectorstore = FAISS.from_documents(
    documents=chunks,
    embedding=embeddings
)
# Save FAISS index
vectorstore.save_local("faiss_index")

# Create retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4}     # retrieve top 4 similar chunks
)

实例化 LLM:我在教程中常用 Gemini,因为有免费层,小模型也很快。

# Set your Google API key
os.environ["GOOGLE_API_KEY"] = "your_api_key"

# Create LLM and QA chain
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash-lite",
    temperature=0
)

创建并运行 RAG:写一个函数串起整个 RAG 流水线,并打印带引用的结果。

# Create RAG pipeline

defask_with_sources(question):
    
    # Retrieve docs first
    docs = retriever.invoke(question)
    
    # Format context
    context = "\n\n".join(
    f"Source: {doc.metadata.get('source', 'Unknown')} (Page {doc.metadata.get('page', 'N/A')})\nContent: {doc.page_content}"
    for doc in docs)
    
    # Generate answer
    prompt_text = f"""
    Answer the question based only on the following retrieved context, and include the source used at the end as reference:

    {context}

    Question: {question}
    """

    response = llm.invoke(prompt_text)
    
    # Print result with sources
    print(f"\nQuestion: {question}")
    print(f"\nAnswer: {response.content}")
    print(f"\nSources Retrieved:")
    for i, doc inenumerate(docs, 1):
        source = doc.metadata.get('source', 'Unknown')
        page = doc.metadata.get('page', 'N/A')
        print(f"  {i}. {source}, Page {page}")

测试 RAG:

question = "what are the Ambient noise levels required"
ask_with_sources(question)

输出:

Question: what are the Ambient noise levels required

Answer: 工作时间内,环境噪音必须低于 45 dB。

Source: company_docs/remote_policy.pdf (Page 0)

Sources Retrieved:
  1. company_docs/remote_policy.pdf, Page 0
  2. company_docs/remote_policy.pdf, Page 0
  3. company_docs/remote_policy.pdf, Page 1
  4. company_docs/remote_policy.pdf, Page 2

很好,现在我们可以获得带引用、可验证的答案了!


使用 LlamaIndex

LlamaIndex 更专注于 RAG 应用,提供易用的高层 API。我们复现同一示例(基于 Remote Work Policy 文档的 RAG)。代码在与上例相同的 notebook 中。

依赖:

!pip install -qU llama-index-llms-google-genai llama-index llama-index-embeddings-huggingface
!pip install -qU nest-asyncio

导入:

# libraries for rag
import os
import re
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.google_genai import GoogleGenAI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core.query_engine import CitationQueryEngine

import nest_asyncio # necessary for notebooks
nest_asyncio.apply()

创建 RAG 引擎:配置与上例相同,但更简洁。

# Define the Global Settings 
Settings.llm = GoogleGenAI(model="models/gemini-2.0-flash-lite")
Settings.embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")

# Load documents
documents = SimpleDirectoryReader('./company_docs').load_data()

# Create index
index = VectorStoreIndex.from_documents(documents)

# Create query engine
query_engine = CitationQueryEngine.from_args(
    index,
    similarity_top_k=4,
    citation_chunk_size=500, 
)

运行 RAG:

def run_rag(query):
  response = query_engine.query(query)

print("Answer:", response.response)
print("="*50)

# Extract citation numbers like [1], [4], etc.
  citations = re.findall(r'\[(\d+)\]', response.response)
  cited_indices = {int(cid) for cid in citations}  # Use set for fast lookup

# Display only cited nodes
for i, node inenumerate(response.source_nodes, start=1):
      if i in cited_indices:
          print(f"[{i}] Metadata (CITED):")
          print("  File:", node.metadata.get('file_name', 'Unknown'))
          print("  Page:", node.metadata.get('page_label', 'N/A'))
          print("  Score:", node.score)
          print("-" * 40)

# Test
response = run_rag("what are the Ambient noise levels required")

输出:

Answer: 工作时间内,环境噪音必须低于 45 dB [4]。

==================================================
[4] Metadata (CITED):
  File: remote_policy.pdf
  Page: 1
  Score: 0.09110435154336344
----------------------------------------

以上就是使用 LlamaIndex 运行简单 RAG 的方式。当然它还能做更多。

LangChain 与 LlamaIndex 各擅胜场:

  • LangChain 在复杂流水线与灵活控制上更强

  • LlamaIndex 更适合快速原型开发


选择 RAG 还是 Finetuning?

在本系列的前一篇中(见这里),我们系统讨论了 LLM 的 Finetuning,并看到它可通过有/无监督训练来定制模型。

相较于 Finetuning,RAG 以一种无需训练的方式来定制 Large Language Models。要明确什么时候该用哪种方法,需要从实操角度理解 RAG 与 Finetuning 的核心差异:

  1. RAG:省预算、上手快
  • 无需重训,只需把模型连到文档
  • 文档一改即生效
  • 数据要求低:只要你的文档,不需要标注集
  • 透明度高:能看到具体用了哪些来源➡ 适合知识更新频繁、需要引用、预算或周期受限的场景
  1. Finetuning:参数优化的路径
  • 能让模型「内化」行业知识
  • 擅长统一语气风格与专业表达
  • 成本高
  • 需要大量高质量训练数据
  • 更新意味着完整重训周期
  • 透明度低:难解释模型为何「知道」➡ 适合知识相对稳定、且有充足预算与数据的场景,尤其当你更关注统一格式与推理速度,而非引用可溯

RAG 的局限与挑战

尽管 RAG 优势明显,但仍存在不少挑战。流水线任一组件出现问题都会_层层传导_。糟糕的 chunks 会导致差的检索,最终生成也不会好。因此要尽量独立测试每个组件。

目标是在问题源头发现并修正,而不是在下游「救火」。

截至 2025 年,主要挑战包括:

1. 检索质量问题

Embedding 模型可能无法捕捉细微关系,导致相关文档排名靠后。技术术语、领域特定词汇或新颖表达会让面向通用语言的检索系统感到困惑。

可行措施:

  • 使用领域专用 embedding 模型

  • 采用语义 + 关键词的 hybrid search

  • 在摄入阶段为每个 chunk 生成 hypothetical questions

  • 增加用于过滤的丰富 metadata

2. 幻觉仍可能出现

RAG 显著降低幻觉,但 LLM 仍可能误读来源、错误拼合信息或合理化超出证据的表述。

可行措施:

  • 在 prompt 中要求对每个关键陈述给出引用

  • 用多次 LLM 调用做自评(response critique)

  • 在关键业务中保留 human-in-the-loop

3. 信息冲突

检索结果可能相互矛盾,尤其在快速变化的领域或存在多视角的任务(如产品评价、市场分析)。

可行措施:

  • 在合适场景呈现多种观点

  • 通过 reranking 优先考虑较新文档

  • 引入来源权威度评分

  • 让 LLM 识别并明确指出冲突

4. 可扩展性与时延

面对上百万文档的大规模 RAG,检索延迟会影响体验。

可行措施:

  • 优化向量库配置(HNSW、量化等)

  • 对常见查询做缓存

5. 上下文窗口溢出

小上下文窗口的模型(<128K tokens)尤为容易触顶;即便 1M+ context 的大模型,在复杂应用中检索大量长 chunks 也可能撞线。

可行措施:

  • 对检索上下文做摘要压缩

  • 用 reranking 算法优先保留最相关 chunks


高级 RAG 技术

为克服标准 RAG 的内在限制,围绕体系架构与组件层面涌现了多种优化方法。本节覆盖当前驱动高性能 RAG 流水线的关键增强技术。

1. 用 Hypothetical Question Generation 做 Metadata 增强

除了在摄入时加入结构化 metadata 以便在语义检索前做过滤外,还可以利用 LLM 为每个 chunk 生成它能够回答的问题,并一并存储。

查询时,用问题匹配问题,而不是用原始文本匹配,从而显著提升语义匹配质量。

# Example metadata structure
chunk_metadata = {
    "source": "employee_handbook.pdf",
    "page": 42,
    "department": "HR",
    "category": "benefits",
    "last_updated": "2024-11-15",
    "access_level": "internal",
    "generated_questions": ["question_1", "question_2", ..]
}

2. 检索后优化(Reranking & LLM-as-a-Judge)

Reranking:初检之后,reranking model 作为专门的过滤器,显著提升检索准确度。它以查询与一组候选匹配项为输入,计算相似度并据此重排。

但我们不是已经在初检时算过「相似度」了吗?

没错,不过两者的相似度计算方式不同:初检基于 Representation-based similarity(如 cosine similarity,对预计算向量做比较);reranking 模型属于 cross-encoder,计算 Interaction-based similarity,把查询与文档一起输入,用注意力机制捕捉更深层语义。

因此 reranking 在语义相关性判别上更强!

尽管 cross-encoder 语义准确度更高,但它们无法使用预计算索引,计算昂贵,不适合初检阶段。

作为参照,用 BERT 在 V100 上对 4000 万条记录做 reranking,单个查询就可能超过 50 小时。

RAG 中的两阶段流程:

  1. 初检:在海量文档上做快速相似检索,取回 Top 50 或 Top 100 候选(快速但可能粗糙)

  2. 重排:对这小部分候选做 reranking,得到更精准的 Top K 交给下游


实操示例:继续用 LlamaIndex,在 RAG 流中添加 reranker。这样可用更小 chunk 也能找到正确答案。

在之前依赖基础上新增一个导入:

from llama_index.core.postprocessor import SentenceTransformerRerank

创建带 reranking 的 RAG 引擎:

# Define Global Settings
Settings.llm = GoogleGenAI(model="models/gemini-2.0-flash-lite")
Settings.embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")

# Load documents
documents = SimpleDirectoryReader('./company_docs').load_data()

#…
— 以上为试看内容(约 40%),开通会员后阅读全文 —