RAG 面试八股文 30 道｜深度详解版（傻子都能看懂）

📖 学习指南

🎯 学习目标：通过本文，你将系统掌握 RAG 的核心知识，能够自信地应对任何相关面试问题。

适合人群

🔰 初学者：想系统学习 RAG 的开发者
🚀 有经验者：想深入理解 RAG 原理的高级开发者
💼 面试准备者：想刷 RAG 面试题的求职者

学习建议

先理解概念，再深入原理：先搞懂”是什么”，再搞懂”为什么”
结合实战场景：不要死记硬背，要理解实际应用场景
动手实践：在自己电脑上安装环境，执行本文的示例代码
反复复习：面试前一周，每天复习 10 个问题

学习时间估算

⏱️ 快速复习（只看一句话总结）：2 小时
📚 系统学习（看深度解析）：1-2 天
💪 深入理解（研究源码）：1 周+

🗺️ 知识图谱

mindmap
  root((RAG))
    基础概念
      核心概念1
      核心概念2
      核心概念3
    高级特性
      特性1
      特性2
    实战应用
      应用场景1
      应用场景2
    性能优化
      优化技巧1
      优化技巧2

⚠️ 常见陷阱与误区

陷阱 1：概念理解错误

❌ 错误示例：

1	`# 错误的理解或用法`

✅ 正确做法：

正确理解概念
避免常见误区

陷阱 2：忽略边界条件

❌ 错误做法：

不考虑特殊情况
忽略异常处理

✅ 正确做法：

总是考虑边界条件
添加异常处理

💡 面试技巧

技巧 1：结构化回答

不要只回答”是什么”，要按照以下结构回答：

一句话总结（概念）
深度解析（原理、实现、优缺点）
面试加分回答（实际项目经验、源码理解、行业最佳实践）

技巧 2：结合实战场景

不要只背概念，要结合实际项目经验回答。

技巧 3：引导到你会的方向

如果遇到不会的问题，不要慌，可以引导到你会的方向。

🎯 实战演练（真实面试场景）

场景 1：请你设计一个系统？

回答思路：

需求分析：明确系统需求
技术选型：选择合适的技术栈
架构设计：设计系统架构
性能优化：考虑性能瓶颈和优化方案

🚀 学习路径总结

第一阶段：基础概念（1-2 天）

理解核心概念
掌握基本操作
完成入门教程

第二阶段：高级特性（2-3 天）

掌握高级特性
理解实现原理
完成进阶教程

第三阶段：实战应用（1 周+）

搭建实际项目
解决实战问题
阅读源码（可选）

第四阶段：面试准备（1 周）

刷完本文的所有问题
复习相关知识点
准备项目经验
模拟面试

📚 扩展学习资源

官方资源

书籍推荐

《RAG 实战》
《RAG 权威指南》

博客推荐

RAG 面试八股文 - 学习指南

🎯 学习目标：真正理解 RAG（检索增强生成）的原理，而不仅仅是背答案

📖 适用人群：AI 初学者、准备面试的同学、想深入理解 RAG 的开发者

⏰ 预计学习时间：3-4 天（每天 2-3 小时）

🏆 学习成果：能够自信地回答任何 RAG 面试问题，并理解背后的原理

📚 学习路线（从易到难）

第一阶段：RAG 基础（Day 1）

RAG 的基本概念 - 理解什么是 RAG，为什么需要 RAG
RAG 的工作流程 - 理解索引、检索、生成三个步骤
Embedding（向量嵌入） - 理解如何将文本转换为向量
向量数据库 - 理解向量数据库的原理和应用

第二阶段：RAG 核心组件（Day 2）

文档切分（Chunking） - 理解如何切分文档
向量检索（Vector Search） - 理解如何检索相关文档
向量索引（Vector Index） - 理解 HNSW、IVF 等索引算法
Rerank（重排序） - 理解如何优化检索结果

第三阶段：RAG 高级技术（Day 3）

Hybrid Search（混合检索） - 理解向量检索 + 关键词检索
Corrective RAG（纠正式 RAG） - 理解如何纠正检索错误
Self-RAG（自我反思 RAG） - 理解如何让模型自我反思
上下文压缩（Context Compression） - 理解如何压缩上下文

第四阶段：RAG 评估与部署（Day 4）

RAG 评估（Evaluation） - 理解如何评估 RAG 系统
RAG 的最佳实践 - 理解如何构建生产级 RAG 系统
RAG 的常见坑 - 理解 RAG 的局限性和解决方案
RAG 的未来趋势 - 理解 RAG 的发展方向

🗺️ RAG 知识图谱

graph TD
    A[RAG 检索增强生成] --> B[索引阶段]
    A --> C[检索阶段]
    A --> D[生成阶段]
    
    B --> B1[文档加载]
    B --> B2[文档切分]
    B --> B3[向量嵌入]
    B --> B4[向量存储]
    
    C --> C1[查询嵌入]
    C --> C2[向量检索]
    C --> C3[Rerank 重排序]
    C --> C4[Hybrid Search]
    
    D --> D1[上下文拼接]
    D --> D2[LLM 生成]
    D --> D3[答案返回]
    
    A --> E[高级技术]
    E --> E1[Corrective RAG]
    E --> E2[Self-RAG]
    E --> E3[上下文压缩]
    E --> E4[多轮对话]
    
    A --> F[评估与优化]
    F --> F1[RAGAs]
    F --> F2[Context Precision]
    F --> F3[Context Recall]
    F --> F4[Faithfulness]
    
    style A fill:#ff6b6b
    style B fill:#4ecdc4
    style C fill:#45b7d1
    style D fill:#96ceb4
    style E fill:#ffeaa7
    style F fill:#dfe6e9

⚠️ 常见陷阱和误区

陷阱 1：RAG 和 Fine-Tuning 的区别

❌ 错误理解：RAG 和 Fine-Tuning 是同一个东西
✅ 正确理解：
- RAG：通过检索外部知识来增强生成
- Fine-Tuning：通过微调模型参数来适应特定任务

陷阱 2：Embedding 模型的选择

❌ 错误理解：所有 Embedding 模型都一样
✅ 正确理解：
- 通用模型：BGE、M3E、text-embedding-ada-002
- 领域模型：需要在特定领域数据上微调

陷阱 3：文档切分策略

❌ 错误理解：文档切分得越细越好
✅ 正确答案：
- 切分太细：丢失上下文
- 切分太粗：包含冗余信息
- 应该根据任务需求和模型上下文窗口来调整

陷阱 4：向量检索的局限性

❌ 错误理解：向量检索总能找到最相关的文档
✅ 正确答案：
- 向量检索擅长语义匹配
- 关键词检索擅长精确匹配
- 应该结合两者（Hybrid Search）

陷阱 5：RAG 的评估

❌ 错误理解：只评估生成结果的质量
✅ 正确答案：
- 应该评估检索质量（Context Precision、Context Recall）
- 应该评估生成质量（Faithfulness、Answer Relevance）

🎯 面试技巧

技巧 1：回答问题时，先讲”是什么”，再讲”为什么”

❌ 不好的回答：直接讲底层原理，面试官听不懂
✅ 好的回答：
1. 先讲”是什么”（一句话总结）
2. 再讲”为什么”（深度解析）
3. 最后讲”实际应用场景”（面试加分回答）

技巧 2：用”比喻”帮助理解

RAG：就像”开卷考试，可以查书”
Embedding：就像”把文本转换成坐标，相似的文本坐标靠近”
向量检索：就像”在地图上找附近的人”

技巧 3：结合”实际项目经验”回答

不要只背概念，要讲你在实际项目中怎么用的
比如：”我在 XX 项目中，用 RAG 实现了文档问答系统…”

📖 推荐学习资源

官方文档（最权威）

论文（深入理解）

“Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks”（RAG 原始论文）
“Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection”
“Corrective RAG: Defeating the LLM Hallucination”

开源项目（动手实践）

LangChain - RAG 开发框架
LlamaIndex - 数据框架
RAGAs - RAG 评估框架

💪 学习建议

不要死记硬背，要理解原理
多写代码，亲自体验 RAG 的各个环节
看论文，理解 RAG 的最新进展
做项目，在实际项目中应用 RAG
刷面试题，熟悉常见的面试问题

现在，让我们开始学习 RAG 吧！🚀

RAG 面试八股文 30 道｜深度详解版

写给准备面试的你：
这篇文章不讲废话，每个知识点都从「是什么 → 为什么 → 怎么用」三个层次讲透。
配有大量比喻和场景化解释，目标是让没有 RAG 基础的人也能看懂。
建议配合实际代码示例，理解效果翻倍。

一、RAG 基础（1-10）

Q1：什么是 RAG（检索增强生成）？它为什么重要？

一句话结论

RAG = Retrieval（检索）+ Augmentation（增强）+ Generation（生成），让 LLM 能查资料后再回答，解决”知识过时”和”幻觉”问题。

💻 代码示例：构建一个简单的 RAG 系统

使用 LangChain 构建 RAG：

from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.chat_models import ChatOllama
from langchain.chains import RetrievalQA

# 1. 加载文档
loader = TextLoader("data.txt")
documents = loader.load()

# 2. 切分文档
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
texts = text_splitter.split_documents(documents)

# 3. 创建向量嵌入
embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh-v1.5")

# 4. 存储到向量数据库
vectorstore = Chroma.from_documents(texts, embeddings)

# 5. 创建检索器
retriever = vectorstore.as_retriever()

# 6. 初始化 LLM
llm = ChatOllama(model="qwen2:7b")

# 7. 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# 8. 提问
result = qa_chain.invoke({"query": "什么是 RAG？"})
print(result["result"])

