在信息爆炸的当下，如何从海量数据中精准提取高价值内容，始终是人工智能领域的核心挑战。检索增强生成（Retrieval-Augmented Generation，简称RAG）技术应运而生，它巧妙融合了信息检索与文本生成能力：首先从文档库中定位关键信息，再据此生成精准的应答。然而，RAG的实现路径多种多样，每种方案都兼具独特优势与潜在局限。本文将系统拆解这些主流技术路线，深入剖析究竟哪一种才是性能最优的解决方案。

1. Simple RAG：经典基础方案的实践与局限

在探究各类复杂的RAG衍生技术之前，我们先回归最基础的方案。Simple RAG的工作流程相当直观：从PDF文件中提取文本内容，将其分割为固定大小的文本块（chunks），然后将每个块转换为数值化的嵌入向量；系统根据用户的查询搜索最相关的文本块，并基于这些检索结果生成最终回答。

# 定义 PDF 文件路径
pdf_path = "data/AI_information.pdf"

# 提取文本并分割成文本块
extracted_text = extract_text_from_pdf(pdf_path)
text_chunks = chunk_text(extracted_text, chunk_size=1000, overlap=200)

# 打印文本块数量
print("Number of text chunks:", len(text_chunks))

这种方法的优势在于简单易行，为后续更复杂的技术奠定了实践基础，如同学习编程时的入门第一课。不过，Simple RAG也存在明显短板：由于文本块按固定大小切割，很可能将一个完整的句子拦腰截断，或者将毫无关联的句子强行组合在一起，这直接影响检索的准确性，导致输出结果不够精准。

2. Semantic Chunking：基于语义的智能分块策略

为了克服Simple RAG在文本切分上的固有缺陷，语义分块（Semantic Chunking）技术应运而生。它不再采用固定大小切割，而是依据文本的语义逻辑进行划分——将语义关联紧密的句子组合成同一个文本块。

# 将提取的文本分割成句子
sentences = extracted_text.split(". ")

# 为每个句子生成嵌入向量
embeddings = [get_embedding(sentence) for sentence in sentences]

# 计算连续句子之间的相似度
similarities = [cosine_similarity(embeddings[i], embeddings[i + 1]) for i in range(len(embeddings) - 1)]

# 使用百分位法计算断点
breakpoints = compute_breakpoints(similarities, method="percentile", threshold=90)

# 根据断点将句子分组成语义块
text_chunks = split_into_chunks(sentences, breakpoints)

理论上，语义分块听起来很理想，但实际测试结果出人意料——它的综合评分甚至低于Simple RAG。这提醒我们，单纯改变文本切块策略并不能保证效果提升，技术优化的道路从来不是一蹴而就的，实践中常常需要经历试错和调整。

3. 上下文增强检索：利用邻近信息提升相关性

既然语义分块未达预期，不妨换个思路。Simple RAG的痛点之一在于每个文本块过于孤立，缺乏必要的上下文支撑。如果能够给每个块补充相邻的上下文信息，检索准确性是否能够显著提升？上下文增强检索（Context Enriched Retrieval）正是基于这一朴素但有效的设想。

# 定义上下文增强检索函数
def context_enriched_search(query, text_chunks, embeddings, k=1, context_size=1):
    query_embedding = create_embeddings(query).data[0].embedding
    similarity_scores = []

    for i, chunk_embedding in enumerate(embeddings):
        similarity_score = cosine_similarity(np.array(query_embedding), np.array(chunk_embedding.embedding))
        similarity_scores.append((i, similarity_score))

    similarity_scores.sort(key=lambda x: x[1], reverse=True)
    top_index = similarity_scores[0][0]

    start = max(0, top_index - context_size)
    end = min(len(text_chunks), top_index + context_size + 1)

    return [text_chunks[i] for i in range(start, end)]

