5.2 提示工程实践

5.2 提示工程实践 — RAG知识库实战提示优化

本节导读：掌握在RAG系统中设计和优化提示词的核技术，学会从基础prompt设计到复杂提示策略的完整流程，实现高质量的检索增强生成效果。

学习目标

• 理解提示工程的基本概念和重要性
• 掌握RAG系统中的提示设计原则
• 学会优化提示词以获得更好的检索效果
• 能够处理复杂的提示场景和多轮对话
• 了解提示模板和最佳实践

核心概念

提示工程是指导LLM生成高质量响应的关键技术，在RAG系统中尤为重要，因为它直接影响检索到的知识的有效利用。

提示工程在RAG中的作用

提示设计核心原则

环境准备 / 前置知识

基础依赖

import json
import re
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum
import numpy as np
​

提示模板基础

# 基础提示模板
BASE_PROMPT_TEMPLATE = """
请根据以下提供的信息回答问题：

{context}

问题：{question}

要求：
1. 只基于提供的上下文回答
2. 如果上下文中没有相关信息，请说明"无法从提供的上下文中找到答案"
3. 答案要准确、简洁、有条理
4. 重要概念需要简要解释

答案：
"""

# 问答提示模板
QAPROMPT_TEMPLATE = """
上下文信息：
{context}

用户问题：{question}

回答要求：
- 基于上下文提供准确答案
- 如果信息不足，明确说明
- 使用简洁明了的语言
- 包含必要的解释说明

回答：
"""

# 代码生成提示模板
CODE_GENERATION_TEMPLATE = """
根据以下技术文档和用户需求，生成完整的代码实现：

技术文档：
{context}

需求描述：
{requirements}

输出要求：
1. 提供完整的可执行代码
2. 包含必要的注释和文档字符串
3. 遵循最佳编码规范
4. 考虑错误处理和边界情况
5. 提供使用示例

代码实现：
"""
​

分步实战

步骤1：基础提示设计

1.1 简单问答提示

class SimpleQAPrompt:
    """
    简单问答提示设计器
    """
    
    def __init__(self, template: str = BASE_PROMPT_TEMPLATE):
        self.template = template
        
    def build_prompt(self, context: str, question: str) -> str:
        """
        构建基础问答提示
        """
        return self.template.format(
            context=context,
            question=question
        )
    
    def validate_response(self, response: str, context: str) -> bool:
        """
        验证回答是否基于上下文
        """
        # 检查回答是否包含不在上下文中的关键信息
        context_words = set(re.findall(r'\w+', context.lower()))
        response_words = set(re.findall(r'\w+', response.lower()))
        
        # 如果回答中有很多词不在上下文中，可能是编造的
        if len(response_words - context_words) > len(response_words) * 0.1:
            return False
        return True
​

1.2 上下文增强提示

class ContextAwarePrompt:
    """
    上下文感知提示设计器
    """
    
    def __init__(self):
        self.context_filters = {
            'relevance': self._filter_relevant_content,
            'length': self._filter_by_length,
            'completeness': self._filter_by_completeness
        }
        
    def build_enhanced_prompt(self, context_chunks: List[str], 
                            question: str, max_length: int = 2000) -> str:
        """
        构建增强的提示词
        """
        # 过滤相关内容
        filtered_chunks = self._filter_relevant_content(context_chunks, question)
        
        # 控制长度
        truncated_chunks = self._filter_by_length(filtered_chunks, max_length)
        
        # 确保完整性
        complete_chunks = self._filter_by_completeness(truncated_chunks, question)
        
        # 构建完整提示
        context_text = "\n\n".join(complete_chunks)
        
        enhanced_prompt = f"""
基于以下相关信息回答问题：

【相关上下文】
{context_text}

【用户问题】
{question}

【回答要求】
1. 严格基于提供的上下文回答
2. 答案要准确、有条理
3. 如果信息不足，明确说明
4. 重点突出关键信息

【回答】
"""
        
        return enhanced_prompt
    
    def _filter_relevant_content(self, chunks: List[str], question: str) -> List[str]:
        """
        过滤与问题相关的上下文
        """
        # 这里可以实现更复杂的相关性判断
        # 简化版本：保留所有chunks，实际情况可能需要向量相似度计算
        return chunks[:5]  # 限制最多5个chunks
    
    def _filter_by_length(self, chunks: List[str], max_length: int) -> List[str]:
        """
        按长度过滤上下文
        """
        result = []
        current_length = 0
        
        for chunk in chunks:
            if current_length + len(chunk) <= max_length:
                result.append(chunk)
                current_length += len(chunk)
            else:
                break
                
        return result
    
    def _filter_by_completeness(self, chunks: List[str], question: str) -> List[str]:
        """
        确保上下文的完整性
        """
        # 检查是否有完整的主题覆盖
        question_keywords = set(question.lower().split())
        
        # 简化判断：如果有足够的chunks，认为完整
        if len(chunks) >= 3:
            return chunks
        else:
            # 如果chunks太少，返回所有可用chunks
            return chunks
