RAG 技术深度调研报告

调研日期：2026-02-28 调研主题：RAG（检索增强生成）技术

第一部分：概念剖析

1. 定义澄清

通行定义

**RAG（Retrieval-Augmented Generation，检索增强生成）**是一种将信息检索与大型语言模型生成相结合的技术架构。它通过从外部知识库中检索相关文档或片段，将其作为上下文输入给 LLM，从而增强生成内容的准确性和可信度。

RAG 的核心价值在于解决 LLM 的三大固有局限：知识时效性（训练数据截止）、幻觉问题（编造事实）和垂直领域知识缺失，使 LLM 能够访问最新、最准确的外部信息。

常见误解

边界辨析

2. 核心架构

┌──────────────────────────────────────────────────────────────┐
│                    RAG 系统架构                               │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐    │
│  │  文档接入   │ ──→ │  文档处理   │ ──→ │  向量化     │    │
│  │  (Ingestion)│     │ (切片/清洗)  │     │  (Embedding)│    │
│  └─────────────┘     └─────────────┘     └──────┬──────┘    │
│                                                  ↓         │
│  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐    │
│  │  生成响应   │ ←── │  重排序     │ ←── │  检索       │    │
│  │  (LLM)      │     │  (Rerank)   │     │  (Retrieve) │    │
│  └─────────────┘     └─────────────┘     └──────┬──────┘    │
│                                                  ↓         │
│                    ┌────────────────────────────┘          │
│                    ↓                                       │
│              ┌─────────────┐                               │
│              │  向量数据库  │                               │
│              │ (Vector DB) │                               │
│              └─────────────┘                               │
└──────────────────────────────────────────────────────────────┘

组件职责说明：

3. 数学形式化

3.1 检索相关性评分

对于查询 $q$ 和文档 $d$，相关性评分：

$\text{score}(q, d) = \frac{\vec{v}_q \cdot \vec{v}_d}{\|\vec{v}_q\| \|\vec{v}_d\|} = \cos(\theta)$

其中 $\vec{v}_q$ 和 $\vec{v}_d$ 分别为查询和文档的嵌入向量。

自然语言解释：相关性由查询和文档向量的余弦相似度衡量。

3.2 Top-K 检索

检索最相关的 $K$ 个文档：

$D_{\text{top}} = \underset{d \in D, |D|=K}{\text{argmax}} \sum_{d} \text{score}(q, d)$

自然语言解释：从文档库中选择与查询最相关的前 K 个文档。

3.3 RAG 生成概率

LLM 生成答案 $a$ 的条件概率：

$P(a | q, D) = \sum_{d \in D_{\text{top}}} P(a | q, d) \cdot P(d | q)$

自然语言解释：最终答案是基于所有检索文档的加权生成概率。

3.4 检索召回率与精确率

$\text{Recall@K} = \frac{|D_{\text{relevant}} \cap D_{\text{retrieved}}|}{|D_{\text{relevant}}|}$

$\text{Precision@K} = \frac{|D_{\text{relevant}} \cap D_{\text{retrieved}}|}{K}$

自然语言解释：召回率衡量查全程度，精确率衡量查准程度。

4. 实现逻辑（Python 伪代码）

from typing import List, Dict, Any, Optional
from dataclasses import dataclass
import numpy as np

@dataclass
class Document:
    """文档片段"""
    content: str
    metadata: Dict[str, Any]
    embedding: Optional[np.ndarray] = None
    score: Optional[float] = None

class EmbeddingModel:
    """文本向量化模型"""

    def __init__(self, model_name: str, dimension: int):
        self.model_name = model_name
        self.dimension = dimension

    def embed(self, texts: List[str]) -> np.ndarray:
        """将文本转换为向量"""
        pass

class VectorStore:
    """向量数据库"""

    def __init__(self, dimension: int):
        self.dimension = dimension
        self.vectors: List[np.ndarray] = []
        self.documents: List[Document] = []

    def add(self, documents: List[Document]):
        """添加文档到向量库"""
        for doc in documents:
            self.vectors.append(doc.embedding)
            self.documents.append(doc)

    def search(self, query_embedding: np.ndarray,
               top_k: int) -> List[Document]:
        """检索最相关的文档"""
        # 计算余弦相似度
        scores = []
        for vec in self.vectors:
            score = np.dot(query_embedding, vec) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(vec)
            )
            scores.append(score)

        # 返回 Top-K
        top_indices = np.argsort(scores)[-top_k:][::-1]
        results = []
        for idx in top_indices:
            doc = self.documents[idx]
            doc.score = scores[idx]
            results.append(doc)
        return results

class Reranker:
    """重排序模型"""

    def __init__(self, model_name: str):
        self.model_name = model_name

    def rerank(self, query: str,
               documents: List[Document]) -> List[Document]:
        """对检索结果进行重排序"""
        # 使用交叉编码器计算更精确的相关性
        pass

class TextSplitter:
    """文本分块器"""

    def __init__(self, chunk_size: int = 500,
                 chunk_overlap: int = 50):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap

    def split(self, text: str) -> List[str]:
        """将文本分割成块"""
        # 按句子或段落分割，保持语义完整性
        pass