在上下文增强检索中，系统不仅提取最相关的文本块，还将该块前后的邻近块一并纳入，为生成回答提供更丰富的背景信息。测试结果显示，该方法的评分达到了0.6，相较于Simple RAG和Semantic Chunking有了明显提升，证明上下文信息确实是影响检索质量的关键变量。

4. 上下文块头：为文本块添加语义标签

上下文增强虽然有效，但仍存在一个核心问题：即使引入了邻近块，文本块本身的信息承载量仍然有限。举例来说，一份文档可能涵盖多个不同的主题，每个主题对应不同的文本块。如何快速准确地在海量块中定位最相关的那一个？

上下文块头（Contextual Chunk Headers）提供了一种巧妙解法：在每个文本块前面添加一个描述性的标题（header），相当于贴上一个语义标签，高度概括该块的核心内容。

# 为每个文本块生成描述性标题
text_chunks_with_headers = chunk_text_with_headers(extracted_text, chunk_size=1000, overlap=200)

# 打印一个样本以查看效果
print("Sample Chunk with Header:")
print("Header:", text_chunks_with_headers[0]['header'])
print("Content:", text_chunks_with_headers[0]['text'])

进行检索时，系统不仅比对本块的具体内容，还会参考标题信息，从而实现更精准的定位。该方法的测试评分为0.5，虽然略低于上下文增强，但相较Simple RAG和Semantic Chunking仍有进步。这说明，给文本块添加语义标签确实能够提供额外的检索线索。

5. 文档增强：从文本块到问题的跨越

尽管上下文本头技术有所改善，但当文本块内容过于复杂时，一个标题往往难以全面概括。有没有方法能让文本块在检索过程中更容易被“命中”？

文档增强（Document Augmentation）提出了一个创新的思路：除了将文本块转换为嵌入向量，还为每个文本块生成若干个相关的问题，并将这些问题也一并转换为嵌入向量。

# 处理文档，提取文本、创建文本块、生成问题并构建向量库
text_chunks, vector_store = process_document(
    pdf_path,
    chunk_size=1000,
    chunk_overlap=200,
    questions_per_chunk=3
)

这样一来，检索时系统不仅能够匹配文本块的内容，还能匹配与用户查询相似的问题，从而显著提升命中率。测试评分达到0.8，表现相当出色。为检索提供更多入口，这一策略确实高明。

6. 查询转换：优化用户输入以提升匹配度

此前的方法主要集中在优化文本块的表示和检索策略上，但忽略了一个关键环节：用户输入的查询本身可能与文档内容存在差异，导致检索结果不准确。有没有办法让查询本身更“友好”？

查询转换（Query Transformation）提供了三种实用方法：查询重写（使查询更具体详细）、后退提示（生成更宽泛的背景查询）以及子查询分解（将复杂查询拆分为多个简单的子查询）。

# 查询重写
rewritten_query = rewrite_query(query)

# 后退提示
step_back_query = generate_step_back_query(query)

# 子查询分解
sub_queries = decompose_query(query, num_subqueries=4)

该方法的测试评分为0.5，不算特别高，但这表明在某些应用场景下，对查询进行适当加工确实能够提升检索准确性。在RAG系统中，查询质量同样是不可忽视的关键因素。

7. 重排序：让检索结果回归价值排序

检索结果输出后，简单的相似性搜索往往返回良莠不齐的结果——相关与不相关的信息混杂在一起。如果能够把最核心的结果排在最前面，生成回答的质量是否会更高？

重排序（Reranker）技术正是为了解决这个问题而设计。它在初次检索的基础上，增加一个额外的步骤对结果进行重新排序，排序依据可以是关键词，也可以借助大语言模型（LLM）来实现。

# 定义重排序函数
def rag_with_reranking(query, vector_store, reranking_method="llm", top_n=3, model="meta-llama/Llama-3.2-3B-Instruct"):
    query_embedding = create_embeddings(query)
    initial_results = vector_store.similarity_search(query_embedding, k=10)

    if reranking_method == "llm":
        reranked_results = rerank_with_llm(query, initial_results, top_n=top_n)
    else:
        reranked_results = initial_results[:top_n]

    context = "nn===nn".join([result["text"] for result in reranked_results])
    response = generate_response(query, context, model)

    return {
        "query": query,
        "reranking_method": reranking_method,
        "initial_results": initial_results[:top_n],
        "reranked_results": reranked_results,
        "context": context,
        "response": response
    }