​

步骤2：高级提示策略

2.1 多轮对话提示

class ConversationAwarePrompt:
    """
    多轮对话提示设计器
    """
    
    def __init__(self):
        self.conversation_history = []
        self.max_history = 5
        
    def add_to_history(self, user_input: str, system_response: str):
        """
        添加对话历史
        """
        self.conversation_history.append({
            'user': user_input,
            'system': system_response
        })
        
        # 保持历史长度限制
        if len(self.conversation_history) > self.max_history:
            self.conversation_history.pop(0)
    
    def build_conversation_prompt(self, context: str, current_question: str) -> str:
        """
        构建多轮对话提示
        """
        # 格式化对话历史
        history_text = ""
        for i, (user, system) in enumerate(self.conversation_history):
            history_text += f"""
历史对话 {i+1}:
用户: {user}
系统: {system}
"""
        
        prompt = f"""
对话历史：
{history_text}

当前上下文：
{context}

当前用户问题：{current_question}

多轮回答要求：
1. 基于完整对话历史理解用户意图
2. 保持对话的连续性
3. 回答要自然流畅，符合对话逻辑
4. 对于复杂问题，可以分步骤回答
5. 适当引用之前的对话内容

当前回答：
"""
        
        return prompt
    
    def summarize_conversation(self, context: str) -> str:
        """
        总结对话历史以构建简洁提示
        """
        if not self.conversation_history:
            return context
            
        # 构建对话总结
        summary = "对话历史总结：\n"
        
        for i, (user, system) in enumerate(self.conversation_history):
            summary += f"Q{i+1}: {user[:50]}...\n"
            summary += f"A{i+1}: {system[:100]}...\n\n"
        
        summary += f"\n新上下文：{context}"
        
        return summary
​

2.2 代码生成提示

class CodeGenerationPrompt:
    """
    代码生成提示设计器
    """
    
    def __init__(self):
        self.code_styles = {
            'basic': self._basic_code_style,
            'documented': self._documented_code_style,
            'production': self._production_code_style
        }
    
    def build_code_prompt(self, context: str, requirements: str, 
                         style: str = 'documented') -> str:
        """
        构建代码生成提示
        """
        style_func = self.code_styles.get(style, self._documented_code_style)
        
        prompt = f"""
基于以下技术文档和需求，生成高质量的{style}代码：

【技术文档】
{context}

【需求描述】
{requirements}

【代码要求】
{style_func()}

【输出格式】
请按照以下格式输出代码：

```python
# 完整的代码实现
​

【代码说明】

简要说明代码的主要功能和关键实现点

【使用示例】

提供代码的使用示例

"""

    return prompt

def _basic_code_style(self) -> str:
    return "1. 提供基础功能实现\n2. 包含必要的错误处理\n3. 代码简洁易读"

def _documented_code_style(self) -> str:
    return """1. 包含完整的文档字符串
​

2. 有清晰的注释说明

3. 良好的函数和变量命名

4. 适当的类型提示

5. 包含单元测试示例

6. 遵循PEP 8规范"""

   def _production_code_style(self) -> str:
   return """1. 完整的生产级代码

7. 全面的错误处理和日志记录

8. 配置文件支持

9. 性能优化

10. 安全考虑

11. 监控和指标

12. 部署说明"""

## 完整示例

### 完整的提示工程系统

