3.3 提示词工程优化

3.3 提示词工程优化 — RAG高级优化关键技巧

本节导读：掌握RAG系统中提示词（Prompt）的设计与优化方法。学完本节，你将能够为RAG系统设计结构化的提示模板，掌握上下文窗口管理、多段检索结果拼接、角色设定与约束注入等核心技巧，显著提升生成答案的质量和可靠性。

学习目标

• 理解RAG提示词与传统LLM提示词的核心区别
• 掌握结构化提示模板的设计原则与实现方法
• 学会管理上下文窗口，合理分配检索结果与指令的空间
• 掌握多段检索结果的智能拼接与排序策略
• 了解提示词评估与A/B测试的方法论

核心概念

在RAG系统中，提示词工程是连接"检索"和"生成"的关键桥梁。一个精心设计的提示模板，能够让大语言模型更准确地利用检索结果，生成高质量、高可靠性的答案。

RAG提示词与传统LLM提示词的根本区别在于：RAG提示词需要在有限的上下文窗口中，同时容纳系统指令、检索到的文档片段、用户查询三大要素，并协调它们之间的关系。

提示词工程在RAG系统中的定位如上图所示：它是检索模块和生成模块之间的"翻译层"，负责将结构化的检索结果转化为模型能够高效利用的自然语言输入。

环境准备 / 前置知识

• 熟悉大语言模型的基本使用方式
• 了解RAG系统的基本架构（本教程第1章）
• 掌握至少一种LLM API的调用方式（OpenAI、Anthropic、或开源模型）
• Python 3.8+ 环境

本节代码示例基于 OpenAI API 格式，兼容大多数主流LLM服务。

分步实战

步骤 1：理解RAG提示词的三大组成要素

一个典型的RAG提示词由三部分组成：系统角色指令、检索上下文、用户查询。三者在上下文窗口中的排列顺序和空间分配，直接影响生成质量。

def build_basic_rag_prompt(query: str, retrieved_docs: list, 
                           system_instruction: str = None) -> str:
    """构建基础RAG提示词"""
    
    # 第一部分：系统角色指令（可选但推荐）
    if system_instruction is None:
        system_instruction = (
            "你是一个专业的知识问答助手。请根据以下参考资料回答用户问题。"
            "如果参考资料中没有相关信息，请明确说明，不要编造答案。"
        )
    
    # 第二部分：检索上下文
    context_parts = []
    for i, doc in enumerate(retrieved_docs, 1):
        context_parts.append(f"[资料{i}] {doc['content']}")
    
    context_block = "\n\n".join(context_parts)
    
    # 第三部分：组装完整提示词
    prompt = f"""{system_instruction}

## 参考资料
{context_block}

## 用户问题
{query}

## 回答要求
1. 仅基于上述参考资料回答
2. 引用资料编号标注信息来源
3. 如果资料不足以回答问题，请说明
"""
    return prompt

# 使用示例
query = "什么是RAG技术？"
docs = [
    {"content": "RAG（Retrieval-Augmented Generation）是一种结合检索和生成的AI技术框架..."},
    {"content": "RAG通过从知识库中检索相关文档，将检索结果作为上下文提供给语言模型..."}
]

prompt = build_basic_rag_prompt(query, docs)
print(prompt[:200] + "...")
​

关键设计决策：

• 系统指令放在最前面，建立模型的行为基调
• 检索结果按编号排列，方便模型引用来源
• 用户问题放在最后，符合模型对最新信息的注意力偏好
• 回答要求明确约束模型行为，减少幻觉

步骤 2：设计结构化提示模板

结构化提示模板是工程化RAG系统的核心组件。一个好的模板应该具备可配置性、可复用性和可评估性。

from typing import List, Dict, Optional
from dataclasses import dataclass, field

