RAG实战指南 Day 24：上下文构建与提示工程

【RAG实战指南 Day 24】上下文构建与提示工程

文章内容

开篇

欢迎来到"RAG实战指南"系列的第24天！今天我们将深入探讨RAG系统中至关重要的上下文构建与提示工程技术。在检索增强生成系统中，如何有效地组织检索到的文档片段，并将其转化为适合大语言模型(LLM)处理的提示，直接决定了最终生成结果的质量。本文将系统讲解上下文构建的最佳实践和高级提示工程技术，帮助您构建更精准、更可靠的RAG应用。

理论基础

关键概念：

1. 上下文窗口：LLM能够同时处理的最大文本长度，不同模型有不同限制
2. 提示工程：设计输入提示以引导模型产生期望输出的技术
3. 上下文相关性：检索内容与用户查询的语义匹配程度
4. 信息密度：单位文本中包含的有价值信息量

核心挑战：

1. 如何从检索结果中选择最具信息量的片段
2. 如何组织多个文档片段以避免信息冲突
3. 如何设计提示模板使LLM充分利用上下文
4. 如何平衡上下文长度和信息密度

技术解析

1. 上下文构建策略

策略名称	核心思想	适用场景
截断法	保留最相关的前N个token	简单查询，上下文有限
滑动窗口	重叠分块保留边界信息	长文档连续信息提取
层次聚合	先提取关键句再扩展上下文	需要保持文档结构
动态融合	根据查询动态重组片段	复杂多文档查询

2. 提示工程设计模式

from typing import List, Dict
from pydantic import BaseModel

class Document(BaseModel):
    content: str
    metadata: Dict[str, str]
    relevance_score: float

class PromptBuilder:
    def __init__(self, system_prompt: str):
        self.system_prompt = system_prompt
        self.context_token_limit = 4000  # 假设模型上下文窗口为4k
        
    def build_prompt(self, query: str, documents: List[Document]) -> str:
        """构建RAG提示的核心方法"""
        # 1. 上下文选择与截断
        selected_context = self._select_context(documents)
        
        # 2. 构建结构化提示
        prompt = f"""
        {self.system_prompt}
        
        ### 背景知识:
        {selected_context}
        
        ### 用户问题:
        {query}
        
        ### 回答要求:
        - 仅基于提供的背景知识回答
        - 如果信息不足请回答"根据现有信息无法确定"
        - 保持专业、准确的语气
        """
        return prompt
    
    def _select_context(self, documents: List[Document]) -> str:
        """选择最相关的上下文片段"""
        # 按相关性排序
        sorted_docs = sorted(documents, key=lambda x: x.relevance_score, reverse=True)
        
        selected_texts = []
        current_length = 0
        
        for doc in sorted_docs:
            doc_length = len(doc.content.split())  # 简单以词数计算
            if current_length + doc_length <= self.context_token_limit:
                selected_texts.append(f"来源: {doc.metadata.get('source', '未知')}\n内容: {doc.content}")
                current_length += doc_length
            else:
                break
                
        return "\n\n".join(selected_texts)

3. 高级提示技术

1. 多轮提示：将复杂问题分解为多个子问题
2. 自洽性检查：要求模型验证自己的回答
3. 思维链：引导模型展示推理过程
4. 模板变量：动态插入上下文片段

class AdvancedPromptBuilder(PromptBuilder):
    def build_analytic_prompt(self, query: str, documents: List[Document]) -> str:
        """构建带有分析过程的提示"""
        context = self._select_context(documents)
        
        prompt = f"""
        {self.system_prompt}
        
        请按照以下步骤分析问题:
        
        1. 理解问题: "{query}"
        2. 分析相关背景知识: 
        {context}
        3. 逐步推理得出结论
        4. 验证结论的合理性
        
        请按上述步骤给出最终答案，并标注每个步骤的思考过程。
        """
        return prompt
    
    def build_multi_turn_prompt(self, conversation: List[Dict], documents: List[Document]) -> str:
        """构建多轮对话提示"""
        context = self._select_context(documents)
        
        # 构建对话历史
        history = "\n".join([f"{msg['role']}: {msg['content']}" for msg in conversation[:-1]])
        current_query = conversation[-1]['content']
        
        prompt = f"""
        {self.system_prompt}
        
        对话历史:
        {history}
        
        当前问题: {current_query}
        
        相关背景:
        {context}
        
        请基于以上信息继续对话。
        """
        return prompt

