Skip to content

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-small1536优秀通用场景
OpenAI text-embedding-3-large3072最佳高精度需求
BGE-large-zh1024良好中文场景
M3E-base768良好多语言

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 chunks

2. 向量化存储 ​

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_store

3. 检索实现 ​

python
def retrieve_documents(query, vector_store, top_k=5):
    results = vector_store.similarity_search(
        query=query,
        k=top_k
    )
    
    return results

4. 生成答案 ​

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_retriever

2. 重排序 ​

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 prompt

2. 答案验证 ​

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. 响应延迟高 ​

问题: 系统响应速度慢

解决方案:

  • 实现缓存机制
  • 优化检索性能
  • 使用异步处理
  • 减少不必要的重排序

参考资料 ​

官方文档 ​

相关论文 ​


提示

RAG 系统的性能取决于检索质量和生成质量的平衡,建议根据具体场景调优参数。

信息

本指南提供了 RAG 架构的核心概念和实现方法,实际应用中需要根据具体需求进行调整。