外观
RAG 架构设计指南
RAG(Retrieval-Augmented Generation,检索增强生成)是一种结合信息检索和文本生成的技术架构。本指南将详细介绍 RAG 的核心概念、架构设计和最佳实践。
概述
什么是 RAG?
RAG 是一种将外部知识库与大语言模型结合的技术方案,通过检索相关信息来增强模型的生成能力。主要解决以下问题:
- 知识时效性:模型训练后的新知识无法获取
- 领域专业性:缺乏特定领域的专业知识
- 事实准确性:减少模型幻觉,提高回答准确性
- 可解释性:提供信息来源,增强可信度
RAG vs 微调
| 特性 | RAG | 微调 |
|---|---|---|
| 知识更新 | 实时更新 | 需要重新训练 |
| 成本 | 低 | 高 |
| 时间 | 快 | 慢 |
| 适用场景 | 知识密集型任务 | 特定任务优化 |
| 可解释性 | 高 | 低 |
| 数据隐私 | 可控 | 难以控制 |
适用场景
- 企业知识库问答
- 文档检索和总结
- 智能客服系统
- 法律医疗等专业领域
- 实时信息查询
核心架构
整体架构图
text
┌─────────────────────────────────────────────────────────────┐
│ 用户查询 │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 查询处理层 │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 查询理解 │ 查询改写 │ 查询扩展 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 检索层 │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 向量检索 │ 关键词检索 │ 混合检索 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 向量数据库 │ 倒排索引 │ 知识图谱 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 重排序层 │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 相关性打分 │ 多样性优化 │ 业务规则过滤 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 生成层 │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ Prompt构建 │ LLM推理 │ 答案后处理 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 输出层 │
│ ┌──────────────┬──────────────┬──────────────────────────┐ │
│ │ 答案生成 │ 来源引用 │ 相关推荐 │ │
│ └──────────────┴──────────────┴──────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘核心组件
1. 文档处理管道
text
原始文档 → 文档解析 → 文本切分 → 向量化 → 存储文档解析:
- PDF 解析
- Word 文档解析
- HTML 解析
- Markdown 解析
文本切分策略:
- 固定长度切分
- 语义切分
- 递归切分
- 自定义切分
2. 向量化模块
Embedding 模型选择:
| 模型 | 维度 | 性能 | 适用场景 |
|---|---|---|---|
| OpenAI text-embedding-3-small | 1536 | 优秀 | 通用场景 |
| OpenAI text-embedding-3-large | 3072 | 最佳 | 高精度需求 |
| BGE-large-zh | 1024 | 良好 | 中文场景 |
| M3E-base | 768 | 良好 | 多语言 |
3. 检索策略
向量检索:
- 余弦相似度
- 欧氏距离
- 点积相似度
关键词检索:
- BM25
- TF-IDF
混合检索:
- 向量检索 + 关键词检索
- 加权融合
- 倒数排名融合
4. 重排序模块
相关性打分:
- Cross-Encoder 模型
- LLM 打分
- 规则打分
多样性优化:
- MMR (Maximal Marginal Relevance)
- 聚类去重
技术实现
基础架构实现
1. 文档处理
python
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader
def process_documents(file_path):
loader = PyPDFLoader(file_path)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
length_function=len,
separators=["\n\n", "\n", " ", ""]
)
chunks = text_splitter.split_documents(documents)
return chunks2. 向量化存储
python
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Milvus
def create_vector_store(documents, collection_name):
embeddings = OpenAIEmbeddings()
vector_store = Milvus.from_documents(
documents=documents,
embedding=embeddings,
collection_name=collection_name,
connection_args={
"host": "localhost",
"port": "19530"
}
)
return vector_store3. 检索实现
python
def retrieve_documents(query, vector_store, top_k=5):
results = vector_store.similarity_search(
query=query,
k=top_k
)
return results4. 生成答案
python
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
def create_qa_chain(vector_store):
llm = OpenAI(temperature=0.7)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vector_store.as_retriever(
search_kwargs={"k": 5}
),
return_source_documents=True
)
return qa_chain高级架构实现
1. 混合检索
python
from langchain.retrievers import EnsembleRetriever
from langchain.retrievers import BM25Retriever
def create_hybrid_retriever(documents, vector_store):
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 5
vector_retriever = vector_store.as_retriever(
search_kwargs={"k": 5}
)
ensemble_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, vector_retriever],
weights=[0.4, 0.6]
)
return ensemble_retriever2. 重排序
python
from sentence_transformers import CrossEncoder
def rerank_documents(query, documents, model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"):
model = CrossEncoder(model_name)
pairs = [[query, doc.page_content] for doc in documents]
scores = model.predict(pairs)
scored_docs = list(zip(documents, scores))
scored_docs.sort(key=lambda x: x[1], reverse=True)
return [doc for doc, score in scored_docs[:5]]3. 查询改写
python
from langchain.llms import OpenAI
def rewrite_query(query):
llm = OpenAI(temperature=0)
prompt = f"""
请将以下用户查询改写为更适合检索的形式:
原始查询:{query}
改写后的查询:
"""
rewritten_query = llm(prompt)
return rewritten_query.strip()4. 多轮对话
python
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
def create_conversational_qa(vector_store):
llm = OpenAI(temperature=0.7)
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True
)
qa_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=vector_store.as_retriever(),
memory=memory,
return_source_documents=True
)
return qa_chain性能优化
检索性能优化
1. 索引优化
python
from langchain.vectorstores import Milvus
vector_store = Milvus.from_documents(
documents=documents,
embedding=embeddings,
collection_name="optimized_collection",
index_params={
"metric_type": "IP",
"index_type": "IVF_FLAT",
"params": {"nlist": 1024}
}
)2. 缓存策略
python
from functools import lru_cache
@lru_cache(maxsize=1000)
def cached_embedding(text):
return embeddings.embed_query(text)
@lru_cache(maxsize=100)
def cached_retrieval(query):
return vector_store.similarity_search(query, k=5)3. 批处理优化
python
def batch_process_documents(documents, batch_size=100):
results = []
for i in range(0, len(documents), batch_size):
batch = documents[i:i + batch_size]
embeddings_list = embeddings.embed_documents(
[doc.page_content for doc in batch]
)
results.extend(embeddings_list)
return results生成质量优化
1. Prompt 优化
python
def create_optimized_prompt(query, context):
prompt = f"""
基于以下上下文信息回答用户问题。如果上下文中没有相关信息,请明确说明。
上下文信息:
{context}
用户问题:{query}
请提供准确、详细的回答,并在适当的地方引用上下文信息:
"""
return prompt2. 答案验证
python
def verify_answer(query, answer, context):
llm = OpenAI(temperature=0)
prompt = f"""
请验证以下答案是否基于给定的上下文信息:
问题:{query}
答案:{answer}
上下文:{context}
答案是否准确?请回答"是"或"否",并说明理由。
"""
verification = llm(prompt)
return verification评估指标
检索质量评估
python
def evaluate_retrieval(queries, ground_truth, vector_store, k=5):
precision_scores = []
recall_scores = []
for query, relevant_docs in zip(queries, ground_truth):
retrieved = vector_store.similarity_search(query, k=k)
retrieved_ids = [doc.metadata["id"] for doc in retrieved]
true_positives = len(set(retrieved_ids) & set(relevant_docs))
precision = true_positives / k
recall = true_positives / len(relevant_docs)
precision_scores.append(precision)
recall_scores.append(recall)
return {
"precision": sum(precision_scores) / len(precision_scores),
"recall": sum(recall_scores) / len(recall_scores)
}生成质量评估
python
def evaluate_generation(queries, ground_truth_answers, qa_chain):
from rouge import Rouge
rouge = Rouge()
scores = []
for query, true_answer in zip(queries, ground_truth_answers):
result = qa_chain({"query": query})
generated_answer = result["result"]
score = rouge.get_scores(generated_answer, true_answer)[0]
scores.append(score)
avg_scores = {
metric: sum(s[metric]['f'] for s in scores) / len(scores)
for metric in scores[0].keys()
}
return avg_scores最佳实践
1. 文档处理
- 选择合适的切分策略
- 保留文档元数据
- 处理特殊格式和表格
- 定期更新知识库
2. 检索优化
- 使用混合检索策略
- 实现查询改写和扩展
- 配置合理的检索参数
- 添加重排序模块
3. 生成优化
- 设计高质量的 Prompt
- 实现答案验证机制
- 提供来源引用
- 处理不确定情况
4. 系统架构
- 实现缓存机制
- 支持水平扩展
- 监控关键指标
- 优化响应延迟
常见问题
1. 检索质量不佳
问题: 检索到的文档不相关
解决方案:
- 优化 Embedding 模型选择
- 调整切分策略
- 使用混合检索
- 添加重排序模块
2. 答案质量不高
问题: 生成的答案不准确或不完整
解决方案:
- 优化 Prompt 设计
- 增加上下文长度
- 实现答案验证
- 使用更强的 LLM
3. 响应延迟高
问题: 系统响应速度慢
解决方案:
- 实现缓存机制
- 优化检索性能
- 使用异步处理
- 减少不必要的重排序
参考资料
官方文档
相关论文
- Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
- Dense Passage Retrieval for Open-Domain Question Answering
提示
RAG 系统的性能取决于检索质量和生成质量的平衡,建议根据具体场景调优参数。
信息
本指南提供了 RAG 架构的核心概念和实现方法,实际应用中需要根据具体需求进行调整。