代码实现

完整实现一个支持多种提示策略的RAG上下文处理器：

import re
from typing import List, Optional
from rank_bm25 import BM25Okapi

class ContextProcessor:
    def __init__(self, chunk_size: int = 500, chunk_overlap: int = 50):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        
    def split_text(self, text: str) -> List[str]:
        """基础文本分块"""
        words = text.split()
        chunks = []
        start = 0
        
        while start < len(words):
            end = min(start + self.chunk_size, len(words))
            chunk = " ".join(words[start:end])
            chunks.append(chunk)
            start = end - self.chunk_overlap
            
        return chunks
    
    def rerank_by_query(self, query: str, documents: List[str]) -> List[float]:
        """基于查询对文档片段重新排序"""
        tokenized_docs = [doc.split() for doc in documents]
        tokenized_query = query.split()
        
        bm25 = BM25Okapi(tokenized_docs)
        scores = bm25.get_scores(tokenized_query)
        return scores
    
    def build_context(
        self,
        query: str,
        documents: List[str],
        strategy: str = "simple",
        max_length: int = 4000
    ) -> str:
        """根据策略构建上下文"""
        if strategy == "simple":
            return self._simple_context(query, documents, max_length)
        elif strategy == "analytical":
            return self._analytical_context(query, documents, max_length)
        else:
            raise ValueError(f"未知策略: {strategy}")
    
    def _simple_context(self, query: str, documents: List[str], max_length: int) -> str:
        """简单拼接策略"""
        current_length = 0
        selected = []
        
        for doc in documents:
            doc_length = len(doc.split())
            if current_length + doc_length <= max_length:
                selected.append(doc)
                current_length += doc_length
            else:
                remaining = max_length - current_length
                if remaining > 100:  # 至少保留有意义的片段
                    selected.append(" ".join(doc.split()[:remaining]))
                break
                
        return "\n".join(selected)
    
    def _analytical_context(self, query: str, documents: List[str], max_length: int) -> str:
        """分析型上下文构建"""
        # 1. 提取关键句
        key_sentences = []
        for doc in documents:
            sentences = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', doc)
            for sent in sentences:
                if len(sent.split()) > 10:  # 忽略过短句子
                    key_sentences.append(sent)
        
        # 2. 重排序
        scores = self.rerank_by_query(query, key_sentences)
        scored_sents = sorted(zip(key_sentences, scores), key=lambda x: x[1], reverse=True)
        
        # 3. 构建上下文
        selected = []
        current_length = 0
        for sent, score in scored_sents:
            sent_length = len(sent.split())
            if current_length + sent_length <= max_length:
                selected.append(f"[相关性: {score:.2f}] {sent}")
                current_length += sent_length
                
        return "\n".join(selected)

# 单元测试
if __name__ == "__main__":
    processor = ContextProcessor()
    
    # 测试数据
    docs = [
        "深度学习是机器学习的分支，专注于使用深度神经网络。",
        "Transformer模型是当前最先进的NLP架构，基于自注意力机制。",
        "BERT是一种预训练的Transformer模型，广泛用于各种NLP任务。",
        "RAG系统结合了检索和生成技术，提升大语言模型的准确性。"
    ]
    
    query = "什么是BERT模型？"
    
    print("=== 简单上下文 ===")
    print(processor.build_context(query, docs, "simple", 100))
    
    print("\n=== 分析型上下文 ===")
    print(processor.build_context(query, docs, "analytical", 150))