@dataclass
class RAGPromptTemplate:
    """RAG提示词模板"""
    
    # 系统角色部分
    role_name: str = "知识问答专家"
    role_description: str = "你是一位专业的技术顾问，擅长从给定资料中提取关键信息并给出准确回答。"
    constraints: List[str] = field(default_factory=lambda: [
        "仅基于提供的参考资料回答问题",
        "当资料不足以回答时，明确说明并建议用户查阅相关领域",
        "回答中引用资料来源时，使用 [资料N] 格式标注",
        "保持回答的专业性和准确性"
    ])
    
    # 上下文管理部分
    max_context_chars: int = 8000  # 上下文最大字符数
    doc_separator: str = "\n---\n"
    doc_format: str = "[资料{index}] {title}\n{content}"
    
    # 输出格式部分
    output_format: str = "结构化回答，包含核心结论和详细说明"
    language: str = "中文"
    
    def build_system_message(self) -> str:
        """构建系统消息"""
        constraints_text = "\n".join(f"- {c}" for c in self.constraints)
        
        return f"""## 角色设定
名称：{self.role_name}
{self.role_description}

## 行为约束
{constraints_text}

## 输出要求
- 格式：{self.output_format}
- 语言：{self.language}"""
    
    def format_document(self, doc: Dict, index: int) -> str:
        """格式化单篇文档"""
        return self.doc_format.format(
            index=index,
            title=doc.get('title', f'文档{index}'),
            content=doc['content']
        )
    
    def build_context(self, documents: List[Dict]) -> str:
        """构建上下文块，自动截断超长内容"""
        context_parts = []
        total_chars = 0
        
        for i, doc in enumerate(documents, 1):
            formatted = self.format_document(doc, i)
            remaining = self.max_context_chars - total_chars
            
            if remaining <= 0:
                break
            
            if len(formatted) > remaining:
                # 智能截断：在句子边界处截断
                truncated = formatted[:remaining]
                last_period = truncated.rfind('。')
                if last_period > remaining * 0.5:
                    truncated = truncated[:last_period + 1]
                truncated += "\n[...内容已截断...]"
                context_parts.append(truncated)
                break
            
            context_parts.append(formatted)
            total_chars += len(formatted) + len(self.doc_separator)
        
        return self.doc_separator.join(context_parts)
    
    def build_prompt(self, query: str, documents: List[Dict],
                     conversation_history: List[Dict] = None) -> Dict:
        """构建完整的RAG提示词"""
        system_msg = self.build_system_message()
        context = self.build_context(documents)
        
        # 构建用户消息
        user_msg = f"## 参考资料\n{context}\n\n## 用户问题\n{query}"
        
        messages = [{"role": "system", "content": system_msg}]
        
        # 添加对话历史
        if conversation_history:
            messages.extend(conversation_history)
        
        messages.append({"role": "user", "content": user_msg})
        
        return messages

# 使用示例
template = RAGPromptTemplate(
    role_name="RAG技术顾问",
    max_context_chars=6000
)

docs = [
    {"title": "RAG技术概述", "content": "检索增强生成（RAG）是一种AI架构..."},
    {"title": "RAG优化方法", "content": "RAG系统的优化可以从检索质量、上下文管理和生成策略三个维度进行..."}
]

messages = template.build_prompt("如何优化RAG系统？", docs)
print(f"系统消息长度: {len(messages[0]['content'])} 字符")
print(f"总消息数: {len(messages)}")
​

步骤 3：上下文窗口管理与智能截断

上下文窗口是RAG系统中最宝贵的资源。当检索结果总量超过窗口限制时，如何选择和截断内容，直接决定了答案质量。