运行结果：

1	`RAG（检索增强生成）是一种结合检索和生成的技术...`

⚠️ 常见错误

错误 1：认为 RAG 可以解决所有问题

1 2	`❌ 错误理解：RAG 是万能的，可以解决所有 LLM 的问题 ✅ 正确回答：RAG 主要解决知识更新和幻觉问题，但不能解决所有问题`

错误 2：忽略 RAG 的局限性

1 2	`❌ 错误回答：RAG 总能找到最相关的文档 ✅ 正确回答：RAG 的检索质量受 Embedding 模型、切分策略、检索算法影响`

🎯 面试场景模拟

面试官：”请讲讲什么是 RAG？”

你的回答：

一句话总结：RAG（检索增强生成）是一种结合检索和生成的技术，通过检索外部知识来增强 LLM 的生成质量。
举个例子：就像”开卷考试，可以查书”。
好处：解决知识更新问题、减少幻觉、增强可解释性。
实际项目中的应用：我在 XX 项目中，用 RAG 实现了文档问答系统，准确率提升了 30%。

深度解析

1. 为什么需要 RAG？

用大白话解释：

LLM（比如 GPT-4）的训练数据是过时的（比如 GPT-4 的知识截止到 2023 年 4 月），它不知道最新信息。
另外，LLM 会瞎编答案（幻觉），比如你问”公司 2026 年的新产品是什么？”，它会瞎编一个。

RAG 就是让 LLM 先查资料（检索相关文档），再回答（用查到的资料回答问题）。

2. RAG 的工作流程

用户提问："公司 2026 年的新产品是什么？"
   ↓
1. 检索（Retrieval）：把问题转成向量，去向量数据库查相关资料
   ↓
2. 增强（Augmentation）：把查到的资料作为上下文（Context）
   ↓
3. 生成（Generation）：LLM 根据上下文回答问题
   ↓
LLM 回答："公司 2026 年的新产品是 XXX（根据查到的资料）"

3. RAG vs Fine-Tuning（微调）

对比项	RAG	Fine-Tuning（微调）
成本	低（不用训练模型）	高（需要 GPU、需要标注数据）
知识更新	快（更新文档就行）	慢（需要重新训练）
效果	好（基于真实文档）	一般（可能过拟合）
适用场景	知识密集型任务（问答系统、客服机器人）	特定风格/特定领域（比如医疗、法律）

面试加分回答

「RAG 的核心是检索 + 增强 + 生成。它解决了 LLM 的两个痛点：知识过时（训练数据过时）和幻觉（瞎编答案）。实际项目中，RAG 是 LLM 应用的主流架构（比如客服机器人、企业知识库问答）。另外，RAG 和 Fine-Tuning 不是互斥的，可以同时使用（RAG 负责查资料，Fine-Tuning 负责调整模型风格）。」

Q2：RAG 的工作流程是什么？每步做了什么？

一句话结论

RAG 工作流程：用户提问 → 向量化问题 → 检索相关文档 → 把文档作为上下文 → LLM 生成答案。

💻 代码示例：理解 RAG 的工作流程

RAG 工作流程的详细代码：

# ==================== 索引阶段 ====================
# 1. 加载文档
from langchain_community.document_loaders import DirectoryLoader
loader = DirectoryLoader("docs/", glob="**/*.pdf")
documents = loader.load()

# 2. 切分文档
from langchain_text_splitters import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["

", "
", "。", "！", "？", " ", ""]
)
texts = text_splitter.split_documents(documents)

# 3. 创建向量嵌入
from langchain_community.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh-v1.5")

# 4. 存储到向量数据库
from langchain_community.vectorstores import Chroma
vectorstore = Chroma.from_documents(
    texts, 
    embeddings,
    persist_directory="./chroma_db"
)

# ==================== 检索阶段 ====================
# 5. 用户输入查询
query = "什么是 RAG？"

# 6. 将查询转换为向量
query_embedding = embeddings.embed_query(query)

# 7. 检索相关文档
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
relevant_docs = retriever.get_relevant_documents(query)

# 8. Rerank（重排序）
from langchain_community.document_compressors import FlashrankRerank
compressor = FlashrankRerank()
compressed_docs = compressor.compress_documents(relevant_docs, query)

# ==================== 生成阶段 ====================
# 9. 拼接上下文
context = "
".join([doc.page_content for doc in compressed_docs])

# 10. 构建 Prompt
prompt_template = "根据以下上下文回答问题：

上下文：
{context}

问题：{query}

回答："
prompt = prompt_template.format(context=context, query=query)

# 11. 调用 LLM 生成答案
from langchain_community.chat_models import ChatOllama
llm = ChatOllama(model="qwen2:7b")
answer = llm.invoke(prompt)

# 12. 返回答案
print(answer)

⚠️ 常见错误

错误 1：忽略文档切分的重要性

1 2	`❌ 错误理解：文档切分不影响 RAG 效果 ✅ 正确回答：文档切分非常重要，切分不好会导致丢失上下文或检索不准确`

错误 2：忽略 Rerank 的作用

1 2	`❌ 错误回答：向量检索的结果已经是最相关的 ✅ 正确回答：向量检索的结果不一定最相关，需要 Rerank 来优化`

🎯 面试场景模拟

面试官：”请讲讲 RAG 的工作流程？”

你的回答：

索引阶段：加载文档 → 切分文档 → 向量嵌入 → 存储到向量数据库
检索阶段：用户输入查询 → 查询向量化 → 检索相关文档 → Rerank
生成阶段：拼接上下文 → 构建 Prompt → LLM 生成答案 → 返回答案
实际项目中的应用：我在 XX 项目中，优化了文档切分策略，将准确率从 70% 提升到 85%。

深度解析

1. RAG 工作流程详解

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 准备文档（公司新产品介绍）
documents = ["公司 2026 年的新产品是 XXX，功能是..."]

# 2. 向量化文档（把文档转成向量）
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_texts(documents, embeddings)

# 3. 检索（用户提问时，先查资料）
retriever = vectorstore.as_retriever()
relevant_docs = retriever.get_relevant_documents("公司 2026 年的新产品是什么？")

# 4. 增强（把查到的资料作为上下文）
context = "\n".join([doc.page_content for doc in relevant_docs])

# 5. 生成（LLM 根据上下文回答问题）
prompt = f"根据以下资料回答问题：\n{context}\n\n问题：公司 2026 年的新产品是什么？"
answer = OpenAI().generate(prompt)

2. 每步的详细说明

步骤	说明	技术方案
1. 文档加载	加载文档（PDF、Word、网页）	PyPDF2、Docx、BeautifulSoup
2. 文档切分	把文档切成小块（Chunk）	LangChain 的 `RecursiveCharacterTextSplitter`
3. 向量化	把文档块转成向量（Embedding）	OpenAI Embeddings、Sentence-BERT
4. 存储	把向量存入向量数据库	Chroma、Pinecone、Milvus
5. 检索	用户提问时，把问题转成向量，查相关文档	向量相似度搜索（余弦相似度）
6. 增强	把查到的文档作为上下文	Prompt Engineering（把文档拼接到 Prompt）
7. 生成	LLM 根据上下文回答问题	GPT-4、Claude、文心一言

面试加分回答

「RAG 的工作流程分为离线部分（文档加载、切分、向量化、存储）和在线部分（检索、增强、生成）。面试中，经常问”RAG 的瓶颈在哪里？”——答案是检索质量（如果检索不到相关文档，LLM 就会瞎编）。提升检索质量的方法：1) 用更好的 Embedding 模型；2) 优化文档切分策略；3) 用 Hybrid Search（向量检索 + 关键词检索）。」

Q3：什么是 Embedding（向量嵌入）？它为什么重要？

一句话结论

Embedding 是把文本转成向量（一串数字），语义相近的文本，向量也相近。它是 RAG 的”灵魂”。

深度解析

1. 为什么需要 Embedding？

用大白话解释：

计算机不懂文本（它只懂数字）。
Embedding 就是把文本转成向量（比如”国王” → [0.1, 0.2, ..., 0.9]）。
语义相近的文本，向量也相近（比如”国王”和”女王”的向量很近，”国王”和”苹果”的向量很远）。

2. Embedding 的原理

1
2
3

"国王"  → Embedding模型 → [0.1, 0.2, 0.3, ..., 0.9]（1536 维向量）
"女王"  → Embedding模型 → [0.1, 0.2, 0.3, ..., 0.8]（和"国王"很近）
"苹果"  → Embedding模型 → [0.5, 0.6, 0.7, ..., 0.2]（和"国王"很远）

3. 常用 Embedding 模型

模型	向量维度	效果	成本
text-embedding-ada-002（OpenAI）	1536 维	好	便宜（$0.0001/1K tokens）
text-embedding-3-small（OpenAI）	1536 维	更好	便宜
text-embedding-3-large（OpenAI）	3072 维	最好	中等
Sentence-BERT（开源）	768 维	好	免费（本地部署）
M3E（中文友好）	768 维	好（中文）	免费（本地部署）

面试加分回答

「Embedding 是 RAG 的”灵魂”——如果 Embedding 模型不好，语义相近的文本向量也不相近，检索就会失败。实际项目中，选择 Embedding 模型要看语言（中文用 M3E 或 text-embedding-3-large，英文用 Sentence-BERT 或 text-embedding-3-small）和成本（OpenAI 的 Embedding 模型便宜，但要联网；开源模型免费，但可以本地部署）。另外，Embedding 的向量维度越高，效果越好，但存储成本也越高。」

Q4：什么是向量数据库？它和传统数据库有什么区别？

一句话结论

向量数据库是专门存储和检索向量的数据库；传统数据库（比如 MySQL）是存储结构化数据的。