案例分析：法律咨询RAG系统

业务场景 ：

为律师事务所构建智能法律咨询系统，需要从大量法律文档中检索相关信息并生成准确回答。

挑战：

1. 法律文本复杂冗长
2. 需要精确引用相关法条
3. 回答必须严谨无歧义

解决方案：

1. 使用分析型上下文构建策略
2. 设计专业法律提示模板
3. 实现引用溯源功能

class LegalPromptBuilder:
    def __init__(self):
        self.system_prompt = """
        你是一位专业法律AI助手，请严格按照以下要求回答问题:
        1. 只基于提供的法律条文和判例回答
        2. 明确标注引用来源(条款号/判例编号)
        3. 如无明确依据，应回答"需要进一步法律分析"
        4. 避免任何主观解释或推测
        """
        
    def build_legal_prompt(self, query: str, contexts: List[Dict]) -> str:
        """构建法律专业提示"""
        context_str = ""
        for ctx in contexts:
            context_str += f"【{ctx['source']}】{ctx['content']}\n\n"
            
        return f"""
        {self.system_prompt}
        
        ### 相关法律依据:
        {context_str}
        
        ### 咨询问题:
        {query}
        
        ### 回答格式要求:
        1. 法律定性
        2. 适用条款
        3. 相关判例(如有)
        4. 结论
        """

# 使用示例
if __name__ == "__main__":
    builder = LegalPromptBuilder()
    
    legal_contexts = [
        {
            "source": "民法典第584条",
            "content": "当事人一方不履行合同义务或者履行合同义务不符合约定，给对方造成损失的...",
        },
        {
            "source": "(2022)最高法民终123号",
            "content": "关于合同违约金的计算标准，应当综合考虑实际损失和合同履行情况...",
        }
    ]
    
    query = "合同违约后如何计算赔偿金额？"
    
    prompt = builder.build_legal_prompt(query, legal_contexts)
    print(prompt)

优缺点分析

优势：

1. 显著提升生成结果的相关性和准确性
2. 减少LLM的幻觉问题
3. 支持复杂问题的分步解答
4. 可适应不同领域的专业要求

局限性：

1. 提示设计需要领域专业知识
2. 复杂提示可能增加计算成本
3. 对上下文质量高度依赖
4. 需要针对不同模型调整策略

总结

今天我们深入探讨了RAG系统中的上下文构建与提示工程技术：

1. 学习了多种上下文构建策略及其适用场景
2. 实现了完整的提示构建器类，支持多种高级技术
3. 分析了法律咨询系统的实际案例
4. 讨论了不同技术的优缺点

核心技术要点：

• 上下文选择比数量更重要
• 结构化提示显著提升生成质量
• 领域特定的提示设计是关键
• 多轮和分步提示适合复杂问题

实践建议：

1. 从简单策略开始逐步优化
2. 针对领域特点定制提示模板
3. 建立提示版本控制系统
4. 持续监控生成质量

明天我们将探讨【Day 25: 响应生成策略与幻觉减少】，学习如何优化RAG系统的最终输出质量，减少错误信息生成。

参考资料

1. Prompt Engineering Guide
2. Advanced RAG Techniques
3. LegalAI Applications
4. Context Management in LLMs

文章标签

RAG, Retrieval-Augmented Generation, Prompt Engineering, Context Management, NLP

文章简述

本文是"RAG实战指南"系列的第24篇，深入讲解检索增强生成系统中的上下文构建与提示工程技术。文章系统介绍了多种上下文组织策略、高级提示设计模式，并提供了完整的Python实现代码。通过法律咨询系统的实际案例，展示了如何将这些技术应用于专业领域。读者将学习到如何优化RAG系统的上下文利用率、设计有效的提示模板，以及平衡信息密度与生成质量。本文内容既有理论深度又有实践价值，提供的代码可直接集成到现有RAG系统中。