class ContextWindowManager:
    """上下文窗口管理器"""
    
    def __init__(self, max_tokens: int = 4000, 
                 model_name: str = "gpt-3.5-turbo"):
        self.max_tokens = max_tokens
        self.model_name = model_name
        
        # 预留空间分配（经验值）
        self.reserved = {
            'system_instruction': 300,  # 系统指令
            'user_query': 100,          # 用户查询
            'output_space': 1000,       # 生成输出
            'conversation_history': 500  # 对话历史
        }
    
    def calculate_available_context_tokens(self, 
                                           system_len: int = 300,
                                           query_len: int = 100,
                                           history_len: int = 0) -> int:
        """计算可用于检索结果的最大token数"""
        used = (system_len + query_len + history_len + 
                self.reserved['output_space'])
        available = self.max_tokens - used
        return max(available, 500)  # 至少保留500 tokens
    
    def estimate_tokens(self, text: str) -> int:
        """估算文本的token数（中文约1.5字/token）"""
        # 简化估算：中文约1.5字/token，英文约4字符/token
        chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
        english_chars = len(text) - chinese_chars
        return int(chinese_chars / 1.5 + english_chars / 4)
    
    def select_documents_by_relevance(self, 
                                       documents: List[Dict],
                                       max_tokens: int) -> List[Dict]:
        """基于相关性分数选择文档"""
        selected = []
        used_tokens = 0
        
        # 按相关性分数排序
        sorted_docs = sorted(documents, 
                           key=lambda x: x.get('score', 0), 
                           reverse=True)
        
        for doc in sorted_docs:
            doc_tokens = self.estimate_tokens(doc['content'])
            
            if used_tokens + doc_tokens <= max_tokens:
                selected.append(doc)
                used_tokens += doc_tokens
            elif not selected:
                # 至少包含最相关的文档
                selected.append(doc)
                break
            else:
                break
        
        return selected
    
    def smart_truncate(self, document: Dict, 
                       max_tokens: int) -> Dict:
        """智能截断文档，保留最重要的内容"""
        content = document['content']
        content_tokens = self.estimate_tokens(content)
        
        if content_tokens <= max_tokens:
            return document
        
        # 策略1：提取首尾段落（保留开头结论和结尾总结）
        paragraphs = content.split('\n\n')
        if len(paragraphs) <= 2:
            # 段落太少，直接按比例截断
            target_chars = int(max_tokens * 1.5)
            return {**document, 'content': content[:target_chars] + '...'}
        
        # 保留首段和尾段
        head_tokens = self.estimate_tokens(paragraphs[0])
        tail_tokens = self.estimate_tokens(paragraphs[-1])
        
        if head_tokens + tail_tokens <= max_tokens:
            remaining = max_tokens - head_tokens - tail_tokens
            middle_chars = int(remaining * 1.5)
            truncated = (
                paragraphs[0] + '\n\n' +
                '...\n[中间内容已精简]\n...\n\n' +
                paragraphs[-1]
            )
            return {**document, 'content': truncated}
        
        # 策略2：仅保留首段
        target_chars = int(max_tokens * 1.5)
        return {**document, 'content': content[:target_chars] + '...'}
    
    def distribute_context_space(self, documents: List[Dict],
                                 query_relevance: Dict[int, float] = None) -> List[Dict]:
        """按相关性分配上下文空间"""
        available = self.calculate_available_context_tokens()
        
        if not query_relevance:
            # 均匀分配
            per_doc = available // len(documents)
            return [self.smart_truncate(doc, per_doc) for doc in documents]
        
        # 按相关性加权分配
        total_relevance = sum(query_relevance.values())
        distributed = []
        
        for i, doc in enumerate(documents):
            weight = query_relevance.get(i, 1.0) / total_relevance
            doc_tokens = int(available * weight)
            distributed.append(self.smart_truncate(doc, max(doc_tokens, 100)))
        
        return distributed

# 使用示例
manager = ContextWindowManager(max_tokens=4096)

docs = [
    {"content": "RAG系统优化的第一个关键维度是检索质量..." * 50, "score": 0.95},
    {"content": "文档分块策略对RAG效果有显著影响..." * 40, "score": 0.87},
    {"content": "向量模型的选择决定了语义匹配的上限..." * 35, "score": 0.82},
    {"content": "评估体系是RAG系统持续改进的基础..." * 30, "score": 0.75},
]

available = manager.calculate_available_context_tokens()
print(f"可用上下文空间: {available} tokens")

selected = manager.select_documents_by_relevance(docs, available)
print(f"选中文档数: {len(selected)}")
​

步骤 4：多轮对话中的上下文管理

在实际应用中，RAG系统往往需要支持多轮对话。这时，提示词需要额外处理对话历史和指代消解问题。