class RAGSystem:
    """RAG 系统核心类"""

    def __init__(self, embedding_model: str,
                 vector_store: VectorStore,
                 reranker: Optional[Reranker] = None,
                 llm=None):
        self.embedder = EmbeddingModel(embedding_model, dimension=1536)
        self.vector_store = vector_store
        self.reranker = reranker
        self.llm = llm

    def ingest_documents(self, texts: List[str],
                         metadata_list: List[Dict] = None):
        """
        文档接入流程
        """
        # 阶段 1: 文本分块
        splitter = TextSplitter()
        chunks = []
        for text in texts:
            chunks.extend(splitter.split(text))

        # 阶段 2: 向量化
        embeddings = self.embedder.embed(chunks)

        # 阶段 3: 存储
        documents = [
            Document(content=chunk,
                    metadata=metadata_list[i] if metadata_list else {},
                    embedding=embeddings[i])
            for i, chunk in enumerate(chunks)
        ]
        self.vector_store.add(documents)

    def query(self, question: str, top_k: int = 5) -> str:
        """
        RAG 查询流程
        检索 → 重排序 → 生成
        """
        # 阶段 1: 检索
        query_embedding = self.embedder.embed([question])[0]
        retrieved_docs = self.vector_store.search(
            query_embedding, top_k=top_k * 2  # 初检多返回一些
        )

        # 阶段 2: 重排序
        if self.reranker:
            retrieved_docs = self.reranker.rerank(
                question, retrieved_docs
            )[:top_k]

        # 阶段 3: 构建上下文
        context = "\n\n".join([doc.content for doc in retrieved_docs])

        # 阶段 4: LLM 生成
        prompt = self._build_prompt(question, context)
        answer = self.llm.generate(prompt)

        return answer

5. 性能指标

6. 扩展性与安全性

水平扩展

• 分布式向量检索：使用 HNSW、IVF 等近似最近邻算法支持亿级向量
• 分片存储：按文档类型或时间分片，提升检索效率
• 缓存层：对热门查询结果进行缓存，减少重复检索

垂直扩展

• Embedding 模型优化：使用更大、更专业的嵌入模型提升表示质量
• 混合检索：结合关键词检索（BM25）和向量检索，提升召回率
• 多跳检索：支持迭代式多轮检索，获取更深层信息

安全考量

第二部分：行业情报

1. GitHub 热门项目（15+ 个）

2. 关键论文（12 篇）

3. 系统化技术博客（10 篇）

4. 技术演进时间线

第三部分：方案对比

1. 历史发展时间线

2020 ─┬─ RAG 论文发布 → 概念正式提出
      ├─ DPR 发布 → 密集检索技术成熟
2022 ─┼─ LangChain 开源 → RAG 编排框架标准化
2023 ─┼─ LlamaIndex/HyDE → 数据编排/高级检索
2024 ─┼─ GraphRAG/RAGAS → 图谱融合/评估标准化
2025 ─┼─ 模块化 RAG → 架构抽象升级
2026 ─┴─ 当前状态：企业级 LLM 应用标准配置

2. 五种主流方案横向对比

3. 技术细节对比

4. 选型建议

第四部分：精华整合

1. The One 公式

解读：RAG 的本质是从外部知识库检索相关信息，构建增强上下文输入给 LLM，让其基于真实信息生成答案，同时抑制幻觉。

2. 一句话解释

RAG 就像一个"开卷考试"——LLM 不再是闭卷作答（仅靠训练记忆），而是可以查阅参考书（外部知识库），从而给出更准确、更有依据的答案。

3. 核心架构图

问题 → [向量化] → [检索] → [重排序] → [构建上下文] → [LLM 生成] → 答案
                      ↓                                          ↑
               ┌─────────────┐                          ┌────────┐
               │  向量数据库  │                          │ 上下文  │
               └─────────────┘                          └────────┘

4. STAR 总结

Situation（背景 + 痛点）

LLM 存在三大固有局限：知识时效性受限（训练数据有截止日期）、幻觉问题（可能编造事实）、垂直领域知识缺失（专业领域表现差）。传统 Fine-tuning 方案成本高、更新慢，无法解决实时知识需求。企业需要一种既能利用 LLM 强大生成能力，又能确保答案准确可靠的技术方案。

Task（核心问题）

RAG 需要解决的关键问题是：如何在保持 LLM 生成能力的同时，确保答案基于真实、准确的外部信息。核心约束包括：检索准确性（Recall@10 > 85%）、响应延迟（<500ms）、成本可控（Token 用量优化）、幻觉抑制（事实核查通过率 >90%）。

Action（主流方案）

技术演进历经三代：第一代（基础 RAG）建立检索 + 生成框架；第二代（Advanced RAG）引入混合检索、重排序、Query 改写等优化；第三代（GraphRAG/Modular RAG）融合知识图谱和模块化架构。核心突破包括：稠密检索技术、混合检索策略、Self-RAG 自触发机制、GraphRAG 多跳推理、RAGAS 评估体系。

Result（效果 + 建议）

当前 RAG 系统可将答案准确率提升至 80-90%，幻觉率降低至 10% 以下，成为企业级 LLM 应用的标准配置。但仍存在检索质量依赖、多跳推理弱、评估复杂等挑战。实操建议：原型用 Flowise/Dify，数据密集型用 LlamaIndex，企业级用 LangChain，知识推理用 GraphRAG。

5. 理解确认问题

问题：RAG 和 Fine-tuning 各适用什么场景？为什么 RAG 成为企业级 LLM 应用的首选方案？

参考答案：RAG 适用场景：1）知识频繁更新（新闻、政策等）；2）垂直领域专业问答；3）需要引用和溯源；4）私有数据问答。Fine-tuning 适用场景：1）特定任务风格迁移；2）领域术语理解；3）固定格式输出；4）数据量充足且稳定。RAG 成为首选的原因：a）无需更新模型，知识更新成本低；b）答案可溯源，可信度高；c）实现简单，开箱即用；d）隐私数据可本地部署。

附录：参考资料

来源链接

• LangChain GitHub
• LlamaIndex GitHub
• GraphRAG GitHub
• RAGAS GitHub

数据新鲜度说明

本调研报告所有数据截至 2026-02-28，建议每 6 个月更新一次以跟踪技术演进。

报告完成日期：2026-02-28 总字数：约 15,000 字