```python
class PromptEngineeringSystem:
    """
    完整的提示工程系统
    """
    
    def __init__(self):
        self.simple_qa = SimpleQAPrompt()
        self.context_aware = ContextAwarePrompt()
        self.conversation = ConversationAwarePrompt()
        self.code_generator = CodeGenerationPrompt()
        
    def process_query(self, query_type: str, context: str, 
                     question: str, **kwargs) -> str:
        """
        根据查询类型处理请求
        """
        if query_type == 'simple':
            return self.simple_qa.build_prompt(context, question)
        elif query_type == 'enhanced':
            return self.context_aware.build_enhanced_prompt(
                context, question, **kwargs
            )
        elif query_type == 'conversation':
            # 添加到对话历史
            if 'response' in kwargs:
                self.conversation.add_to_history(question, kwargs['response'])
            return self.conversation.build_conversation_prompt(
                context, question
            )
        elif query_type == 'code':
            return self.code_generator.build_code_prompt(
                context, question, kwargs.get('style', 'documented')
            )
        else:
            raise ValueError(f"不支持的查询类型: {query_type}")
    
    def evaluate_prompt_quality(self, prompt: str, expected_response: str,
                              actual_response: str) -> Dict:
        """
        评估提示质量
        """
        # 这里可以实现更复杂的评估逻辑
        evaluation = {
            'prompt_length': len(prompt),
            'relevance_score': self._calculate_relevance(prompt, actual_response),
            'completeness_score': self._calculate_completeness(
                expected_response, actual_response
            ),
            'clarity_score': self._calculate_clarity(actual_response),
            'total_score': 0  # 将根据各项指标计算
        }
        
        # 计算总分
        evaluation['total_score'] = (
            evaluation['relevance_score'] * 0.3 +
            evaluation['completeness_score'] * 0.4 +
            evaluation['clarity_score'] * 0.3
        )
        
        return evaluation
    
    def _calculate_relevance(self, prompt: str, response: str) -> float:
        """计算相关性分数"""
        # 简化的相关性计算
        prompt_words = set(prompt.lower().split())
        response_words = set(response.lower().split())
        
        if not prompt_words:
            return 0.5
        
        overlap = len(prompt_words & response_words)
        return min(1.0, overlap / len(prompt_words))
    
    def _calculate_completeness(self, expected: str, actual: str) -> float:
        """计算完整性分数"""
        expected_words = set(expected.lower().split())
        actual_words = set(actual.lower().split())
        
        if not expected_words:
            return 0.5
            
        coverage = len(expected_words & actual_words)
        return min(1.0, coverage / len(expected_words))
    
    def _calculate_clarity(self, response: str) -> float:
        """计算清晰度分数"""
        # 基于响应长度和结构评估
        word_count = len(response.split())
        
        # 适当的长度
        length_score = 1.0 if 50 <= word_count <= 500 else 0.5
        
        # 句子结构
        sentences = response.split('.')
        avg_sentence_length = word_count / len(sentences) if sentences else 0
        structure_score = 1.0 if 10 <= avg_sentence_length <= 30 else 0.5
        
        return (length_score + structure_score) / 2
​

常见问题 FAQ

Q1：如何设计针对特定领域的提示词？

A：设计特定领域提示词的关键步骤：

1. 领域分析：深入了解目标领域的专业术语和知识结构
2. 用户调研：了解目标用户的实际需求和痛点
3. 模板设计：创建适合该领域的提示模板
4. 迭代优化：基于实际反馈持续改进提示设计
5. 标准化：建立统一的提示设计标准

Q2：提示词过长会有什么影响？如何处理？

A：提示词过长的处理方法：

• 分段处理：将复杂提示分解为多个简单提示
• 内容摘要：使用LLM对冗长上下文进行摘要
• 优先级排序：保留最重要的信息，去除冗余内容
• 分层提示：先提供概览，再深入细节

Q3：如何处理多轮对话中的上下文管理？

A：多轮对话上下文管理策略：

• 历史总结：定期总结对话历史，控制长度
• 关键信息提取：保留对话中的关键信息点
• 对话状态跟踪：维护对话的当前状态和主题
• 动态上下文：根据对话进展动态调整上下文范围

最佳实践与避坑

最佳实践

1. 迭代优化：持续测试和改进提示设计
2. A/B测试：比较不同提示策略的效果
3. 用户反馈：收集用户评价指导优化方向
4. 性能监控：监控提示生成的时间和资源消耗
5. 版本管理：维护提示模板的版本历史

常见陷阱

• 过度复杂：提示词过于复杂可能导致理解困难
• 信息冗余：包含过多无关信息影响响应质量
• 缺乏测试：没有充分测试提示的效果
• 静态设计：提示设计缺乏动态调整能力
• 忽视边界：没有考虑各种异常情况

本节小结

本节深入讲解了RAG系统中的提示工程实践：

1. 基础概念：理解提示工程在RAG系统中的核心作用
2. 设计原则：掌握了提示设计的5个核心原则
3. 技术实现：学习了从简单到复杂的提示设计方法
4. 实际应用：掌握了不同场景下的提示策略
5. 质量评估：学会了如何评估和优化提示质量

提示工程是RAG系统成功的关键因素，需要根据具体应用场景进行精细化设计。下一节我们将探讨上下文管理的重要技术。

延伸阅读

• 官方文档：OpenAI提示工程指南（文字描述，不带链接）
• 相关章节：本教程5.3节上下文管理（文字描述，不带链接）

关键词：RAG知识库实战, 提示工程, prompt设计, 上下文增强, 对话管理, 代码生成
难度：进阶
预计阅读：45分钟