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

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 是两种不同的大模型增强技术。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)