RAG 技术深度解析：低成本替代微调实现 AI 升级

一、大语言模型（LLM）的三大痛点

1.1 幻觉问题：一本正经地胡说八道

大模型的文本生成基于概率预测，它并不真正理解语义的正确性。通俗来说，就像学生遇到不会的题目凭记忆瞎蒙答案，虽然看起来像模像样，但实际上可能完全错误。

比如当你问 AI'太阳为什么从西边升起？'，它可能会解释'因为地球自转方向发生了改变'，而实际上太阳根本不会从西边升起。这种幻觉在关键业务中是致命的。

from transformers import pipeline

generator = pipeline('text-generation', model='gpt2')
result = generator("太阳为什么从西边升起？", max_length=100, num_return_sequences=1)
print(result[0]['generated_text'])

1.2 时效性问题：知识更新不及时

大型语言模型的训练成本极高且周期长，导致实时数据无法及时参与训练。这就好比一个只会背诵五年前课本知识的学生，无法回答最新的科技进展或热点事件。

例如在 2026 年问 AI'2026 年的春节是哪一天？'，如果训练数据截止到 2023 年，它大概率无法给出正确答案。此时需要结合外部实时数据源。

from datetime import datetime
import requests

def get_current_time():
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def get_latest_news():
    response = requests.get("https://newsapi.org/v2/top-headlines?country=cn&apiKey=YOUR_API_KEY")
    return response.json()

print(f"当前时间：{get_current_time()}")
print(f"最新新闻：{get_latest_news()}")

1.3 数据安全问题：敏感信息泄露风险

通用 LLM 没有企业内部数据，企业若将敏感数据直接输入公共模型存在泄露风险。最好的方式是将数据放在本地处理，仅让在线大模型完成归纳功能。

就像你不会把公司机密文件交给陌生人保管，而是自己妥善保存，只在需要时让人帮忙整理。银行通常先在本地脱敏账户信息，再将结果发送给 LLM 分析。

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# 本地处理敏感数据
def process_sensitive_data(data):
    # 脱敏处理
    return data.replace("敏感信息", "***")

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建 Prompt 模板
prompt = PromptTemplate(
    input_variables=["data"], 
    template="分析以下数据：{data}"
)

# 创建 LLM Chain
chain = LLMChain(llm=llm, prompt=prompt)

# 处理敏感数据
sensitive_data = "用户的敏感信息：1234567890"
processed_data = process_sensitive_data(sensitive_data)

# 调用 LLM 进行分析
result = chain.run(processed_data)
print(result)

二、RAG 技术：检索增强生成

2.1 RAG 的定义

RAG（Retrieval-Augmented Generation，检索增强生成）是指 LLM 在回答问题前，先从大量文档中检索出相关信息，再基于这些信息生成回答。这就像学生考试时可以查阅课本资料，而不是仅凭记忆瞎蒙，从而显著提高预测质量。

例如问'如何做红烧肉？'，RAG 会先检索菜谱文档，再生成详细做法。

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

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["红烧肉的做法：1. 准备食材..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何做红烧肉？")
print(result)

2.2 RAG 的架构

RAG 主要包含两个核心模块：检索器（R）和生成器（G）。

2.2.1 检索器模块

检索器的作用是从知识库中找出最相关的 k 个文档。构建高质量检索器需解决三个关键问题：如何获得准确的语义表示？如何协调查询和文档的语义空间？如何对齐检索模型的输出和大语言模型的偏好？

这就像图书馆管理员，能根据读者需求快速找到相关书籍。当你在搜索引擎输入'如何学习 Python'时，引擎会从海量网页中找到最相关的资源。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 创建向量数据库
documents = ["Python 学习资源 1...", "Python 学习资源 2...", "Python 学习资源 3..."]
db = FAISS.from_texts(documents, embeddings)

# 检索相关文档
query = "如何学习 Python"
docs = db.similarity_search(query, k=2)
for doc in docs:
    print(doc.page_content)

2.2.2 生成器模块

生成器负责将检索到的信息转化为自然流畅的文本。其输入不仅包括上下文，还有检索到的相关片段，使回答更准确丰富。