测试评分达到0.7，效果十分显著。这表明排序优化并非可有可无的环节，而是提升回答准确性的重要杠杆。

8. 相关段落提取（RSE）：精准锁定连续相关文本

在某些情况下，最优信息可能分散在多个连续的文本块中。如果能够自动识别并提取这些连续的、相关的文本段落，而不是仅仅检索单个文本块，检索效果是否会更好？

相关段落提取（Relevant Segment Extraction，RSE）正是为实现这一目标而设计。

# 运行 RAG 并应用相关段落提取
rse_result = rag_with_rse(pdf_path, query)

这种方法能够为生成回答提供更连贯、更完整的上下文信息。测试评分高达0.8，充分说明“连锅端”的提取策略比“挑一块”的检索方式更为可靠。

9. 上下文压缩：精炼信息，去除冗余

检索到的信息有时过于冗长，其中夹杂了大量不相关内容，这不仅浪费计算资源，还可能干扰最终回答的质量。能不能只保留与查询最相关的核心部分？

上下文压缩（Contextual Compression）技术正是为解决这一痛点而生：在获取文本块之后，额外执行一步压缩操作，剔除与查询无关的内容。

# 定义上下文压缩函数
def rag_with_compression(pdf_path, query, k=10, compression_type="selective", model="meta-llama/Llama-3.2-3B-Instruct"):
    vector_store = process_document(pdf_path)
    results = vector_store.similarity_search(create_embeddings(query), k=k)
    retrieved_chunks = [r["text"] for r in results]

    compressed = batch_compress_chunks(retrieved_chunks, query, compression_type, model)
    compressed_chunks, compression_ratios = zip([(c, r) for c, r in compressed if c.strip()] or [(chunk, 0.0) for chunk in retrieved_chunks])

    context = "nn---nn".join(compressed_chunks)
    response = generate_response(query, context, model)

    return {
        "query": query,
        "original_chunks": retrieved_chunks,
        "compressed_chunks": compressed_chunks,
        "compression_ratios": compression_ratios,
        "context_length_reduction": f"{sum(compression_ratios)/len(compression_ratios):.2f}%",
        "response": response
    }

测试评分达到0.75，效果令人满意。很多时候，对信息做减法比做加法更为有效。

10. 反馈循环：让系统在迭代中持续进化

前面所介绍的改进方案均基于预设策略，系统本身并不会根据实际使用情况进行自我调整。如果能够让用户提供反馈，系统依据这些反馈持续优化，其性能是否会逐步提升？

反馈循环（Feedback Loop）正是基于这一理念：用户可以对每次回答进行评分、撰写评语，系统将这些反馈数据存储起来，并在后续检索时利用这些信息来调整策略。

# 定义完整的 RAG 流程，包含反馈机制
def full_rag_workflow(pdf_path, query, feedback_data=None, feedback_file="feedback_data.json", fine_tune=False):
    if feedback_data is None:
        feedback_data = load_feedback_data(feedback_file)
        print(f"Loaded {len(feedback_data)} feedback entries from {feedback_file}")

    chunks, vector_store = process_document(pdf_path)

    if fine_tune and feedback_data:
        vector_store = fine_tune_index(vector_store, chunks, feedback_data)

    result = rag_with_feedback_loop(query, vector_store, feedback_data)

    print("n=== Would you like to provide feedback on this response? ===")
    print("Rate relevance (1-5, with 5 being most relevant):")
    relevance = input()

    print("Rate quality (1-5, with 5 being highest quality):")
    quality = input()

    print("Any comments? (optional, press Enter to skip)")
    comments = input()

    feedback = get_user_feedback(
        query=query,
        response=result["response"],
        relevance=int(relevance),
        quality=int(quality),
        comments=comments
    )

    store_feedback(feedback, feedback_file)
    print("Feedback recorded. Thank you!")

    return result