class MultiTurnPromptManager:
    """多轮对话提示词管理器"""
    
    def __init__(self, max_history_turns: int = 3,
                 history_token_budget: int = 800):
        self.max_history_turns = max_history_turns
        self.history_token_budget = history_token_budget
    
    def compress_history(self, history: List[Dict]) -> List[Dict]:
        """压缩对话历史，保留关键信息"""
        if len(history) <= self.max_history_turns:
            return history
        
        # 保留最近N轮对话
        recent_history = history[-self.max_history_turns * 2:]
        
        # 进一步压缩：提取摘要
        compressed = []
        for msg in recent_history:
            if len(msg['content']) > 200:
                compressed.append({
                    "role": msg['role'],
                    "content": msg['content'][:200] + "..."
                })
            else:
                compressed.append(msg)
        
        return compressed
    
    def resolve_references(self, current_query: str, 
                           history: List[Dict]) -> str:
        """简单的指代消解"""
        if not history:
            return current_query
        
        # 查找最近的用户问题作为上下文
        last_user_query = None
        for msg in reversed(history):
            if msg['role'] == 'user':
                last_user_query = msg['content']
                break
        
        if not last_user_query:
            return current_query
        
        # 检测当前查询中的指代词
        pronouns = {'它', '这个', '那个', '该', '其', 'these', 'it', 'this'}
        has_pronoun = any(p in current_query for p in pronouns)
        
        if has_pronoun and last_user_query:
            # 将指代替换为具体内容（简化实现）
            resolved = f"（关于「{last_user_query[:30]}」）{current_query}"
            return resolved
        
        return current_query
    
    def build_multi_turn_prompt(self, query: str, 
                                 documents: List[Dict],
                                 history: List[Dict] = None,
                                 template: RAGPromptTemplate = None) -> Dict:
        """构建多轮对话RAG提示词"""
        if template is None:
            template = RAGPromptTemplate()
        
        # 指代消解
        resolved_query = self.resolve_references(
            query, history or []
        )
        
        # 压缩历史
        compressed_history = self.compress_history(history or [])
        
        # 构建提示词
        messages = template.build_prompt(
            resolved_query, documents, compressed_history
        )
        
        return messages

# 使用示例
multi_turn_mgr = MultiTurnPromptManager()

history = [
    {"role": "user", "content": "什么是RAG技术？"},
    {"role": "assistant", "content": "RAG是检索增强生成技术..."},
    {"role": "user", "content": "它有哪些优势？"}
]

messages = multi_turn_mgr.build_multi_turn_prompt(
    "它有哪些优势？",
    docs,
    history
)

print(f"对话历史轮数: {len(history) // 2}")
print(f"压缩后消息数: {len(messages)}")
​

完整示例

下面是一个完整的RAG提示词系统实现，包含模板管理、上下文管理和多轮对话支持：

"""
完整RAG提示词系统示例
功能：结构化模板 + 上下文管理 + 多轮对话 + 答案后处理
"""

from dataclasses import dataclass, field
from typing import List, Dict, Optional
import json
import re