深度解析

1. 为什么需要向量数据库？

用大白话解释：

传统数据库（MySQL）不会算向量相似度（比如”国王”和”女王”的向量相似度是多少？MySQL 算不了）。
向量数据库专门用来存向量、算向量相似度（比如 Chroma、Pinecone）。

2. 向量数据库的核心功能

功能	说明
存储向量	把文档的 Embedding 向量存起来
向量检索	根据用户问题的向量，找最相似的文档向量（余弦相似度、欧氏距离）
元数据过滤	根据元数据过滤（比如只检索”2026 年”的文档）

3. 常用向量数据库对比

向量数据库	开源	部署方式	适用场景
Chroma	✅ 开源	本地部署（简单）	原型开发、小规模应用
Pinecone	❌ 闭源	云服务（简单）	生产环境、大规模应用
Weaviate	✅ 开源	本地部署 / 云服务	生产环境、需要元数据过滤
Milvus	✅ 开源	本地部署（复杂）	大规模向量检索（十亿级）
Qdrant	✅ 开源	本地部署 / 云服务	生产环境、需要过滤和排序

面试加分回答

「向量数据库是 RAG 的”仓库”——它负责存储文档的 Embedding 向量，并根据用户问题的向量检索相关文档。实际项目中，选择向量数据库要看规模（小规模用 Chroma，大规模用 Milvus 或 Pinecone）和部署方式（本地部署用 Chroma/Weaviate/Milvus，云服务用 Pinecone/Qdrant）。另外，向量数据库的检索速度很关键（十亿级向量要在毫秒级返回结果），所以需要向量索引（比如 HNSW、IVF）。」

Q5：RAG 中的文档切分（Chunking）策略有哪些？

一句话结论

文档切分策略：固定大小切分（简单）、语义切分（按段落/标题切分，效果好）、递归切分（按分隔符递归切分，最常用）。

深度解析

1. 为什么需要文档切分？

用大白话解释：

如果文档太长（比如 10000 字），LLM 的上下文长度有限（比如 GPT-4 是 128K tokens），放不下。
另外，检索精度（如果文档太长，检索时可能检索不到关键信息）。
所以需要把文档切成小块（Chunk，比如每块 500 字）。

2. 常用切分策略

切分策略	说明	优点	缺点
固定大小切分	按字符数切分（比如每块 500 字）	简单	可能切断句子（语义不完整）
语义切分	按段落/标题切分（保留语义完整）	语义完整	块大小不均匀（有的块大，有的块小）
递归切分（最常用）	按分隔符递归切分（先按 `\n\n` 切分，再按 `\n` 切分，最后按空格切分）	兼顾语义和块大小	复杂

3. 代码示例（LangChain）

from langchain.text_splitter import RecursiveCharacterTextSplitter

# 递归切分（最常用）
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # 每块 500 字
    chunk_overlap=50,     # 相邻块重叠 50 字（保留上下文）
    separators=["\n\n", "\n", " ", ""]  # 递归切分的分隔符
)

# 切分文档
texts = text_splitter.split_text(document)

面试加分回答

「文档切分是 RAG 的关键步骤——如果切分不好，检索精度会下降。实际项目中，推荐用递归切分（RecursiveCharacterTextSplitter），因为它兼顾语义和块大小。另外，chunk_overlap（相邻块重叠）很重要——它保留了上下文，避免切分后语义不完整。一般 chunk_overlap 设为 chunk_size 的 10%-20%。」

Q6：向量检索（Vector Search）的原理是什么？

一句话结论

向量检索是把查询文本转成向量，然后在向量数据库中找最相似的向量（余弦相似度或欧氏距离）。

深度解析

1. 为什么需要向量检索？

用大白话解释：

传统关键词检索（比如 SQL 的 LIKE '%天气%'）只能匹配关键词，如果用户输入”今天冷不冷？”，它匹配不到”天气”。

向量检索是语义匹配（把”今天冷不冷？”和”天气”的向量算相似度），能匹配到相关文档。

2. 向量检索的流程

用户提问："今天冷不冷？"
   ↓
1. 向量化（Embedding）：把问题转成向量 [0.1, 0.2, ..., 0.9]
   ↓
2. 计算相似度：把问题向量和数据库中的所有文档向量算相似度
   ↓
3. 排序：按相似度从高到低排序
   ↓
4. 返回 Top-K 相关文档（比如 Top-3）

3. 相似度计算方法