该方法的测试评分为0.7，虽未达到顶尖水平，但“学习”能力本身就是极具价值的进化方向。每一次用户评价，都在帮助系统变得更聪明、更精准。

11. Adaptive RAG：智能匹配检索策略

不同的查询往往需要不同的检索策略。例如，事实性查询、分析性查询、观点性查询对信息的需求截然不同。如果系统能够依据查询类型自动匹配最优的检索策略，效果无疑会更好。

自适应RAG（Adaptive RAG）正是为此而生：它首先对查询进行分类，然后根据分类结果选择对应的检索策略——事实型查询采用事实检索，分析型查询采用分析检索，以此类推。

# 定义自适应 RAG 函数
def rag_with_adaptive_retrieval(pdf_path, query, k=4, user_context=None):
    chunks, vector_store = process_document(pdf_path)
    query_type = classify_query(query)
    print(f"Query classified as: {query_type}")

    retrieved_docs = adaptive_retrieval(query, vector_store, k, user_context)
    response = generate_response(query, retrieved_docs, query_type)

    return {
        "query": query,
        "query_type": query_type,
        "retrieved_documents": retrieved_docs,
        "response": response
    }

测试评分高达0.86，在所有方法中拔得头筹！这充分证明，量身定制的策略远比一刀切的方式更具优势。

12. Self RAG：引入自我反思机制

能否让系统自主判断：当前是否需要检索？检索到的信息该如何有效利用？自我反思能力，是衡量一个系统智能化程度的重要标志。

自我RAG（Self RAG）正是实现这一目标的方案：它能够在检索和生成的过程中自动进行反思，决定是否需要执行检索以及如何利用检索结果。

# 运行自我 RAG
result = self_rag(query, vector_store)

该方法的测试评分为0.65，虽然不算惊艳，但“自我反思”这一方向极具潜力。一个能够自我审视的系统，才有望变得越来越智能。

13. Knowledge Graph：构建知识网络，实现关联检索

文档中的信息往往相互关联。如果能够将这些关联关系组织成一张知识网络，那么在检索时就可以通过节点间的连接找到更多相关的信息。

知识图谱RAG（Knowledge Graph RAG）将文档中的信息构建为图结构：图中的节点代表概念或实体，边则代表它们之间的关联关系。

# 构建知识图谱
def build_knowledge_graph(chunks):
    graph, texts = nx.Graph(), [c["text"] for c in chunks]
    embeddings = create_embeddings(texts)

    for i, (chunk, emb) in enumerate(zip(chunks, embeddings)):
        graph.add_node(i, text=chunk["text"], concepts=extract_concepts(chunk["text"]), embedding=emb)

    for i, j in ((i, j) for i in range(len(chunks)) for j in range(i + 1, len(chunks))):
        if shared_concepts := set(graph.nodes[i]["concepts"]) & set(graph.nodes[j]["concepts"]):
            sim = np.dot(embeddings[i], embeddings[j]) / (np.linalg.norm(embeddings[i]) * np.linalg.norm(embeddings[j]))
            weight = 0.7 * sim + 0.3 * (len(shared_concepts) / min(len(graph.nodes[i]["concepts"]), len(graph.nodes[j]["concepts"])))
            if weight > 0.6:
                graph.add_edge(i, j, weight=weight, similarity=sim, shared_concepts=list(shared_concepts))

    print(f"Graph built: {graph.number_of_nodes()} nodes, {graph.number_of_edges()} edges")
    return graph, embeddings

进行检索时，系统不仅能够找到直接匹配的节点，还能顺着图谱找到间接关联的邻居节点，从而提供更全面的上下文信息。测试评分为0.78，表现相当亮眼。