@dataclass
class AdvancedRAGPromptSystem:
    """高级RAG提示词系统"""
    
    # 模型配置
    model_name: str = "gpt-3.5-turbo"
    max_context_tokens: int = 3000
    max_output_tokens: int = 1500
    
    # 模板配置
    role_name: str = "技术顾问"
    temperature: float = 0.3  # RAG场景建议低温度
    
    # 约束条件
    strict_mode: bool = True  # 严格模式：禁止编造
    
    def build_messages(self, query: str, documents: List[Dict],
                       history: List[Dict] = None) -> List[Dict]:
        """构建完整的消息列表"""
        
        # 1. 系统消息
        system_msg = self._build_system_message()
        
        # 2. 格式化文档
        context = self._build_context(documents)
        
        # 3. 组装
        messages = [{"role": "system", "content": system_msg}]
        
        # 对话历史（仅保留最近2轮）
        if history:
            recent = history[-4:]
            messages.extend(recent)
        
        # 4. 用户消息
        user_msg = self._build_user_message(query, context)
        messages.append({"role": "user", "content": user_msg})
        
        return messages
    
    def _build_system_message(self) -> str:
        """构建系统消息"""
        base = f"""你是一位{self.role_name}。

## 核心规则
- 仅基于提供的「参考资料」回答问题
- 引用信息时标注来源编号 [资料N]
- 回答要结构清晰、重点突出"""
        
        if self.strict_mode:
            base += "\n- 如果参考资料无法回答问题，必须明确说明「根据现有资料，无法回答这个问题」\n- 绝对禁止编造或推测参考资料以外的信息"
        
        return base
    
    def _build_context(self, documents: List[Dict]) -> str:
        """构建上下文，包含相关性标注"""
        parts = []
        
        for i, doc in enumerate(documents, 1):
            score = doc.get('score', 0)
            relevance = "高" if score > 0.85 else "中" if score > 0.7 else "低"
            
            part = f"[资料{i}] （相关度：{relevance}）\n{doc['content']}"
            parts.append(part)
        
        return "\n\n".join(parts)
    
    def _build_user_message(self, query: str, context: str) -> str:
        """构建用户消息"""
        return f"""## 参考资料
{context}

## 请回答以下问题
{query}"""
    
    def post_process_answer(self, answer: str, 
                            documents: List[Dict]) -> Dict:
        """后处理答案：提取引用、验证来源"""
        # 提取引用标记
        citations = re.findall(r'\[资料(\d+)\]', answer)
        cited_ids = [int(c) for c in citations]
        
        # 验证引用是否有效
        valid_citations = [c for c in cited_ids if c <= len(documents)]
        invalid_citations = [c for c in cited_ids if c > len(documents)]
        
        return {
            'answer': answer,
            'citations': valid_citations,
            'citation_count': len(valid_citations),
            'has_invalid_citations': len(invalid_citations) > 0,
            'answer_length': len(answer)
        }


# === 使用示例 ===
system = AdvancedRAGPromptSystem(
    role_name="RAG技术专家",
    max_context_tokens=3000,
    strict_mode=True
)

query = "RAG系统有哪些常见的优化方向？"
documents = [
    {
        "content": "RAG系统的核心优化方向包括三个维度：第一，检索质量优化，涉及向量模型选择、混合检索策略和重排序机制；第二，上下文管理优化，涉及分块策略、上下文窗口分配和检索结果筛选；第三，生成策略优化，涉及提示词工程、答案验证和输出格式控制。",
        "score": 0.95
    },
    {
        "content": "在生产环境中，RAG系统还需要关注部署架构的优化，包括缓存策略、负载均衡和监控告警体系。此外，数据质量是容易被忽视但至关重要的因素，文档预处理和清洗直接影响检索效果。",
        "score": 0.82
    },
    {
        "content": "评估体系是RAG优化闭环的关键环节。常用的评估指标包括检索准确率、召回率、答案忠实度和答案相关性。RAGAS框架提供了一套标准化的评估方法。",
        "score": 0.78
    }
]

messages = system.build_messages(query, documents)
print(f"构建的消息数: {len(messages)}")
print(f"系统消息长度: {len(messages[0]['content'])} 字符")

# 模拟后处理
mock_answer = """根据参考资料，RAG系统的主要优化方向包括：

1. **检索质量优化** [资料1]：涉及向量模型选择、混合检索策略和重排序机制
2. **上下文管理优化** [资料1]：涉及分块策略、上下文窗口分配和检索结果筛选
3. **生成策略优化** [资料1]：涉及提示词工程、答案验证和输出格式控制
4. **部署架构优化** [资料2]：包括缓存策略、负载均衡和监控告警
5. **评估体系建设** [资料3]：使用检索准确率、召回率等指标形成优化闭环"""

result = system.post_process_answer(mock_answer, documents)
print(f"\n引用资料数: {result['citation_count']}")
print(f"答案长度: {result['answer_length']} 字符")
print(f"无效引用: {result['has_invalid_citations']}")
​

subgraph 处理层
    R[指代消解]
    C[上下文窗口管理]
    T[模板渲染]
    S[空间分配]
end

subgraph 输出层
    M[消息列表]
    L[LLM生成]
    P[后处理验证]
    A[最终答案]
end

Q --> R
H --> R
D --> C
R --> T
C --> S
S --> T
T --> M
M --> L
L --> P
P --> A
​

</div>

## 常见问题 FAQ