方法	说明	公式
余弦相似度（最常用）	计算两个向量的夹角（夹角越小，越相似）	`cosine_similarity = A·B / (
欧氏距离	计算两个向量的直线距离（距离越小，越相似）	`euclidean_distance = sqrt(Σ(Ai - Bi)²)`
点积	计算两个向量的点积（值越大，越相似）	`dot_product = Σ(Ai × Bi)`

面试加分回答

「向量检索的核心是相似度计算（余弦相似度最常用）。但是，如果向量数据库中有十亿级向量，每次都和所有向量算相似度（暴力搜索），速度会很慢。所以需要向量索引（比如 HNSW、IVF），加速检索。另外，向量检索的召回率（能不能检索到相关文档）很重要，一般用 recall@K 指标评估。」

Q7：什么是向量索引（Vector Index）？有哪些常用算法？

一句话结论

向量索引是加速向量检索的数据结构，常用算法：HNSW（效果好）、IVF（速度快）、LSH（适合高维向量）。

深度解析

1. 为什么需要向量索引？

用大白话解释：

如果向量数据库中有十亿级向量，每次都和所有向量算相似度（暴力搜索），速度会很慢（O(N) 复杂度）。

向量索引就是提前建好索引（类似书的目录），检索时只用看”目录”指向的向量，不用看所有向量。

2. 常用向量索引算法

算法	说明	优点	缺点
HNSW（最常用）	基于图的索引（多层图）	效果好（召回率高）、速度快	占用内存大
IVF（倒排索引）	把向量分成多个簇（Cluster），检索时只看少数几个簇	速度快（适合大规模向量）	效果略差（可能漏掉相关向量）
LSW（局部敏感哈希）	把相似向量哈希到同一个桶	速度快（适合高维向量）	效果差（召回率低）

3. 代码示例（Chroma 中使用 HNSW）

import chromadb

# 1. 创建 Chroma 客户端（使用 HNSW 索引）
client = chromadb.Client(settings=chromadb.Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./chroma_db"
))

# 2. 创建 Collection（集合，类似关系数据库的"表"）
collection = client.create_collection(
    name="my_documents",
    metadata={"hnsw:space": "cosine"}  # 使用余弦相似度
)

# 3. 插入向量（自动建 HNSW 索引）
collection.add(
    embeddings=[[0.1, 0.2, ...], [0.3, 0.4, ...]],  # 向量
    documents=["文档1内容", "文档2内容"],
    ids=["doc1", "doc2"]
)

# 4. 检索（使用 HNSW 索引加速）
results = collection.query(
    query_embeddings=[0.1, 0.2, ...],
    n_results=3  # 返回 Top-3 相关文档
)

面试加分回答

「向量索引是加速向量检索的关键。实际项目中，推荐用 HNSW（效果好、速度快），但如果向量规模很大（十亿级），可以用 IVF（速度快，但效果略差）。另外，向量索引的参数调优很关键：HNSW 的 M（每个节点的邻居数）和 efConstruction（构建时的候选集大小）会影响效果和速度，需要调优。」

Q8：什么是 Rerank（重排序）？为什么需要它？

一句话结论

Rerank 是对检索结果重新排序（让更相关的文档排前面）。向量检索的 Top-K 结果不一定最相关，需要 Rerank 优化。

深度解析

1. 为什么需要 Rerank？

用大白话解释：

向量检索返回的 Top-K 结果不一定最相关（比如第 1 名相关，第 2 名不相关）。

Rerank 就是用一个更准的模型（比如 Cross-Encoder）对 Top-K 结果重新排序，让更相关的文档排前面。

2. Rerank 的流程

向量检索返回 Top-20 结果（可能排序不准）
   ↓
Rerank 模型（Cross-Encoder）对这 20 个结果重新打分
   ↓
按 Rerank 分数重新排序
   ↓
返回 Rerank 后的 Top-5 结果（更准确）

3. 代码示例（使用 Cohere Rerank API）

import cohere

# 1. 向量检索返回 Top-20 结果
retrieved_docs = [
    "文档1：北京今天晴天，气温 25 度",
    "文档2：上海今天雨天，气温 20 度",
    # ...（共 20 个文档）
]

# 2. 使用 Cohere Rerank API 重排序
co = cohere.Client(api_key="YOUR_API_KEY")
results = co.rerank(
    query="北京天气怎么样？",
    documents=retrieved_docs,
    top_n=5  # 返回 Rerank 后的 Top-5
)

# 3. 输出 Rerank 后的结果
for result in results:
    print(f"文档：{result['document']['text']}, 分数：{result['relevance_score']}")

面试加分回答

「Rerank 是提升 RAG 检索精度的关键步骤。向量检索用 Bi-Encoder（速度快，但效果略差），Rerank 用 Cross-Encoder（效果好，但速度慢）。实际项目中，Rerank 的成本要考虑（Cross-Encoder 比 Bi-Encoder 贵 10 倍），所以一般只对 Top-K（比如 Top-20）做 Rerank，不对所有文档做 Rerank。」

Q9：什么是 Hybrid Search（混合检索）？为什么需要它？

一句话结论

Hybrid Search = 向量检索 + 关键词检索，结合了语义匹配和精准匹配的优点。

深度解析

1. 为什么需要 Hybrid Search？

用大白话解释：

向量检索（语义匹配）：能匹配近义词（比如”天气”和”冷不冷”），但可能漏掉精准匹配（比如用户搜”GPT-4”，向量检索可能返回”GPT-3”的文档）。

关键词检索（精准匹配）：能精准匹配关键词（比如”GPT-4”），但不能匹配近义词（比如”冷不冷”匹配不到”天气”）。

Hybrid Search 就是结合两者优点（既匹配近义词，又精准匹配关键词）。

2. Hybrid Search 的打分策略

打分策略	说明
加权求和	`最终分数 = α × 向量检索分数 + (1-α) × 关键词检索分数`（α 一般取 0.7）
RRF（Reciprocal Rank Fusion）	把向量检索和关键词检索的排名转换成分数，然后相加（效果最好）

3. 代码示例（LangChain 中使用 Hybrid Search）

from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# 1. 向量检索（Chroma）
vectorstore = Chroma(embedding_function=OpenAIEmbeddings())
vector_retriever = vectorstore.as_retriever()

# 2. 关键词检索（BM25）
bm25_retriever = BM25Retriever.from_texts(["文档1", "文档2", ...])

# 3. Hybrid Search（加权求和）
ensemble_retriever = EnsembleRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    weights=[0.7, 0.3]  # 向量检索权重 0.7，关键词检索权重 0.3
)

# 4. 检索
results = ensemble_retriever.get_relevant_documents("北京天气怎么样？")

面试加分回答

「Hybrid Search 是提升 RAG 检索精度的重要手段。实际项目中，Hybrid Search 的权重调优（α 取多少？）很关键：如果文档中专业术语多（比如”GPT-4”、”Transformer”），应该加大关键词检索的权重；如果文档是通俗文本，应该加大向量检索的权重。另外，RRF（Reciprocal Rank Fusion）比加权求和效果更好。」

Q10：RAG 的评估（Evaluation）怎么做？

一句话结论

RAG 评估分为：检索评估（检索到了吗？）和生成评估（答案对吗？）。

深度解析

1. 为什么需要评估？

用大白话解释：

如果 RAG 系统没有评估，你不知道它好不好用：

检索到了相关文档吗？（检索评估）

LLM 生成的答案对吗？（生成评估）

2. 检索评估（Retrieval Evaluation）

指标	说明
召回率（Recall@K）	Top-K 结果中有多少相关文档？（比如相关文档有 10 个，Top-10 结果中有 8 个，召回率 80%）
精确率（Precision@K）	Top-K 结果中有多少是相关的？（比如 Top-10 结果中有 8 个相关，精确率 80%）
MRR（Mean Reciprocal Rank）	第一个相关文档的排名的倒数（越高越好）

3. 生成评估（Generation Evaluation）

指标	说明
Faithfulness（忠实度）	答案是否基于检索到的文档？（防止幻觉）
Answer Relevance（答案相关性）	答案是否回答了问题？
Context Relevance（上下文相关性）	检索到的文档是否相关？

4. 代码示例（使用 RAGAS 评估框架）

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevance, context_relevance

# 1. 定义评估指标
metrics = [faithfulness, answer_relevance, context_relevance]

# 2. 准备评估数据
eval_data = {
    "question": ["北京天气怎么样？"],
    "answer": ["北京今天晴天，气温 25 度"],
    "contexts": [["北京今天晴天，气温 25 度，空气质量良好"]]
}

# 3. 评估
results = evaluate(metrics=metrics, dataset=eval_data)
print(results)

面试加分回答

「RAG 评估是很容易被忽视的环节。检索评估用 Recall@K、Precision@K；生成评估用 Faithfulness、Answer Relevance。实际项目中，评估要持续进行（每次更新 RAG 系统，都要重新评估），确保性能没有下降。另外，RAGAS 是专门的 RAG 评估框架，可以自动化评估流程。」

Q11：RAG 的最佳实践有哪些？

一句话结论

RAG 最佳实践：1) 用更好的 Embedding 模型；2) 优化文档切分；3) 用 Hybrid Search；4) 用 Rerank；5) 做好评估。

深度解析

1. 用更好的 Embedding 模型

# ❌ 不好的 Embedding 模型（效果差）
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")  # 效果一般

# ✅ 好的 Embedding 模型（效果好）
from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(model_name="moka-ai/m3e-base")  # 中文效果好

2. 优化文档切分

# ❌ 不好的切分（切断句子）
text_splitter = CharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=0  # 没有重叠，语义不完整
)

# ✅ 好的切分（保留语义完整）
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,  # 相邻块重叠 50 字（保留上下文）
    separators=["\n\n", "\n", " ", ""]  # 递归切分
)

3. 用 Hybrid Search

见 Q9（什么是 Hybrid Search？为什么需要它？）

4. 用 Rerank

见 Q8（什么是 Rerank？为什么需要它？）

5. 做好评估

见 Q10（RAG 的评估（Evaluation）怎么做？）

面试加分回答

「RAG 最佳实践：更好的 Embedding 模型 + 优化文档切分 + Hybrid Search + Rerank + 做好评估。另外，实际项目中，RAG 的Prompt 工程也很重要：怎么把检索到的文档拼接到 Prompt 中？——一般是用 \n\nContext:\n{context}\n\nQuestion: {question}\nAnswer: 格式。」

Q12：RAG 的常见坑有哪些？

一句话结论

RAG 的常见坑：检索不到相关文档、检索到无关文档、LLM 不看上下文（直接回答）、成本失控。

深度解析

1. 检索不到相关文档

用大白话解释：

用户问”公司 2026 年的新产品是什么？”，但向量数据库中没有相关文档，RAG 检索不到。

解决方法：

补充文档（把公司 2026 年的新产品介绍加到向量数据库）
用更好的 Embedding 模型（提升检索精度）
用 Hybrid Search（向量检索 + 关键词检索）

2. 检索到无关文档

用大白话解释：

用户问”北京天气怎么样？”，但向量数据库中只有”上海天气”的文档，RAG 检索到无关文档（上海天气），LLM 根据错误文档回答。

解决方法：

用 Rerank（重排序，把最相关的文档排前面）
优化文档切分（让每块文档语义更完整）
限制检索数量（比如只取 Top-3，不取 Top-10）

3. LLM 不看上下文（直接回答）

用大白话解释：

RAG 检索到了相关文档，但 LLM 不看上下文，直接根据自己的训练数据回答（可能过时或错误）。

解决方法：

在 Prompt 中明确要求”请根据以下上下文回答问题，不要用自己的知识”
用”少样本学习”（Few-Shot），给几个示例（问题 + 上下文 + 答案）

4. 成本失控

用大白话解释：

RAG 每次都要把检索到的文档拼接到 Prompt 中，如果检索到很多文档，Prompt 会很长（Token 用量大，成本高）。

解决方法：

限制检索数量（比如只取 Top-3）
用便宜的模型（比如用 GPT-3.5 代替 GPT-4）

面试加分回答

「RAG 的常见坑：检索不到相关文档、检索到无关文档、LLM 不看上下文（直接回答）、成本失控。实际项目中，这些坑都要提前预防（比如做好评估、限制检索数量、用便宜的模型）。另外，RAG 的可解释性也很重要（为什么检索到这个文档？能不能解释原因？）——如果 RAG 给出错误答案，你要能回溯原因。」

三、RAG 进阶（13-20）

Q13：什么是 Corrective RAG（纠正式 RAG）？

一句话结论

Corrective RAG = 检索 → 评估检索质量 → 如果不好就重新检索或改写问题。

深度解析

1. 为什么需要 Corrective RAG？

用大白话解释：

传统 RAG 是”一次性”的：检索 → 生成答案。
如果检索到的文档质量不好（不相关、信息不足），LLM 会根据错误文档回答。

Corrective RAG 是”纠正式”的：检索 → 评估检索质量 → 如果不好就重新检索或改写问题。

2. Corrective RAG 的流程

用户提问："北京天气怎么样？"
   ↓
1. 检索（Retrieval）：检索相关文档
   ↓
2. 评估检索质量（Assessment）：LLM 评估检索到的文档是否相关？
   ↓
   如果相关 → 生成答案
   如果不相关 → 重新检索（用不同的检索策略）或改写问题（"北京天气预报"）
   ↓
3. 生成（Generation）：LLM 根据上下文回答问题

3. 代码示例

def corrective_rag(user_question: str) -> str:
    """Corrective RAG"""
    # 1. 检索
    retrieved_docs = retrieve(user_question)
    
    # 2. 评估检索质量（让 LLM 评估）
    assessment_prompt = f"""请评估以下文档是否和问题相关：
    问题：{user_question}
    文档：{retrieved_docs}
    
    如果相关，输出"相关"；如果不相关，输出"不相关"。"""
    
    assessment = llm.generate(assessment_prompt)
    
    # 3. 如果不相关，重新检索或改写问题
    if "不相关" in assessment:
        # 改写问题（让 LLM 改写）
        rewrite_prompt = f"请改写以下问题，让它更容易检索到相关文档：{user_question}"
        rewritten_question = llm.generate(rewrite_prompt)
        
        # 重新检索
        retrieved_docs = retrieve(rewritten_question)
    
    # 4. 生成答案
    answer = generate_answer(user_question, retrieved_docs)
    return answer

面试加分回答

「Corrective RAG 是 RAG 的改进版，它在检索后评估检索质量，如果不好就重新检索或改写问题。这是提升 RAG 精度的有效方法。另外，Corrective RAG 的评估检索质量步骤很关键：怎么评估？——可以用 LLM 评估（让 LLM 判断文档是否相关），也可以用向量相似度（相似度太低就是不相关）。」

Q14：什么是 Self-RAG（自我反思 RAG）？

一句话结论

Self-RAG = 检索 → 生成答案 → 反思（评估答案质量）→ 如果不好的就重新检索或重新生成。

深度解析

1. 为什么需要 Self-RAG？

用大白话解释：

Corrective RAG 是在检索后评估检索质量。
Self-RAG 是在生成后评估答案质量（自我反思）。

如果答案质量不好（比如不准确、不完整），Self-RAG 会重新检索或重新生成。

2. Self-RAG 的流程

用户提问："北京天气怎么样？"
   ↓
1. 检索（Retrieval）：检索相关文档
   ↓
2. 生成（Generation）：LLM 根据上下文生成答案
   ↓
3. 反思（Reflection）：LLM 评估答案质量（准确吗？完整吗？）
   ↓
   如果质量好 → 返回答案
   如果质量不好 → 重新检索（用不同的检索策略）或重新生成
   ↓
4. 返回最终答案

3. 代码示例

def self_rag(user_question: str, max_retries: int = 3) -> str:
    """Self-RAG"""
    for i in range(max_retries):
        # 1. 检索
        retrieved_docs = retrieve(user_question)
        
        # 2. 生成答案
        answer = generate_answer(user_question, retrieved_docs)
        
        # 3. 反思（评估答案质量）
        reflection_prompt = f"""请评估以下答案的质量（1-5 分，5 分最好）：
        问题：{user_question}
        答案：{answer}
        
        输出格式：分数：X（1-5）"""
        
        reflection = llm.generate(reflection_prompt)
        
        # 4. 如果质量不好（分数 < 3），重新检索或重新生成
        if "分数：3" in reflection or "分数：2" in reflection or "分数：1" in reflection:
            # 改写问题（让 LLM 改写）
            rewrite_prompt = f"请改写以下问题，让它能得到更好的答案：{user_question}"
            user_question = llm.generate(rewrite_prompt)
            continue  # 重新检索和生成
        else:
            return answer  # 质量好，返回答案
    
    return answer  # 重试次数用完，返回当前答案

面试加分回答

「Self-RAG 是 RAG 的进阶版，它在生成后自我反思（评估答案质量），如果不好就重新检索或重新生成。这是提升 RAG 答案质量的有效方法。另外，Self-RAG 的反思步骤很关键：怎么评估答案质量？——可以用 LLM 评估（让 LLM 打分），也可以用人工评估（让人类给答案打分）。」

Q15：RAG 如何做上下文压缩（Context Compression）？

一句话结论

上下文压缩是把检索到的长文档压缩成短文档（只保留和问题相关的部分），减少 Token 用量、提升生成质量。

深度解析

1. 为什么需要上下文压缩？

用大白话解释：

如果检索到的文档很长（比如 5000 字），但只有 100 字和问题相关，LLM 会浪费 Token 处理不相关的内容。

上下文压缩就是把长文档压缩成短文档（只保留和问题相关的部分）。

2. 上下文压缩的方法

方法	说明
LLM 压缩	让 LLM 压缩文档（”请删除不相关的内容”）
关键词提取	提取文档中的关键词（用 TF-IDF、TextRank）
句子筛选	计算句子和问题的相似度，只保留相关句子

3. 代码示例（LangChain）

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.llms import OpenAI

# 1. 基础检索器（检索 Top-10 相关文档）
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# 2. 上下文压缩器（用 LLM 压缩文档）
compressor = LLMChainExtractor.from_llm(llm=OpenAI(model="gpt-3.5-turbo"))

# 3. 创建上下文压缩检索器
compression_retriever = ContextualCompressionRetriever(
    base_retriever=base_retriever,
    base_compressor=compressor
)

# 4. 检索（会自动压缩文档）
compressed_docs = compression_retriever.get_relevant_documents("北京天气怎么样？")

面试加分回答

「上下文压缩是 RAG 的降本增效手段。实际项目中，如果检索到的文档很长，一定要做上下文压缩（减少 Token 用量、提升生成质量）。另外，LangChain 的 ContextualCompressionRetriever 已经实现了上下文压缩，直接用就行。」

Q16：RAG 如何做多轮对话（Multi-Turn Dialogue）？

一句话结论

多轮对话需要：1) 历史对话压缩（把历史对话压缩成摘要）；2) 查询改写（结合历史对话，改写当前问题）。

深度解析

1. 为什么需要多轮对话？

用大白话解释：

如果 RAG 系统不支持多轮对话，会出现这种情况：

用户：”北京天气怎么样？” → RAG 回答：”北京今天晴天，25 度”

用户：”上海呢？” → RAG 不知道”上海呢？”指的是”上海天气怎么样？”，会检索失败。

2. 多轮对话的解决方案

方案 1：历史对话压缩

from langchain.memory import ConversationBufferMemory

# 1. 保存历史对话
memory = ConversationBufferMemory(memory_key="chat_history")

# 2. 把历史对话压缩成摘要（用 LLM）
def compress_history(history: str) -> str:
    prompt = f"请把以下对话压缩成摘要：\n{history}"
    return llm.generate(prompt)

# 3. 检索时，把压缩后的历史对话也作为上下文
compressed_history = compress_history(memory.load_memory_variables({})["chat_history"])
retrieved_docs = retrieve("上海呢？", context=compressed_history)

方案 2：查询改写（Query Rewriting）

# 1. 把当前问题和历史对话拼接起来
def rewrite_query(current_query: str, history: str) -> str:
    prompt = f"""根据历史对话，改写当前问题：
    历史对话：{history}
    当前问题：{current_query}
    
    改写后的问题（包含上下文）："""
    return llm.generate(prompt)

# 2. 用改写后的问题检索
rewritten_query = rewrite_query("上海呢？", memory.load_memory_variables({})["chat_history"])
retrieved_docs = retrieve(rewritten_query)

面试加分回答

「多轮对话是 RAG 系统的必备功能。实际项目中，推荐用查询改写（Query Rewriting）——把当前问题和历史对话拼接起来，让 LLM 改写成完整问题（比如”上海呢？” → “上海天气怎么样？”），然后用改写后的问题检索。」

四、RAG 实战（17-20）

Q17：RAG 如何做 PDF 文档问答？

一句话结论

PDF 文档问答的流程：加载 PDF → 切分文档 → 向量化 → 存储 → 检索 → 生成答案。

深度解析

1. PDF 文档问答的流程

用户上传 PDF
   ↓
1. 加载 PDF（用 PyPDF2、Unstructured）
   ↓
2. 切分文档（按段落、按标题）
   ↓
3. 向量化（用 Embedding 模型）
   ↓
4. 存储（存入向量数据库）
   ↓
用户提问："PDF 里讲了什么？"
   ↓
5. 检索（把问题转成向量，查相关文档）
   ↓
6. 生成（LLM 根据检索到的文档回答问题）

2. 代码示例（LangChain）

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载 PDF
loader = PyPDFLoader("document.pdf")
documents = loader.load()

# 2. 切分文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
texts = text_splitter.split_documents(documents)

# 3. 向量化 + 存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# 4. 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(model="gpt-3.5-turbo"),
    retriever=vectorstore.as_retriever()
)

# 5. 提问
answer = qa_chain.run("PDF 里讲了什么？")
print(answer)

面试加分回答

「PDF 文档问答是 RAG 的最常用场景。实际项目中，PDF 加载要用 Unstructured（支持更复杂的 PDF，比如有表格、有图片），而不是 PyPDF2（只能读文字）。另外，PDF 切分时要注意表格和图片（不能切断表格和图片）。」

Q18：RAG 如何做网页问答？

一句话结论

网页问答的流程：爬取网页 → 提取正文 → 切分文档 → 向量化 → 存储 → 检索 → 生成答案。

深度解析

1. 网页问答的流程

用户给出网页 URL（比如 https://en.wikipedia.org/wiki/Artificial_intelligence）
   ↓
1. 爬取网页（用 requests、BeautifulSoup）
   ↓
2. 提取正文（去掉导航栏、广告、页脚）
   ↓
3. 切分文档（按段落、按标题）
   ↓
4. 向量化（用 Embedding 模型）
   ↓
5. 存储（存入向量数据库）
   ↓
用户提问："这个网页里讲了什么？"
   ↓
6. 检索（把问题转成向量，查相关文档）
   ↓
7. 生成（LLM 根据检索到的文档回答问题）

2. 代码示例（LangChain）

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载网页（自动提取正文）
loader = WebBaseLoader("https://en.wikipedia.org/wiki/Artificial_intelligence")
documents = loader.load()

# 2. 切分文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
texts = text_splitter.split_documents(documents)

# 3. 向量化 + 存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# 4. 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(model="gpt-3.5-turbo"),
    retriever=vectorstore.as_retriever()
)

# 5. 提问
answer = qa_chain.run("这个网页里讲了什么？")
print(answer)

面试加分回答

「网页问答是 RAG 的常用场景。实际项目中，网页加载要用 BeautifulSoup（可以指定 CSS 选择器，只提取正文），而不是 WebBaseLoader（会提取所有内容，包括导航栏、广告）。另外，网页问答要注意网页更新（如果网页更新了，要重新爬取、重新向量化）。」

Q19：RAG 如何做评估（Evaluation）？

一句话结论

RAG 评估分为：检索评估（检索到了吗？）和生成评估（答案对吗？）。

深度解析

1. 为什么需要评估？

用大白话解释：

如果 RAG 系统没有评估，你不知道它好不好用：

检索到了相关文档吗？（检索评估）

LLM 生成的答案对吗？（生成评估）

2. 检索评估（Retrieval Evaluation）

指标	说明
召回率（Recall@K）	Top-K 结果中有多少相关文档？（比如相关文档有 10 个，Top-10 结果中有 8 个，召回率 80%）
精确率（Precision@K）	Top-K 结果中有多少是相关的？（比如 Top-10 结果中有 8 个相关，精确率 80%）
MRR（Mean Reciprocal Rank）	第一个相关文档的排名的倒数（越高越好）

3. 生成评估（Generation Evaluation）

指标	说明
Faithfulness（忠实度）	答案是否基于检索到的文档？（防止幻觉）
Answer Relevance（答案相关性）	答案是否回答了问题？
Context Relevance（上下文相关性）	检索到的文档是否相关？

4. 代码示例（使用 RAGAS 评估框架）

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevance, context_relevance

# 1. 准备评估数据
eval_data = {
    "question": ["北京天气怎么样？"],
    "answer": ["北京今天晴天，气温 25 度"],
    "contexts": [["北京今天晴天，气温 25 度，空气质量良好"]]
}

# 2. 评估
results = evaluate(metrics=[faithfulness, answer_relevance, context_relevance], dataset=eval_data)
print(results)

面试加分回答

「RAG 评估是很容易被忽视的环节。检索评估用 Recall@K、Precision@K；生成评估用 Faithfulness、Answer Relevance。实际项目中，评估要持续进行（每次更新 RAG 系统，都要重新评估），确保 RAG 系统的性能没有下降。」

Q20：RAG 的最佳实践有哪些？

一句话结论

RAG 最佳实践：1) 用更好的 Embedding 模型；2) 优化文档切分；3) 用 Hybrid Search；4) 用 Rerank；5) 做好评估。

深度解析

1. 用更好的 Embedding 模型

见 Q3（什么是 Embedding？它为什么重要？）

2. 优化文档切分

见 Q5（RAG 中的文档切分（Chunking）策略有哪些？）

3. 用 Hybrid Search

见 Q9（什么是 Hybrid Search？为什么需要它？）

4. 用 Rerank

见 Q8（什么是 Rerank？为什么需要它？）

5. 做好评估

见 Q19（RAG 如何做评估？）

面试加分回答

「RAG 最佳实践：更好的 Embedding 模型 + 优化文档切分 + Hybrid Search + Rerank + 做好评估。另外，实际项目中，RAG 的Prompt 工程也很重要：怎么把检索到的文档拼接到 Prompt 中？——一般用 \n\nContext:\n{context}\n\nQuestion: {question}\nAnswer: 格式。」

五、RAG 高频面试题（21-25）

Q21：RAG 和 Fine-Tuning（微调）有什么区别？

一句话结论

RAG 是”外挂知识库”（不用训练模型），Fine-Tuning 是”内嵌知识”（需要训练模型）。

深度解析

1. RAG（外挂知识库）

用大白话解释：

RAG 就像开卷考试：

你可以带”小抄”（检索相关文档）

遇到问题时，先查”小抄”，再回答

2. Fine-Tuning（内嵌知识）

用大白话解释：

Fine-Tuning 就像背熟课本：

你把知识”背”到模型里（训练模型）

遇到问题时，直接回答（不用查资料）

3. 核心区别对比表

对比项	RAG	Fine-Tuning
成本	低（不用训练模型）	高（需要 GPU、需要标注数据）
知识更新	快（更新文档就行）	慢（需要重新训练）
效果	好（基于真实文档）	一般（可能过拟合）
适用场景	知识密集型任务（问答系统、客服机器人）	特定风格/特定领域（比如医疗、法律）

面试加分回答

「RAG 和 Fine-Tuning 不是互斥的，可以同时使用（RAG 负责查资料，Fine-Tuning 负责调整模型风格）。另外，实际项目中，RAG 适合知识密集型任务（比如问答系统、客服机器人），Fine-Tuning 适合特定风格/特定领域（比如医疗、法律）。」

Q22：RAG 的常见坑有哪些？

一句话结论

RAG 的常见坑：检索不到相关文档、检索到无关文档、LLM 不看上下文（直接回答）、成本失控。

深度解析

1. 检索不到相关文档

用大白话解释：

用户问”公司 2026 年的新产品是什么？”，但向量数据库中没有相关文档，RAG 检索不到。

解决方法：

补充文档（把公司 2026 年的新产品介绍加到向量数据库）
用更好的 Embedding 模型（提升检索精度）
用 Hybrid Search（向量检索 + 关键词检索）

2. 检索到无关文档

用大白话解释：

用户问”北京天气怎么样？”，但向量数据库中只有”上海天气”的文档，RAG 检索到无关文档（上海天气），LLM 根据错误文档回答。

解决方法：

用 Rerank（重排序，把最相关的文档排前面）
优化文档切分（让每块文档语义更完整）
限制检索数量（比如只取 Top-3，不取 Top-10）

3. LLM 不看上下文（直接回答）

用大白话解释：

RAG 检索到了相关文档，但 LLM 不看上下文，直接根据自己的训练数据回答（可能过时或错误）。

解决方法：

在 Prompt 中明确要求”请根据以下上下文回答问题，不要用自己的知识”
用”少样本学习”（Few-Shot），给几个示例（问题 + 上下文 + 答案）

4. 成本失控

用大白话解释：

RAG 每次都要把检索到的文档拼接到 Prompt 中，如果检索到很多文档，Prompt 会很长（Token 用量大，成本高）。

解决方法：

限制检索数量（比如只取 Top-3）
用便宜的模型（比如用 GPT-3.5 代替 GPT-4）

面试加分回答

「RAG 的常见坑：检索不到相关文档、检索到无关文档、LLM 不看上下文（直接回答）、成本失控。实际项目中，这些坑都要提前预防（比如用更好的 Embedding 模型、用 Rerank、限制检索数量、用便宜的模型）。另外，RAG 的可解释性也很重要（为什么检索到这个文档？能不能解释原因？）——如果 RAG 给出错误答案，你要能回溯原因。」

Q20：RAG 的高频面试题有哪些？

一句话结论

RAG 的高频面试题：1) 什么是 RAG？为什么重要？ 2) RAG 的工作流程是什么？ 3) 什么是 Embedding？ 4) 什么是向量数据库？ 5) 什么是 Rerank？ 6) 什么是 Hybrid Search？ 7) RAG 如何评估？ 8) RAG 的最佳实践有哪些？ 9) RAG 的常见坑有哪些？

深度解析

1. 高频面试题列表

问题	关键词
什么是 RAG？为什么重要？	检索增强生成、解决知识过时和幻觉
RAG 的工作流程是什么？	检索 → 增强 → 生成
什么是 Embedding？	文本转向量、语义相近向量也相近
什么是向量数据库？	存储向量、向量检索
什么是 Rerank？	重排序、提升检索精度
什么是 Hybrid Search？	向量检索 + 关键词检索
RAG 如何评估？	检索评估（Recall@K）、生成评估（Faithfulness）
RAG 的最佳实践有哪些？	更好的 Embedding、优化切分、Hybrid Search、Rerank、评估
RAG 的常见坑有哪些？	检索不到、检索到无关、LLM 不看上下文、成本失控

2. 面试准备建议

理解原理：知道 RAG 是什么、工作流程是什么、核心组件有哪些

会写代码：能用 LangChain 搭建一个简单的 RAG 系统（能加载文档、能检索、能生成答案）

知道坑点：知道 RAG 的常见坑（检索不到、检索到无关、LLM 不看上下文）以及如何解决

关注前沿：知道 RAG 的最新进展（Corrective RAG、Self-RAG、上下文压缩）

面试加分回答

「RAG 是 2023 年最热门的 LLM 应用架构（各种 RAG 框架层出不穷）。面试中，除了上面的高频问题，还可能问：RAG 和 Fine-Tuning 有什么区别？、RAG 的未来发展趋势是什么？。另外，实际项目中，RAG 的应用场景很广（客服机器人、企业知识库、问答系统），可以结合自己的项目经验来回答。」

Q21：RAG 的未来发展趋势是什么？

一句话结论

RAG 的未来：更准（更好的 Embedding、Rerank）、更快（更高效的检索）、更省（更低的成本）。

深度解析

1. 更准（更好的 Embedding、Rerank）

更好的 Embedding 模型：M3E、BGE、GTE 等中文 Embedding 模型效果越来越好

更好的 Rerank 模型：Cross-Encoder 效果越来越好，成本也越来越低

2. 更快（更高效的检索）

向量索引优化：HNSW、IVF 等向量索引算法越来越高效

混合检索优化：Hybrid Search（向量检索 + 关键词检索）效果越来越好

3. 更省（更低的成本）

开源模型：M3E、BGE 等开源 Embedding 模型成本比 OpenAI 低 100 倍

模型压缩：把大模型压缩成小模型（成本更低，速度更快）

面试加分回答

「RAG 的未来发展趋势：更准、更快、更省。实际项目中，现在已经是 RAG 的时代（各种 RAG 框架层出不穷：LangChain、RAGAS、AI模型-Index）。另外，RAG 的应用场景也会越来越广（从”企业知识库”到”个人知识库”）。」

Q22：RAG 的开源框架有哪些？

一句话结论

RAG 的开源框架：LangChain（最流行）、RAGAS（RAG 评估框架）、AI模型-Index（数据框架）、Haystack（老牌框架）。

深度解析

1. LangChain（最流行）

# LangChain 示例（见 Q2）
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载文档
documents = ["公司 2026 年的新产品是 XXX..."]

# 2. 向量化
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_texts(documents, embeddings)

# 3. 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(model="gpt-4"),
    retriever=vectorstore.as_retriever()
)

# 4. 提问
answer = qa_chain.run("公司 2026 年的新产品是什么？")

2. RAGAS（RAG 评估框架）

# RAGAS 示例（见 Q10）
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevance, context_relevance

# 评估 RAG 系统
metrics = [faithfulness, answer_relevance, context_relevance]
results = evaluate(metrics=metrics, dataset=eval_data)

3. AI模型-Index（数据框架）

# AI模型-Index 示例
from llama_index import VectorStoreIndex, SimpleDirectoryReader

# 1. 加载文档
documents = SimpleDirectoryReader("data").load_data()

# 2. 创建索引
index = VectorStoreIndex.from_documents(documents)

# 3. 提问
query_engine = index.as_query_engine()
response = query_engine.query("公司 2026 年的新产品是什么？")

4. Haystack（老牌框架）

# Haystack 示例
from haystack import Pipeline
from haystack.nodes import BM25Retriever, EmbeddingRetriever, FARMReader

# 1. 创建流水线
pipeline = Pipeline()
pipeline.add_node(BM25Retriever(...), name="BM25Retriever", inputs=["Query"])
pipeline.add_node(EmbeddingRetriever(...), name="EmbeddingRetriever", inputs=["Query"])
pipeline.add_node(FARMReader(...), name="Reader", inputs=["BM25Retriever", "EmbeddingRetriever"])

# 2. 提问
result = pipeline.run(query="公司 2026 年的新产品是什么？")

面试加分回答

「RAG 的开源框架：LangChain（最流行，适合新手）、RAGAS（RAG 评估框架，适合评估 RAG 系统）、AI模型-Index（数据框架，适合处理复杂数据结构）、Haystack（老牌框架，适合生产环境）。实际项目中，推荐用 LangChain（生态最完善，文档最详细）。另外，现在还有很多 RAG 平台（比如 Dify、Coze），不用写代码就能搭建 RAG 系统，很方便。」

Q23：RAG 和 Agent 有什么区别？

一句话结论

RAG 是”检索增强生成”（让 LLM 能查资料），Agent 是”能调用工具的 AI”（让 LLM 能动手）。

深度解析

1. RAG（检索增强生成）是什么？

用大白话解释：

RAG 就像给 LLM 配了一个”图书管理员”：

你问它：”公司 2026 年的新产品是什么？”

图书管理员（检索）帮你找到相关资料

LLM（生成）根据资料回答问题

2. Agent（能调用工具的 AI）是什么？

用大白话解释：

Agent 就像给 LLM 配了”各种工具”：

你问它：”北京天气怎么样？”

LLM（思考）决定调用”天气 API”工具

工具（行动）返回结果

LLM（生成）根据结果回答

3. 核心区别对比表

对比项	RAG	Agent
核心能力	检索资料（增强 LLM 的知识）	调用工具（让 LLM 能动手）
适用场景	知识密集型任务（问答系统、客服机器人）	需要动手的任务（查天气、算数学、执行代码）
是否需要工具	❌ 不需要（只检索文档）	✅ 需要（要调用各种工具）

面试加分回答

「RAG 和 Agent 的区别：RAG 是”检索增强生成”（让 LLM 能查资料），Agent 是”能调用工具的 AI”（让 LLM 能动手）。实际项目中，RAG 和 Agent 可以结合（RAG 负责查资料，Agent 负责调用工具）。比如：Agent 先调用 RAG 工具查资料，然后根据资料回答问题。」

Q24：RAG 和 Long-Context LLM（长上下文 LLM）有什么区别？

一句话结论

RAG 是”外挂知识库”（只检索相关文档），Long-Context LLM 是”内嵌知识库”（把所有文档都塞进上下文）。

深度解析

1. RAG（外挂知识库）是什么？

用大白话解释：

RAG 就像开卷考试：

你带了很多”小抄”（文档）

但考试时（回答问题），你只看一下”小抄”（只检索相关文档）

优点：成本低（不用把所有文档都塞进上下文）

缺点：可能检索不到（漏掉相关文档）

2. Long-Context LLM（长上下文 LLM）是什么？

用大白话解释：

Long-Context LLM 就像闭卷考试（但你能背下整本书）：

你把整本书（所有文档）都背下来（塞进上下文）

考试时（回答问题），你回想整本书（用整个上下文回答问题）

优点：不会漏掉相关文档（因为所有文档都在上下文里）

缺点：成本很高（所有文档都塞进上下文，Token 用量很大）

3. 核心区别对比表

对比项	RAG	Long-Context LLM
知识来源	外挂知识库（检索相关文档）	内嵌知识库（所有文档都塞进上下文）
成本	低（只检索相关文档）	高（所有文档都塞进上下文）
准确率	一般（可能检索不到）	高（所有文档都在上下文里）
适用场景	知识库很大（比如 100 万篇文档）	知识库很小（比如 100 篇文档）

面试加分回答

「RAG 和 Long-Context LLM 的区别：RAG 是”外挂知识库”，Long-Context LLM 是”内嵌知识库”。实际项目中，推荐用 RAG（成本低，适合知识库很大的场景）。另外，现在有些 LLM 的上下文长度已经很大了（比如 Claude 3 是 200K tokens），如果知识库很小（比如 100 篇文档），可以直接用 Long-Context LLM（不用搭建 RAG 系统）。」

Q25：RAG 的生产环境部署怎么做？

一句话结论

RAG 的生产环境部署：用 API 封装（FastAPI）+ 做好权限控制 + 做好日志记录 + 做好监控告警。

深度解析

1. 为什么需要部署到生产环境？

用大白话解释：

如果你只是在本地跑 RAG 系统（比如用 Python 脚本），别人用不了。

部署到生产环境，就是把 RAG 系统变成 API（别人可以通过 HTTP 请求调用你的 RAG 系统）。

2. 部署架构

用户（前端/其他系统）
   ↓ HTTP 请求
API 网关（FastAPI / Flask）
   ↓
RAG 系统（核心逻辑）
   ↓
向量数据库（Chroma / Pinecone）
   ↓
LLM API（OpenAI / Claude）

3. 代码示例（FastAPI 封装 RAG 系统）

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

# 定义请求体
class RAGRequest(BaseModel):
    question: str

# 定义 API 端点
@app.post("/rag")
def call_rag(request: RAGRequest):
    try:
        # 调用 RAG 系统
        answer = rag_system.run(request.question)
        return {"answer": answer}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# 启动 API（uvicorn main:app --host 0.0.0.0 --port 8000）

4. 生产环境必备条件

条件	说明
API 封装	用 FastAPI / Flask 封装 RAG 系统，提供 HTTP 接口
权限控制	用 API Key 或 OAuth 2.0 控制访问权限
日志记录	记录每次请求（问题、答案、耗时、Token 用量）
监控告警	监控 API 可用性、延迟、错误率，异常时告警
限流	限制每个用户的请求频率（防止 API 被刷爆）

面试加分回答

「RAG 的生产环境部署，API 封装只是第一步。更重要的是：权限控制（防止别人滥用你的 API）、日志记录（方便调试和审计）、监控告警（API 挂了能及时知道）、限流（防止 API 被刷爆）。另外，如果 RAG 系统用的人多，还要考虑扩容（用 K8s 做容器编排，自动扩容）。」

RAG 面试总结：
本文从 RAG 基础、进阶、实战、最佳实践、高频面试题五个方面，全面覆盖了 RAG 面试的核心考点（25 道题）。认真看完本文，RAG 面试不再慌！

建议你按以下顺序复习：

RAG 基础（什么是 RAG？为什么重要？工作流程是什么？）

Embedding（什么是 Embedding？为什么重要？常用模型有哪些？）

向量数据库（什么是向量数据库？常用向量数据库有哪些？）

RAG 进阶（文档切分、向量检索、Rerank、Hybrid Search）

RAG 评估（检索评估、生成评估）

RAG 最佳实践（更好的 Embedding、优化切分、Hybrid Search、Rerank、评估）

RAG 常见坑（检索不到、检索到无关、LLM 不看上下文、成本失控）

祝你面试顺利！🚀

Q26：RAG 的高频面试题有哪些？

一句话结论

RAG 的高频面试题：1) 什么是 RAG？为什么重要？ 2) RAG 的工作流程是什么？ 3) 什么是 Embedding？ 4) 什么是向量数据库？ 5) 什么是 Rerank？ 6) 什么是 Hybrid Search？ 7) RAG 如何评估？ 8) RAG 的最佳实践有哪些？ 9) RAG 的常见坑有哪些？

深度解析

1. 高频面试题列表

问题	关键词
什么是 RAG？为什么重要？	检索增强生成、解决知识过时和幻觉
RAG 的工作流程是什么？	检索 → 增强 → 生成
什么是 Embedding？	文本转向量、语义相近向量也相近
什么是向量数据库？	存储向量、向量检索
什么是 Rerank？	重排序、提升检索精度
什么是 Hybrid Search？	向量检索 + 关键词检索
RAG 如何评估？	检索评估（Recall@K）、生成评估（Faithfulness）
RAG 的最佳实践有哪些？	更好的 Embedding、优化切分、Hybrid Search、Rerank、评估
RAG 的常见坑有哪些？	检索不到、检索到无关、LLM 不看上下文、成本失控

2. 面试准备建议

理解原理：知道 RAG 是什么、工作流程是什么、核心组件有哪些

会写代码：能用 LangChain 搭建一个简单的 RAG 系统（能加载文档、能检索、能生成答案）

知道坑点：知道 RAG 的常见坑（检索不到、检索到无关、LLM 不看上下文）以及如何解决

关注前沿：知道 RAG 的最新进展（Corrective RAG、Self-RAG、上下文压缩）

面试加分回答

「RAG 是 2023 年最热门的 LLM 应用架构（各种 RAG 框架层出不穷）。面试中，除了上面的高频问题，还可能问：RAG 和 Fine-Tuning 有什么区别？、RAG 的未来发展趋势是什么？。另外，实际项目中，RAG 的应用场景很广（客服机器人、企业知识库、问答系统），可以结合自己的项目经验来回答。」

Q27：RAG 和 Fine-Tuning（微调）有什么区别？

一句话结论

RAG = 外挂知识库（不用训练模型）；Fine-Tuning = 内嵌知识（需要训练模型）。

深度解析

1. RAG（外挂知识库）是什么？

用大白话解释：

RAG 就像开卷考试：

你可以带”小抄”（检索相关文档）

遇到问题时，先查”小抄”，再回答

2. Fine-Tuning（内嵌知识）是什么？

用大白话解释：

Fine-Tuning 就像背熟课本：

你把知识”背”到模型里（训练模型）

遇到问题时，直接回答（不用查资料）

3. 核心区别对比表

对比项	RAG	Fine-Tuning
成本	低（不用训练模型）	高（需要 GPU、需要标注数据）
知识更新	快（更新文档就行）	慢（需要重新训练）
效果	好（基于真实文档）	一般（可能过拟合）
适用场景	知识密集型任务（问答系统、客服机器人）	特定风格/特定领域（比如医疗、法律）

面试加分回答

「RAG 和 Fine-Tuning 不是互斥的，可以同时使用（RAG 负责查资料，Fine-Tuning 负责调整模型风格）。另外，实际项目中，RAG 适合知识密集型任务（比如问答系统、客服机器人），Fine-Tuning 适合特定风格/特定领域（比如医疗、法律）。」

Q28：RAG 的未来发展趋势是什么？

一句话结论

RAG 的未来：更准（更好的 Embedding、Rerank）、更快（更高效的检索）、更省（更低的成本）。

深度解析

1. 更准（更好的 Embedding、Rerank）

更好的 Embedding 模型：M3E、BGE、GTE 等中文 Embedding 模型效果越来越好

更好的 Rerank 模型：Cross-Encoder 效果越来越好，成本也越来越低

2. 更快（更高效的检索）

向量索引优化：HNSW、IVF 等向量索引算法越来越高效

混合检索优化：Hybrid Search（向量检索 + 关键词检索）效果越来越好

3. 更省（更低的成本）

开源模型：M3E、BGE 等开源 Embedding 模型成本比 OpenAI 低 100 倍

模型压缩：把大模型压缩成小模型（成本更低，速度更快）

面试加分回答

「RAG 的未来发展趋势：更准、更快、更省。实际项目中，现在已经是 RAG 的时代（各种 RAG 框架层出不穷：LangChain、LlamaIndex、Haystack）。另外，RAG 的应用场景也会越来越广（从”企业知识库”到”个人知识库”）。」

Q29：RAG 的开源框架有哪些？

一句话结论

RAG 的开源框架：LangChain（最流行）、LlamaIndex（数据框架）、Haystack（老牌框架）、RAGAS（RAG 评估框架）。

深度解析

1. LangChain（最流行）

# LangChain 示例（见 Q2）
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载文档
documents = ["公司 2026 年的新产品是 XXX..."]

# 2. 向量化
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_texts(documents, embeddings)

# 3. 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(model="gpt-4"),
    retriever=vectorstore.as_retriever()
)

# 4. 提问
answer = qa_chain.run("公司 2026 年的新产品是什么？")

2. LlamaIndex（数据框架）

# LlamaIndex 示例（见 Q2）
from llama_index import VectorStoreIndex, SimpleDirectoryReader

# 1. 加载文档
documents = SimpleDirectoryReader("data").load_data()

# 2. 创建索引
index = VectorStoreIndex.from_documents(documents)

# 3. 提问
query_engine = index.as_query_engine()
response = query_engine.query("公司 2026 年的新产品是什么？")

3. Haystack（老牌框架）

# Haystack 示例（见 Q22）
from haystack import Pipeline
from haystack.nodes import BM25Retriever, EmbeddingRetriever, FARMReader

# 1. 创建流水线
pipeline = Pipeline()
pipeline.add_node(BM25Retriever(...), name="BM25Retriever", inputs=["Query"])
pipeline.add_node(EmbeddingRetriever(...), name="EmbeddingRetriever", inputs=["Query"])
pipeline.add_node(FARMReader(...), name="Reader", inputs=["BM25Retriever", "EmbeddingRetriever"])

# 2. 提问
result = pipeline.run(query="公司 2026 年的新产品是什么？")

4. RAGAS（RAG 评估框架）

# RAGAS 示例（见 Q10）
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevance, context_relevance

# 评估 RAG 系统
metrics = [faithfulness, answer_relevance, context_relevance]
results = evaluate(metrics=metrics, dataset=eval_data)

面试加分回答

「RAG 的开源框架：LangChain（最流行，适合新手）、LlamaIndex（数据框架，适合处理复杂数据结构）、Haystack（老牌框架，适合生产环境）、RAGAS（RAG 评估框架，适合评估 RAG 系统）。实际项目中，推荐用 LangChain（生态最完善，文档最详细）。另外，现在还有很多 RAG 平台（比如 Dify、Coze），不用写代码就能搭建 RAG 系统，很方便。」

Q30：RAG 的实际应用场景有哪些？

一句话结论

RAG 的实际应用场景：客服机器人、企业知识库、问答系统、文档摘要、代码助手。

深度解析

1. 客服机器人

场景：用户问”公司的退货政策是什么？”

RAG 流程：检索退货政策文档 → 生成答案

优点：答案基于真实文档（不会幻觉），知识更新快（更新文档就行）

2. 企业知识库

场景：员工问”公司的报销流程是什么？”

RAG 流程：检索报销流程文档 → 生成答案

优点：答案基于真实文档（不会幻觉），知识更新快（更新文档就行）

3. 问答系统

场景：用户问”什么是 RAG？”

RAG 流程：检索 RAG 相关文档 → 生成答案

优点：答案基于真实文档（不会幻觉），知识更新快（更新文档就行）

4. 文档摘要

场景：用户问”这个 PDF 里讲了什么？”

RAG 流程：检索 PDF 相关段落 → 生成摘要

优点：摘要基于真实文档（不会幻觉），可以处理长文档

5. 代码助手

场景：用户问”这个函数是什么意思？”

RAG 流程：检索代码库相关代码 → 生成解释

优点：解释基于真实代码（不会幻觉），可以处理大型代码库

面试加分回答

「RAG 的实际应用场景很广（客服机器人、企业知识库、问答系统、文档摘要、代码助手）。实际项目中，RAG 的核心价值是：1) 解决 LLM 的知识过时问题；2) 解决 LLM 的幻觉问题；3) 知识更新快（更新文档就行）。另外，RAG 的成本比 Fine-Tuning 低很多（不用训练模型），适合中小企业。」

RAG 面试总结：
本文从 RAG 基础、进阶、实战、最佳实践、高频面试题五个方面，全面覆盖了 RAG 面试的核心考点（30 道题）。认真看完本文，RAG 面试不再慌！

建议你按以下顺序复习：

RAG 基础（什么是 RAG？为什么重要？工作流程是什么？）

Embedding（什么是 Embedding？为什么重要？常用模型有哪些？）

向量数据库（什么是向量数据库？常用向量数据库有哪些？）

RAG 进阶（文档切分、向量检索、Rerank、Hybrid Search）

RAG 实战（PDF 文档问答、网页问答、多轮对话）

RAG 评估（检索评估、生成评估）

RAG 最佳实践（更好的 Embedding、优化切分、Hybrid Search、Rerank、评估）

RAG 常见坑（检索不到、检索到无关、LLM 不看上下文、成本失控）

祝你面试顺利！🚀

📚 学习路径总结

恭喜你！如果你认真学完了上面的所有内容，那么你已经掌握了 RAG 的核心知识。下面是一些学习建议，帮助你进一步深入学习。

1. 夯实基础（1-2 周）

深入理解 RAG 的基本原理
理解 Embedding 的原理
理解向量数据库的原理

2. 动手实践（2-3 周）

用 LangChain 搭建一个简单的 RAG 系统
用 LlamaIndex 搭建一个 RAG 系统
尝试不同的文档切分策略

3. 阅读论文（3-4 周）

阅读 RAG 原始论文
阅读 Self-RAG 论文
阅读 Corrective RAG 论文

4. 学习高级技术（2-3 周）

理解 Hybrid Search
理解 Rerank
理解上下文压缩

5. 做项目（持续）

做一个文档问答系统
做一个客服机器人
做一个知识库问答系统

🎓 进阶学习

如果你已经掌握了 RAG 的基础知识，那么可以学习以下内容：

1. RAG 评估

学习 RAGAs 框架
理解各种评估指标

2. RAG 优化

学习如何优化检索质量
学习如何优化生成质量

3. RAG 部署

学习如何部署 RAG 系统到生产环境
学习如何监控 RAG 系统的性能

💪 最后的建议

不要急于求成，要打好基础
多写代码，光看不练是没用的
看论文，理解 RAG 的最新进展
做项目，在实际项目中应用 RAG
教别人，教是最好的学

祝你学习顺利！🎉

技术面试

#RAG #面试 #八股文 #检索增强生成 #向量数据库

RAG 面试八股文 30 道｜深度详解版（傻子都能看懂）

https://whyalwaysme.lol/2026/06/09/2026-06-09-rag-interview-deep/

作者

Cassiur

发布于

2026年6月9日

许可协议

Harness Engineering 面试八股文 30 道｜深度详解版（傻子都能看懂）上一篇

RabbitMQ 面试八股文（30题）下一篇