14. 层次化索引：在宏观与微观间寻找平衡

上下文信息过多可能导致精确性下降，而一味追求精确又可能丢失必要的上下文。如何在两者之间找到平衡？

层次化索引（Hierarchical Indices）提供了一个巧妙的解决方案：创建两个层次的表示——摘要层和详细块层。检索时，先通过摘要层快速缩小搜索范围，再在详细块层进行精确匹配。

# 定义层次化 RAG 函数
def hierarchical_rag(query, pdf_path, chunk_size=1000, chunk_overlap=200, k_summaries=3, k_chunks=5, regenerate=False):
    summary_store_file = f"{os.path.basename(pdf_path)}_summary_store.pkl"
    detailed_store_file = f"{os.path.basename(pdf_path)}_detailed_store.pkl"

    if regenerate or not os.path.exists(summary_store_file) or not os.path.exists(detailed_store_file):
        print("Processing document and creating vector stores...")
        summary_store, detailed_store = process_document_hierarchically(pdf_path, chunk_size, chunk_overlap)

        with open(summary_store_file, 'wb') as f:
            pickle.dump(summary_store, f)
        with open(detailed_store_file, 'wb') as f:
            pickle.dump(detailed_store, f)
    else:
        print("Loading existing vector stores...")
        with open(summary_store_file, 'rb') as f:
            summary_store = pickle.load(f)
        with open(detailed_store_file, 'rb') as f:
            detailed_store = pickle.load(f)

    retrieved_chunks = retrieve_hierarchically(query, summary_store, detailed_store, k_summaries, k_chunks)
    response = generate_response(query, retrieved_chunks)

    return {
        "query": query,
        "response": response,
        "retrieved_chunks": retrieved_chunks,
        "summary_count": len(summary_store.texts),
        "detailed_count": len(detailed_store.texts)
    }

测试评分达到0.84，说明这种平衡之术运用得非常出色。系统既保留了全局视野，又不失精确打击的能力。

15. HyDE：从假设文档出发的逆向思维

换个思路：如果直接对查询做嵌入的效果不理想，能不能先虚构一个“理想答案”，再用这个虚构文档去进行检索？这就是HyDE（Hypothetical Document Embedding）的核心思想。

# 定义 HyDE RAG 函数
def hyde_rag(query, vector_store, k=5, should_generate_response=True):
    print(f"n=== Processing query with HyDE: {query} ===n")

    print("Generating hypothetical document...")
    hypothetical_doc = generate_hypothetical_document(query)
    print(f"Generated hypothetical document of {len(hypothetical_doc)} characters")

    print("Creating embedding for hypothetical document...")
    hypothetical_embedding = create_embeddings([hypothetical_doc])[0]

    print(f"Retrieving {k} most similar chunks...")
    retrieved_chunks = vector_store.similarity_search(hypothetical_embedding, k=k)

    results = {
        "query": query,
        "hypothetical_document": hypothetical_doc,
        "retrieved_chunks": retrieved_chunks
    }

    if should_generate_response:
        print("Generating final response...")
        response = generate_response(query, retrieved_chunks)
        results["response"] = response

    return results

该方法的测试评分为0.5，虽然不算突出，但“假设文档”这一逆向思维非常有趣，在某些特定场景下可能成为创新的突破口。

16. 融合 RAG：取长补短的多策略结合

向量检索擅长捕捉语义信息，而关键词检索则擅长精确匹配。两者各有所长，何不取长补短，将它们结合起来？

融合RAG（Fusion RAG）同时使用向量检索和BM25关键词检索，然后对两种结果进行加权融合，充分发挥各自优势。