### Q1：RAG提示词和普通ChatGPT提示词有什么区别？
A：核心区别在于上下文管理。普通ChatGPT提示词主要关注指令的清晰度和角色设定，而RAG提示词还需要处理结构化的检索结果输入、来源引用标注、上下文窗口分配等问题。RAG提示词更像是一个"模板引擎"，需要动态地将检索结果嵌入到固定的指令框架中。此外，RAG提示词通常设置更低的温度参数（0.1-0.3），因为目标是忠实于检索结果而非创造性生成。

### Q2：当检索结果相互矛盾时，提示词该如何处理？
A：处理矛盾信息的策略有三种。第一，在系统指令中添加"如果参考资料之间存在矛盾，请分别列出不同观点并标注来源"。第二，利用检索相关性分数，在提示词中标注每条资料的置信度，引导模型优先采信高置信度资料。第三，在生成后增加一个"矛盾检测"后处理步骤，自动识别答案中的矛盾之处并提示用户核实。实践中，三种策略组合使用效果最好。

### Q3：RAG提示词的温度参数应该设多少？
A：对于知识问答类RAG场景，建议温度设置在0.1-0.3之间。低温度确保答案的稳定性和一致性，这对于需要忠实于检索结果的任务至关重要。如果是创意写作或开放性讨论类的RAG应用，可以适当提高到0.5-0.7。但无论什么场景，RAG应用的温度都不建议超过0.8，因为高温会导致模型过度"发挥"，偏离检索结果。

### Q4：上下文窗口不够用怎么办？
A：可以从三个层面解决。第一，减少输入：优化检索质量只保留最相关的Top-K文档，对长文档进行智能截断。第二，压缩表示：将文档摘要而非全文放入上下文，或者使用更高效的编码格式。第三，分步处理：先让模型基于部分上下文生成初步答案，再根据答案需要补充更多上下文进行二次生成。实践中，第一层优化通常就能解决80%的场景。

### Q5：如何评估提示词的质量？
A：建议采用A/B测试的方法。准备一组标准测试问题（50-100个），覆盖不同类型（事实型、概念型、对比型、操作型），分别用不同版本的提示词生成答案，然后从准确性、完整性、引用正确性、格式规范性四个维度进行评分。也可以使用LLM-as-Judge的方法，让另一个LLM来评估答案质量，效率更高但需要设计好评估提示词。

## 最佳实践与避坑

**最佳实践：**
- 提示词模板版本化管理：每次修改提示词都记录版本号和变更原因，方便回滚和A/B对比
- 在提示词中标注检索结果的相关性分数，帮助模型区分高价值和低价值信息
- 为不同类型的查询（事实型、操作型、对比型）设计不同的提示模板分支
- 在系统指令中明确"不知道就说不知道"的规则，这是减少幻觉最有效的一行提示词
- 预留至少20%的上下文窗口给模型输出，否则答案会被截断

**常见坑点：**
- 把所有检索结果无差别地塞进上下文：低相关性的文档会稀释高相关性文档的影响力，导致答案质量下降
- 忽略对话历史的token开销：多轮对话中，历史消息可能占用大量空间，必须做压缩或裁剪
- 温度设置过高：RAG场景高温度=高幻觉率，这是最常见的配置错误
- 在提示词中使用过于复杂的指令：LLM对简单明确的指令理解更好，复杂指令反而降低执行准确率
- 不做答案后处理：直接返回LLM输出可能包含无效引用、格式混乱等问题

## 本节小结

提示词工程是RAG系统中"最后一公里"的优化关键。本节从RAG提示词的三大组成要素出发，讲解了结构化模板设计、上下文窗口管理、智能截断策略和多轮对话处理四个核心技术点。

核心要点回顾：第一，RAG提示词不是简单的字符串拼接，而是需要精心设计的模板系统；第二，上下文窗口是稀缺资源，必须按相关性智能分配；第三，多轮对话需要指代消解和历史压缩；第四，低温度和严格约束是减少幻觉的有效手段。

在下一节中，我们将探讨向量模型的微调与优化，这是提升检索质量上游能力的核心技术。

---
**关键词**：RAG高级优化, 提示词工程, Prompt Engineering, 上下文管理, RAG提示模板, LLM温度设置, 答案验证, 多轮对话RAG
**难度**：进阶
**预计阅读**：18 分钟
​