就像作家写文章参考资料一样，当你在写论文时，会先查阅文献，再基于资料写出内容。

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建 Prompt 模板
prompt = PromptTemplate(
    input_variables=["context", "question"], 
    template="基于以下上下文回答问题：\n{context}\n\n问题：{question}"
)

# 检索到的上下文
context = "Python 是一种高级编程语言，易于学习和使用。"

# 提问
question = "Python 是什么？"

# 生成回答
result = llm(prompt.format(context=context, question=question))
print(result)

三、使用 RAG 的八大优势

3.1 可扩展性：减少模型大小和训练成本

RAG 方法无需为每个特定任务重新训练整个大模型，只需外挂知识库即可提供额外信息输入。这就像给普通电脑外接移动硬盘增加容量，而不必更换整机。企业可将内部知识库与通用 LLM 结合，避免专有模型训练的高昂成本。

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

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
# 加载企业内部知识库
db = FAISS.load_local("enterprise_knowledge_base", embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("公司的请假政策是什么？")
print(result)

3.2 准确性：通过引用信息来源增强信任

通过引用信息来源，用户可以核实答案准确性，增强对模型输出的信任。就像老师批改作业时，若学生引用了课本内容，会更相信答案正确性。

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建 Prompt 模板
prompt = PromptTemplate(
    input_variables=["context", "question"], 
    template="基于以下上下文回答问题，并引用信息来源：\n{context}\n\n问题：{question}"
)

# 检索到的上下文
context = "根据《Python 编程从入门到精通》一书，Python 是一种高级编程语言，易于学习和使用。"

# 提问
question = "Python 是什么？"

# 生成回答
result = llm(prompt.format(context=context, question=question))
print(result)

3.3 可控性：允许更新或定制知识

RAG 允许开发者轻松更新或定制知识库，无需重新训练大模型。就像随时更新手机 APP 而不必换手机，企业可定期更新内部知识库，使 LLM 能回答最新政策和业务问题。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 创建向量数据库
documents = ["公司的请假政策是：病假需要提供医院证明..."]
db = FAISS.from_texts(documents, embeddings)

# 更新知识库
new_document = "公司的请假政策已更新：病假需要提供三甲医院证明..."
db.add_texts([new_document])

# 检索相关文档
query = "公司的请假政策是什么？"
docs = db.similarity_search(query, k=1)
print(docs[0].page_content)

3.4 可解释性：检索到的项目作为模型预测中来源的参考

RAG 系统通过将响应生成分解为不同阶段来提供透明度，展示数据检索匹配度以提高信任。就像法官判决案件时会引用法律条文，搜索引擎也会显示结果来源链接供用户查看原始文档。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQAWithSourcesChain
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts([{"content":"Python 是一种高级编程语言，易于学习和使用。","metadata":{"source":"《Python 编程从入门到精通》"}}], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain({"question": "Python 是什么？"})
print(f"回答：{result['answer']}")
print(f"来源：{result['sources']}")

3.5 多功能性：适用于多种任务

RAG 可针对多种任务进行定制，包括 QA、文本摘要、对话系统等。就像瑞士军刀可用于切割、开瓶等，RAG 可应用于智能客服、文档问答、知识图谱等领域。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains.summarize import load_summarize_chain
from langchain.llms import OpenAI
from langchain.text_splitter import CharacterTextSplitter

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载文档
with open("example.txt", "r", encoding="utf-8") as f:
    text = f.read()

# 分割文本
text_splitter = CharacterTextSplitter()
texts = text_splitter.split_text(text)

# 创建向量数据库
db = FAISS.from_texts(texts, embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建摘要链
chain = load_summarize_chain(llm, chain_type="map_reduce")

# 检索相关文档
query = "本文的主要内容是什么？"
docs = db.similarity_search(query, k=5)

# 生成摘要
result = chain.run(documents=docs)
print(result)

3.6 及时性：识别最新的信息

使用检索技术能识别最新信息，相比只依赖训练数据的传统模型有明显优势。就像随时通过手机获取新闻资讯，RAG 可检索最新日历数据给出正确日期。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
import requests

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载最新的日历数据
response = requests.get("https://api.example.com/calendar/2026")
calendar_data = response.json()

# 创建向量数据库
db = FAISS.from_texts([str(calendar_data)], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("2026 年的春节是哪一天？")
print(result)

3.7 定制性：为不同领域提供专业的知识支持

通过索引特定领域语料库，RAG 能为医疗、法律、金融等领域提供专业支持。就像专业医生针对不同疾病提供治疗方案，RAG 可针对垂直领域优化。

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

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载医疗知识库
with open("medical_knowledge_base.txt", "r", encoding="utf-8") as f:
    medical_data = f.read()

# 创建向量数据库
db = FAISS.from_texts([medical_data], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何治疗感冒？")
print(result)

3.8 安全性：更好地控制数据使用

RAG 通过数据库中设置的角色和安全控制，实现对数据使用的更好控制。相比之下，微调模型在管理数据访问权限方面可能不够明确。就像保险箱只有钥匙持有者才能打开，企业可将敏感数据存于本地数据库，通过权限限制访问。

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

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 加载敏感数据
with open("sensitive_data.txt", "r", encoding="utf-8") as f:
    sensitive_data = f.read()

# 创建向量数据库
db = FAISS.from_texts([sensitive_data], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 设置访问权限
access_control = {"admin": True, "user": False}

# 检查访问权限
user_role = "admin"
if access_control[user_role]:
    result = qa_chain.run("敏感数据是什么？")
    print(result)
else:
    print("您没有访问权限。")

四、RAG 与 SFT 的对比

	RAG	SFT
数据类型	动态数据，不断查询外部源，确保信息保持最新，无需频繁重训。	（相对）静态数据，动态场景中易过时，不能保证记住新知识。
外部知识利用	擅长利用外部资源，在生成前检索相关信息增强能力，适合文档库。	可对 LLM 微调以对齐预训练知识，但对频繁更改的数据源不实用。
模型定制	关注信息检索，整合外部知识，但难以完全定制行为或写作风格。	允许调整 LLM 行为、风格或特定领域知识。
减少幻觉	基于检索证据回答，本质上不易产生幻觉。	可减少幻觉，但面对不熟悉输入仍可能产生幻觉。
透明度	分解响应生成阶段，提供数据检索匹配度，提高信任。	黑匣子模式，推理过程不透明。
技术要求	需高效检索策略、大型数据库技术及外部数据集成。	需准备高质量数据集、定义微调目标及计算资源。

RAG 和 SFT 是两种不同的大模型增强技术。RAG 像会查资料的助手，能快速找到信息；SFT 像经过特殊训练的专家，能提供特定领域回答。当你需要回答最新科技进展问题时，RAG 会检索最新新闻，而 SFT 可能因训练数据滞后而过时。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from transformers import pipeline

# RAG 示例
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["最新科技进展：GPT-5 发布..."], embeddings)
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)
rag_result = qa_chain.run("最新的科技进展是什么？")
print(f"RAG 回答：{rag_result}")

# SFT 示例
sft_model = pipeline('text-generation', model='fine_tuned_model')
sft_result = sft_model("最新的科技进展是什么？", max_length=100, num_return_sequences=1)
print(f"SFT 回答：{sft_result[0]['generated_text']}")

五、RAG 的典型实现方法

5.1 数据索引

数据索引是离线过程，将私域数据向量化后构建索引存入数据库。主要包括数据提取、文本分割、向量化（embedding）及创建索引等环节。就像图书管理员分类建立索引，方便读者快速找书。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
import PyPDF2

# 提取 PDF 文本
def extract_text_from_pdf(pdf_path):
    text = ""
    with open(pdf_path, "rb") as f:
        reader = PyPDF2.PdfReader(f)
        for page in reader.pages:
            text += page.extract_text()
    return text

# 分割文本
text_splitter = CharacterTextSplitter()

# 向量化
embeddings = OpenAIEmbeddings()

# 创建索引
def create_index(pdf_path):
    text = extract_text_from_pdf(pdf_path)
    texts = text_splitter.split_text(text)
    db = FAISS.from_texts(texts, embeddings)
    db.save_local("pdf_index")

# 创建 PDF 索引
create_index("example.pdf")

5.2 数据检索

数据检索是获取有效信息的关键环节，包括元数据过滤、图关系检索、向量化相似度检索等方式。就像搜索引擎输入关键词找到相关结果。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 加载索引
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("pdf_index", embeddings)

# 检索
query = "Python 学习教程"
docs = db.similarity_search(query, k=3)
for doc in docs:
    print(doc.page_content)

5.3 文本生成

文本生成是将原始 query 和检索文本组合输入模型的过程，本质上是 Prompt Engineering。就像写作文先收集资料再动笔。

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

# 加载索引
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("pdf_index", embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何学习 Python？")
print(result)

六、RAG 的典型案例

6.1 ChatPDF 及其复刻版

ChatPDF 是基于 RAG 的在线工具，允许上传 PDF 并通过聊天提问。它会先将 PDF 转为文本，使用 Embeddings API 转换为向量，再基于向量回答问题。就像可以和 PDF 文件聊天，询问内容而不必手动翻阅。

import requests
import PyPDF2
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 提取 PDF 文本
def extract_text_from_pdf(pdf_path):
    text = ""
    with open(pdf_path, "rb") as f:
        reader = PyPDF2.PdfReader(f)
        for page in reader.pages:
            text += page.extract_text()
    return text

# 创建索引
def create_chat_pdf(pdf_path):
    text = extract_text_from_pdf(pdf_path)
    embeddings = OpenAIEmbeddings()
    db = FAISS.from_texts([text], embeddings)
    db.save_local("chat_pdf_index")

# 提问
def chat_with_pdf(question):
    embeddings = OpenAIEmbeddings()
    db = FAISS.load_local("chat_pdf_index", embeddings)
    llm = OpenAI(temperature=0)
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm, 
        chain_type="stuff", 
        retriever=db.as_retriever()
    )
    result = qa_chain.run(question)
    return result

# 创建 ChatPDF 索引
create_chat_pdf("example.pdf")

# 提问
answer = chat_with_pdf("本文的主要内容是什么？")
print(answer)

6.2 Baichuan

Baichuan 是基于 RAG 的大模型搜索增强系统，融合了指令意图理解、智能搜索和结果增强模块，实现了更精确的回答，减少了幻觉。就像一个智能搜索引擎，理解搜索意图并提供准确结果。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["红烧肉的做法：1. 准备食材..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建 Prompt 模板
prompt = PromptTemplate(
    input_variables=["context", "question"], 
    template="理解用户意图：{question}\n基于以下上下文回答问题：{context}\n\n问题：{question}"
)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever(), 
    chain_type_kwargs={"prompt": prompt}
)

# 提问
result = qa_chain.run("如何做红烧肉？")
print(result)

6.3 Multi-modal retrieval-based LMs

RA-CM3 是一个检索增强的多模态模型，包含信息检索框架从外部存储库获取知识。作者使用预训练 CLIP 模型实现检索器，CM3 Transformer 构成生成器，辅助模型搜索精确信息并合成图像。就像能同时处理文本和图像的智能助手。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from PIL import Image
import requests
from io import BytesIO

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫在草地上玩耍的图片：https://example.com/cat.jpg"], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("生成一只猫在草地上玩耍的图片")
print(result)

# 显示图片
image_url = result.split("：")[-1].strip()
response = requests.get(image_url)
image = Image.open(BytesIO(response.content))
image.show()

七、RAG 存在的问题

7.1 检索效果依赖 embedding 和检索算法

RAG 的检索效果依赖于 embedding 模型和检索算法的质量。如果 embedding 无法准确表示语义，或检索算法找不到相关文档，会导致无关信息干扰输出。就像图书馆分类不好，读者找不到需要的书。

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

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物...", "狗是一种哺乳动物..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("如何训练一只狗？")
print(result)

7.2 大模型如何利用检索到的信息仍是黑盒

虽然 RAG 能检索到相关信息，但大模型如何利用这些信息生成回答仍是黑盒，可能存在不准确甚至冲突的情况。就像给学生提供了参考资料，但你不知道他们如何使用这些资料。

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

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物...", "狗是一种哺乳动物..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("猫是一种什么动物？")
print(result)

7.3 效率问题：无差别检索所有任务

RAG 对所有任务都无差别检索 k 个文本片段，效率不高，且大大增加模型输入长度，导致生成速度变慢。就像无论什么问题都要去图书馆查阅所有相关书籍，浪费时间和精力。

import time
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物...", "狗是一种哺乳动物...", "鸟是一种脊椎动物...", "鱼是一种脊椎动物..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链（检索 2 个文档）
qa_chain_2 = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever(search_kwargs={"k":2})
)

# 创建检索 QA 链（检索 4 个文档）
qa_chain_4 = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever(search_kwargs={"k":4})
)

# 提问并计时
start_time = time.time()
result_2 = qa_chain_2.run("猫是一种什么动物？")
end_time = time.time()
print(f"检索 2 个文档耗时：{end_time - start_time}秒")

start_time = time.time()
result_4 = qa_chain_4.run("猫是一种什么动物？")
end_time = time.time()
print(f"检索 4 个文档耗时：{end_time - start_time}秒")

7.4 无法精准查证事实

RAG 无法引用来源，也因此无法精准地查证事实，检索的真实性取决于数据源及检索算法。就像听到消息但不知来源，无法判断真实性。如果 AI 检索到不可靠数据源，生成的回答可能不准确。

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

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种爬行动物...（来源：不可靠网站）"], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("猫是一种什么动物？")
print(result)

八、RAG 的拓展方案

8.1 多模态 RAG

多模态 RAG 不仅可以处理文本，还可以处理图像、音频、视频等多种模态数据。它将不同模态数据转化为向量，然后进行检索和生成。就像能同时处理文字、图片、声音和视频的智能助手。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from PIL import Image
import pytesseract

# 提取图片文本
def extract_text_from_image(image_path):
    image = Image.open(image_path)
    text = pytesseract.image_to_string(image)
    return text

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["猫是一种哺乳动物..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提取图片文本
image_text = extract_text_from_image("cat.jpg")

# 提问
result = qa_chain.run(f"这张图片中的动物是什么？图片文本：{image_text}")
print(result)

8.2 实时 RAG

实时 RAG 能够实时检索最新数据并基于这些数据生成回答。它可以与实时数据源（如新闻 API、社交媒体 API 等）集成，确保回答的及时性和准确性。就像一个实时更新的新闻播报员。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
import requests

# 实时获取科技新闻
def get_latest_tech_news():
    response = requests.get("https://newsapi.org/v2/top-headlines?country=us&category=technology&apiKey=YOUR_API_KEY")
    news = response.json()
    return news['articles'][0]['content']

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts([get_latest_tech_news()], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever()
)

# 提问
result = qa_chain.run("最新的科技新闻是什么？")
print(result)

8.3 个性化 RAG

个性化 RAG 能够根据用户的个性化需求和偏好提供个性化回答。通过分析用户历史记录、兴趣爱好等信息，调整检索策略和生成方式。就像一个贴心的私人秘书。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 初始化嵌入模型和向量数据库
embeddings = OpenAIEmbeddings()
db = FAISS.from_texts(["《肖申克的救赎》是一部经典的剧情片...", "《阿甘正传》是一部励志的剧情片...", "《星际穿越》是一部科幻片..."], embeddings)

# 初始化 LLM
llm = OpenAI(temperature=0)

# 获取用户偏好
user_preference = "剧情片"

# 创建 Prompt 模板
prompt = PromptTemplate(
    input_variables=["context", "question", "user_preference"], 
    template="用户偏好：{user_preference}\n基于以下上下文回答问题：{context}\n\n问题：{question}"
)

# 创建检索 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm, 
    chain_type="stuff", 
    retriever=db.as_retriever(), 
    chain_type_kwargs={"prompt": prompt}
)

# 提问
result = qa_chain.run({"question": "推荐一些适合我的电影", "user_preference": user_preference})
print(result)