# 定义融合检索函数
def fusion_retrieval(query, chunks, vector_store, bm25_index, k=5, alpha=0.5):
    query_embedding = create_embeddings(query)
    vector_results = {r["metadata"]["index"]: r["similarity"] for r in vector_store.similarity_search_with_scores(query_embedding, len(chunks))}
    bm25_results = {r["metadata"]["index"]: r["bm25_score"] for r in bm25_search(bm25_index, chunks, query, len(chunks))}

    all_docs = vector_store.get_all_documents()
    scores = [(i, alpha * vector_results.get(i, 0) + (1 - alpha) * bm25_results.get(i, 0)) for i in range(len(all_docs))]
    top_docs = sorted(scores, key=lambda x: x[1], reverse=True)[:k]

    return [{"text": all_docs[i]["text"], "metadata": all_docs[i]["metadata"], "score": s} for i, s in top_docs]

测试评分高达0.83，效果十分出色。取长补短，果然是一条行之有效的技术路线。

17. 多模态RAG：解锁图像信息，丰富检索维度

文档中不仅仅包含文字，还有各种图表和图片。如果能够将图像信息也纳入检索体系，无疑会大大丰富系统可用的信息源。

多模态RAG（Multi Model RAG）从PDF中同时提取文本和图像，并为图像生成描述性标题，然后将文本和图像的嵌入信息一起存入向量库，实现联合检索。

# 处理多模态文档
def process_document(pdf_path, chunk_size=1000, chunk_overlap=200):
    image_dir = "extracted_images"
    os.makedirs(image_dir, exist_ok=True)

    text_data, image_paths = extract_content_from_pdf(pdf_path, image_dir)
    chunked_text = chunk_text(text_data, chunk_size, chunk_overlap)
    image_data = process_images(image_paths)

    all_items = chunked_text + image_data
    contents = [item["content"] for item in all_items]
    embeddings = create_embeddings(contents)

    vector_store = MultiModalVectorStore()
    vector_store.add_items(all_items, embeddings)

    doc_info = {
        "text_count": len(chunked_text),
        "image_count": len(image_data),
        "total_items": len(all_items),
    }

    print(f"Added {len(all_items)} items to vector store ({len(chunked_text)} text chunks, {len(image_data)} image captions)")
    return vector_store, doc_info

测试评分达到0.79，说明图像信息确实能够为系统带来额外的价值。视觉与文字的结合，实现了双剑合璧的效果。

18. CRAG：根据检索质量动态调整策略

检索结果的质量有时高有时低，不能一概而论。如果系统能够根据检索结果的质量动态调整后续策略——质量高时直接采用，质量差时转而去互联网搜索，质量中等时两者结合——就能更灵活地应对各种情况。

纠正性RAG（Corrective RAG，CRAG）正是基于这一思路：先评估检索结果的质量，然后根据评估结果分情况处理。

# 运行纠正性 RAG
crag_result = rag_with_compression(pdf_path, query, compression_type="selective")

测试评分达到0.824，表现相当出色。随机应变，往往比固执己见更为有效。

结论：选择最适合应用场景的 RAG 技术

将这18种RAG技术逐一梳理下来，可以发现它们各有独到之处，也各有其短板。Simple RAG提供了一个基础的框架，但效果有限；语义分块、上下文增强、文档增强等方法通过在文本块上做文章提升了准确性；查询转换、重排序、段落提取、上下文压缩等则在查询和排序环节下足了功夫；反馈循环、自适应RAG、自我RAG引入了学习与动态调整机制；而知识图谱、层次化索引、HyDE、融合、多模态、CRAG则通过融合多种信息源或策略，将系统性能推向了新的高度。

在所有方法中，自适应RAG以0.86的综合评分拔得头筹。它的核心优势在于——能够根据查询类型自动选择最合适的检索策略，真正做到了因材施教。然而，这并不意味着其他技术没有价值。实际上，每种技术都有其最适合的应用场景：例如，知识图谱适用于关系密集型文档，层次化索引适合长文档处理，多模态则适合图文并茂的资料。关键在于具体问题具体分析，根据实际需求选择最合适的方案。

展望未来，RAG技术还将继续演进。可以预见，将多种技术有机结合起来，打造更智能、更高效、更可靠的系统，将是信息检索与自然语言处理领域的重要发展方向。