4.2 提示模板设计 — LLM优化的艺术

本节导读：掌握提示工程的核心原理和Haystack中的模板设计技术，学会构建高效的提示模板来优化LLM的输出质量。

学习目标

• 理解提示工程的基本原理和重要性
• 掌握Haystack中提示模板的使用方法
• 学会设计不同类型的提示模板
• 掌握提示优化和调试的最佳实践

核心概念

提示模板是指导LLM生成高质量回答的核心工具，通过结构化的方式向模型提供上下文信息、指令和约束条件。

提示模板的重要性

1. 质量提升：显著提升LLM输出的准确性、相关性和专业性
2. 一致性保证：确保相同类型的问题得到格式统一、风格一致的回答
3. 可控性增强：通过模板约束控制输出的格式、长度和内容范围
4. 效率优化：减少手动编写完整提示的工作量

提示模板的类型

1. 指令型模板

以明确的指令为导向，指导模型如何处理输入和生成输出。

2. 模板型模板

使用变量占位符，支持动态内容替换，实现模板复用。

3. 少样本模板

通过示例展示期望的输出格式和质量，引导模型生成类似结果。

环境准备 / 前置知识

基础依赖

# 核心依赖
pip install haystack-ai jinja2

# 可选依赖
pip install langchain-community
​

概念理解

from typing import Dict, Any, List
from jinja2 import Template

class PromptTemplate:
    """基础提示模板类"""
    
    def __init__(self, template: str, variables: List[str]):
        self.template = Template(template)
        self.variables = variables
    
    def render(self, **kwargs) -> str:
        """渲染提示模板"""
        # 验证必需变量
        missing_vars = set(self.variables) - set(kwargs.keys())
        if missing_vars:
            raise ValueError(f"缺少必需变量: {missing_vars}")
        
        return self.template.render(**kwargs)

# 使用示例
qa_template = PromptTemplate(
    template="""你是一个专业的{{ role }}助手。

请基于以下信息回答用户问题：
- 背景信息：{{ context }}
- 用户问题：{{ query }}

请按照以下格式回答：
## 答案
{{ answer }}

## 解释
{{ explanation }}""",
    variables=["role", "context", "query", "answer", "explanation"]
)

# 渲染模板
prompt = qa_template.render(
    role="技术文档",
    context="检索增强生成（RAG）是一种结合信息检索和生成式AI的技术。",
    query="什么是RAG技术？",
    answer="RAG技术通过检索相关信息来增强生成模型的回答质量。",
    explanation="RAG技术解决了传统语言模型可能产生不准确或幻觉信息的问题。"
)

print("生成的提示：")
print(prompt)
​

分步实战

步骤1：基础提示模板

简单问答模板

from haystack.components.builders import PromptBuilder
from haystack.components.generators import OpenAIGenerator

class SimpleQATemplate:
    """简单问答提示模板"""
    
    def __init__(self, api_key: str, model: str = "gpt-3.5-turbo"):
        # 初始化提示构建器
        self.prompt_builder = PromptBuilder(
            template="""你是一个专业的知识库助手。

请基于以下上下文信息回答用户的问题。如果上下文信息不足以回答问题，
请基于你的知识回答，并说明信息来源。

上下文信息：
{{ context }}

用户问题：{{ query }}

请提供准确、完整的回答。""",
            required_variables=["context", "query"]
        )
        
        # 初始化LLM生成器
        self.llm = OpenAIGenerator(
            api_key=api_key,
            model=model,
            max_tokens=500,
            generation_kwargs={"temperature": 0.3}
        )
    
    def answer_question(self, context: str, query: str) -> str:
        """回答问题"""
        # 构建提示
        prompt_dict = self.prompt_builder._prepare_prompt(context=context, query=query)
        prompt_text = prompt_dict["prompt"]
        
        # 生成回答
        result = self.llm.run(prompt=prompt_text)
        return result["replies"][0]

# 使用示例
qa_template = SimpleQATemplate(api_key="your-openai-key")

# 测试问答
response = qa_template.answer_question(
    context="检索增强生成（RAG）是一种结合信息检索和生成式AI的技术，通过检索相关文档来增强模型回答的准确性和可靠性。",
    query="什么是RAG技术？"
)

print("回答：", response)
​

摘要生成模板

class SummaryTemplate:
    """摘要生成提示模板"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        
    def create_summary_prompt(self, text: str, summary_type: str = "brief"):
        """创建摘要提示"""
        
        summary_templates = {
            "brief": """请对以下文本进行简要摘要，控制在200字以内：

文本内容：
{{ text }}

摘要要求：
- 提取核心观点和关键信息
- 保持客观、准确
- 语言简洁明了

摘要：""",
            
            "detailed": """请对以下文本进行详细摘要：

文本内容：
{{ text }}

摘要要求：
1. 提取主要观点和论证
2. 包含重要的数据和事实
3. 保留原文的逻辑结构
4. 控制在400-600字之间

摘要：""",
            
            "structured": """请对以下文本进行结构化摘要：

文本内容：
{{ text }}

请按照以下格式输出：
## 核心主题
[文本的核心主题]

## 主要观点
- 观点1
- 观点2
- 观点3

## 关键信息
- 信息1
- 信息2
- 信息3

## 总结
[对文本的整体总结]"""
        }
        
        template = summary_templates.get(summary_type, summary_templates["brief"])
        return template.replace("{{ text }}", text)

# 使用示例
summary_template = SummaryTemplate(api_key="your-openai-key")

long_text = """
人工智能（AI）正在改变我们的生活方式。从智能手机的语音助手到自动驾驶汽车，
AI技术已经深入到我们日常生活的各个方面。机器学习作为AI的核心技术，
通过算法让计算机能够从数据中学习并做出预测和决策。深度学习作为机器学习
的一个重要分支，使用神经网络来模拟人脑的工作方式。近年来，大语言模型（LLM）
的出现更是 revolutionized 自然语言处理领域，使得AI能够理解和生成人类语言。
"""

# 不同类型的摘要
brief_prompt = summary_template.create_summary_prompt(long_text, "brief")
detailed_prompt = summary_template.create_summary_prompt(long_text, "detailed")
structured_prompt = summary_template.create_summary_prompt(long_text, "structured")

print("简要摘要提示：")
print(brief_prompt)
​

步骤2：高级提示模板

条件提示模板

class ConditionalTemplate:
    """条件提示模板"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
    
    def create_conditional_prompt(self, 
                                query: str, 
                                context: str, 
                                query_type: str,
                                difficulty: str = "normal"):
        """创建条件提示模板"""
        
        # 根据查询类型生成不同的提示
        type_templates = {
            "factual": """你是一个事实核查专家。

任务：回答以下问题，确保答案准确、客观。

背景信息：{{ context }}
用户问题：{{ query }}

要求：
1. 基于给定背景信息回答
2. 如果信息不足，请明确说明
3. 避免主观推测
4. 提供准确的数据和事实

回答：""",
            
            "opinion": """你是一个中立的分析师。

任务：分析以下问题并提供客观的观点。

背景信息：{{ context }}
用户问题：{{ query }}

要求：
1. 分析问题的多个角度
2. 提供不同观点的平衡分析
3. 保持中立立场
4. 基于事实进行推理

分析：""",
            
            "creative": """你是一个创意写作专家。

任务：以创意方式回答以下问题。

背景信息：{{ context }}
用户问题：{{ query }}

要求：
1. 运用创造性思维
2. 提供新颖独特的观点
3. 保持内容相关性
4. 激发读者兴趣

创意回答："""
        }
        
        # 根据难度调整提示
        difficulty_modifiers = {
            "easy": "要求：使用简单易懂的语言，避免复杂术语。\n",
            "normal": "",
            "advanced": "要求：使用专业术语，提供深入的技术细节和分析。\n"
        }
        
        # 组合提示
        base_template = type_templates.get(query_type, type_templates["factual"])
        difficulty_modifier = difficulty_modifiers.get(difficulty, difficulty_modifiers["normal"])
        
        full_prompt = f"{base_template}\n{difficulty_modifier}\n\n背景信息：{context}\n用户问题：{query}"
        
        return full_prompt

# 使用示例
conditional_template = ConditionalTemplate(api_key="your-openai-key")

# 不同条件的提示
factual_prompt = conditional_template.create_conditional_prompt(
    query="什么是RAG技术？",
    context="检索增强生成（RAG）是一种结合信息检索和生成式AI的技术。",
    query_type="factual",
    difficulty="easy"
)

opinion_prompt = conditional_template.create_conditional_prompt(
    query="RAG技术的未来发展方向是什么？",
    context="当前RAG技术已经在多个领域得到应用，包括搜索引擎、智能客服等。",
    query_type="opinion",
    difficulty="normal"
)

print("事实查询提示：")
print(factual_prompt)
​

少样本学习模板

class FewShotTemplate:
    """少样本学习提示模板"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
    
    def create_few_shot_prompt(self, 
                              query: str, 
                              context: str, 
                              examples: List[Dict[str, str]],
                              task_type: str = "qa"):
        """创建少样本学习提示"""
        
        # 根据任务类型选择模板
        templates = {
            "qa": """你是一个专业的问答助手。

请基于示例的格式和风格回答用户问题。

示例：
{% for example in examples %}
问题：{{ example.question }}
答案：{{ example.answer }}
{% endfor %}

现在请回答以下问题：
背景信息：{{ context }}
用户问题：{{ query }}

请按照示例的格式和风格回答：""",
            
            "classification": """你是一个文本分类专家。

请根据示例中的分类模式对文本进行分类。

示例：
{% for example in examples %}
文本：{{ example.text }}
分类：{{ example.category }}
{% endfor %}

现在请分类以下文本：
文本：{{ context }}
分类：""",
            
            "translation": """你是一个专业的翻译助手。

请根据示例的翻译风格进行翻译。

示例：
{% for example in examples %}
原文：{{ example.original }}
译文：{{ example.translation }}
{% endfor %}

现在请翻译以下文本：
原文：{{ context }}
译文："""
        }
        
        selected_template = templates.get(task_type, templates["qa"])
        
        # 使用Jinja2模板渲染
        from jinja2 import Template
        template = Template(selected_template)
        
        prompt = template.render(
            context=context,
            query=query,
            examples=examples
        )
        
        return prompt
    
    def generate_examples(self, task_type: str) -> List[Dict[str, str]]:
        """生成示例数据"""
        examples = {
            "qa": [
                {"question": "什么是机器学习？", "answer": "机器学习是人工智能的一个分支，让计算机能够从数据中学习模式。"},
                {"question": "什么是深度学习？", "answer": "深度学习是机器学习的一个子领域，使用多层神经网络处理复杂数据。"}
            ],
            "classification": [
                {"text": "这是一篇关于人工智能的文章", "category": "技术"},
                {"text": "最新的体育赛事结果", "category": "体育"},
                {"text": "公司的季度财务报告", "category": "商业"}
            ],
            "translation": [
                {"original": "Hello, how are you?", "translation": "你好，你好吗？"},
                {"original": "The weather is nice today.", "translation": "今天天气很好。"}
            ]
        }
        
        return examples.get(task_type, [])

# 使用示例
few_shot_template = FewShotTemplate(api_key="your-openai-key")

# 生成示例
qa_examples = few_shot_template.generate_examples("qa")

# 创建少样本提示
few_shot_prompt = few_shot_template.create_few_shot_prompt(
    query="什么是自然语言处理？",
    context="自然语言处理是人工智能的一个重要分支，让计算机能够理解和生成人类语言。",
    examples=qa_examples,
    task_type="qa"
)

print("少样本学习提示：")
print(few_shot_prompt)
​

步骤3：动态提示模板

基于上下文的动态模板

class DynamicTemplate:
    """动态提示模板"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
    
    def create_context_aware_prompt(self, 
                                   query: str,
                                   context: str,
                                   user_profile: Dict[str, Any],
                                   conversation_history: List[str] = None):
        """创建基于上下文的动态提示"""
        
        # 根据用户角色调整提示
        role_templates = {
            "expert": """你是一个技术专家，能够提供专业、详细的技术解释。

用户背景：
- 角色：{{ user_role }}
- 专业领域：{{ user_expertise }}
- 经验水平：{{ user_level }}

当前对话历史：
{% if conversation_history %}
{% for message in conversation_history %}
{{ message }}
{% endfor %}
{% endif %}

当前问题：{{ query }}

相关上下文：{{ context }}

请从专家角度提供详细、准确的技术解答。""",
            
            "beginner": """你是一个耐心的导师，能够用简单的语言解释复杂的概念。

用户背景：
- 角色：{{ user_role }}
- 专业领域：{{ user_expertise }}
- 经验水平：{{ user_level }}

当前对话历史：
{% if conversation_history %}
{% for message in conversation_history %}
{{ message }}
{% endfor %}
{% endif %}

当前问题：{{ query }}

相关上下文：{{ context }}

请用简单易懂的语言回答，避免专业术语，必要时提供比喻和例子。"""
        }
        
        # 选择模板
        template_key = "expert" if user_profile.get("level", "beginner") == "expert" else "beginner"
        template = role_templates[template_key]
        
        # 渲染模板
        from jinja2 import Template
        prompt_template = Template(template)
        
        prompt = prompt_template.render(
            query=query,
            context=context,
            user_profile=user_profile,
            conversation_history=conversation_history
        )
        
        return prompt

# 使用示例
dynamic_template = DynamicTemplate(api_key="your-openai-key")

# 用户背景
user_profile = {
    "role": "软件工程师",
    "expertise": "机器学习",
    "level": "intermediate"
}

# 对话历史
conversation_history = [
    "用户：什么是向量嵌入？",
    "助手：向量嵌入是将文本转换为数值向量的技术。"
]

# 创建动态提示
prompt = dynamic_template.create_context_aware_prompt(
    query="RAG和传统检索有什么区别？",
    context="检索增强生成（RAG）结合了检索和生成两种技术的优势。",
    user_profile=user_profile,
    conversation_history=conversation_history
)

print("动态提示模板：")
print(prompt)
​

常见问题 FAQ

Q1：如何设计高效的提示模板？

A： 高效的提示模板设计需要考虑多个维度：

class PromptTemplateOptimizer:
    """提示模板优化器"""
    
    def __init__(self):
        self.best_practices = {
            "clarity": "使用清晰、具体的语言",
            "structure": "采用结构化的格式",
            "context": "提供充分的背景信息",
            "constraints": "明确的输出限制和要求",
            "examples": "使用示例指导期望的输出",
            "consistency": "保持模板的一致性"
        }
    
    def evaluate_template(self, template: str) -> Dict[str, Any]:
        """评估提示模板质量"""
        
        evaluation = {
            "score": 0,
            "feedback": [],
            "improvements": []
        }
        
        # 评估清晰度
        if len(template) < 100:
            evaluation["feedback"].append("提示可能过于简短")
            evaluation["improvements"].append("添加更多背景信息和详细说明")
        
        # 评估结构
        if "##" in template or "###" in template:
            evaluation["score"] += 10
            evaluation["feedback"].append("良好的结构层次")
        else:
            evaluation["improvements"].append("添加标题和分节以提高可读性")
        
        # 评估变量使用
        variables = self._extract_variables(template)
        if len(variables) >= 2:
            evaluation["score"] += 15
            evaluation["feedback"].append(f"使用了{len(variables)}个变量，提高了灵活性")
        else:
            evaluation["improvements"].append("添加更多变量以支持动态内容")
        
        # 评估示例
        if "示例" in template or "example" in template.lower():
            evaluation["score"] += 10
            evaluation["feedback"].append("包含示例，有助于模型理解期望")
        
        # 评估约束
        if "要求" in template or "约束" in template or "constraint" in template.lower():
            evaluation["score"] += 10
            evaluation["feedback"].append("包含明确的约束条件")
        
        return evaluation
    
    def _extract_variables(self, template: str) -> List[str]:
        """提取模板变量"""
        import re
        # 查找 {{ variable }} 格式的变量
        variables = re.findall(r'\{\{\s*(\w+)\s*\}\}', template)
        return list(set(variables))
    
    def optimize_template(self, template: str) -> str:
        """优化提示模板"""
        
        # 基础优化：添加结构
        optimized = template
        
        # 添加标题
        if "你是一个" not in optimized:
            optimized = "## 角色设定\n你是一个专业的AI助手。\n\n" + optimized
        
        # 添加格式要求
        if "格式" not in optimized and "要求" not in optimized:
            optimized += "\n## 输出要求\n请按照清晰的格式回答，确保信息准确、完整。"
        
        # 添加验证
        if "检查" not in optimized:
            optimized += "\n## 验证\n请确保回答准确无误，符合要求。"
        
        return optimized

# 使用示例
optimizer = PromptTemplateOptimizer()

# 原始模板
original_template = """请基于以下信息回答问题：
{{ context }}

问题：{{ query }}

回答："""

# 评估模板
evaluation = optimizer.evaluate_template(original_template)
print("模板评估结果：")
print(f"得分：{evaluation['score']}")
print("反馈：", evaluation['feedback'])
print("改进建议：", evaluation['improvements'])

# 优化模板
optimized_template = optimizer.optimize_template(original_template)
print("\n优化后的模板：")
print(optimized_template)
​

Q2：如何处理模板中的变量缺失问题？

A： 变量缺失是常见问题，需要建立健壮的处理机制：

class RobustTemplateHandler:
    """健壮的模板处理器"""
    
    def __init__(self, templates: Dict[str, str]):
        self.templates = templates
        self.required_variables = self._extract_required_variables()
    
    def _extract_required_variables(self) -> Dict[str, List[str]]:
        """提取每个模板的必需变量"""
        import re
        required = {}
        
        for template_name, template_content in self.templates.items():
            variables = re.findall(r'\{\{\s*(\w+)\s*\}\}', template_content)
            required[template_name] = list(set(variables))
        
        return required
    
    def render_template(self, template_name: str, variables: Dict[str, Any], 
                       fallback_values: Dict[str, str] = None) -> str:
        """渲染模板，处理缺失变量"""
        
        if template_name not in self.templates:
            raise ValueError(f"模板 '{template_name}' 不存在")
        
        # 获取模板内容
        template_content = self.templates[template_name]
        
        # 检查必需变量
        required_vars = self.required_variables[template_name]
        provided_vars = set(variables.keys())
        missing_vars = set(required_vars) - provided_vars
        
        if missing_vars:
            print(f"警告：缺少变量 {missing_vars}")
            
            # 使用默认值
            if fallback_values:
                for var in missing_vars:
                    if var in fallback_values:
                        variables[var] = fallback_values[var]
                        print(f"使用默认值替换变量 {var}")
                    else:
                        raise ValueError(f"缺少必需变量 {var} 且未提供默认值")
            else:
                raise ValueError(f"缺少必需变量 {missing_vars}")
        
        # 渲染模板
        from jinja2 import Template
        template = Template(template_content)
        result = template.render(**variables)
        
        return result
    
    def validate_variables(self, template_name: str, variables: Dict[str, Any]) -> bool:
        """验证变量是否完整"""
        
        if template_name not in self.templates:
            return False
        
        required_vars = self.required_variables[template_name]
        provided_vars = set(variables.keys())
        
        return required_vars.issubset(provided_vars)

# 使用示例
# 定义模板
templates = {
    "qa": """你是一个问答助手。

请基于以下信息回答问题：
- 背景：{{ background }}
- 问题：{{ question }}
- 上下文：{{ context }}

请提供准确、有用的回答。""",
    
    "summary": """请对以下文本进行摘要：
{{ text }}

要求：
1. 提取核心观点
2. 控制在{{ max_length }}字以内
3. 保持客观准确"""
}

# 创建处理器
template_handler = RobustTemplateHandler(templates)

# 测试完整变量
qa_variables = {
    "background": "背景信息",
    "question": "什么是RAG？",
    "context": "RAG是检索增强生成技术。"
}

try:
    result = template_handler.render_template("qa", qa_variables)
    print("完整变量渲染结果：")
    print(result)
except Exception as e:
    print(f"错误：{e}")

# 测试缺失变量
incomplete_variables = {
    "background": "背景信息",
    "question": "什么是RAG？"
    # 缺少 context 变量
}

try:
    result = template_handler.render_template("qa", incomplete_variables)
    print("\n缺失变量渲染结果：")
    print(result)
except Exception as e:
    print(f"错误：{e}")

# 使用默认值
fallback_values = {
    "context": "无上下文信息"
}

try:
    result = template_handler.render_template(
        "qa", 
        incomplete_variables, 
        fallback_values=fallback_values
    )
    print("\n使用默认值渲染结果：")
    print(result)
except Exception as e:
    print(f"错误：{e}")
​

最佳实践与避坑

实践1：模板设计原则

• 清晰明确：使用清晰、具体的语言，避免歧义
• 结构化：采用层次分明的结构，便于理解
• 变量化：使用变量实现模板复用和动态内容
• 示例引导：通过示例指导期望的输出格式
• 约束明确：明确输出限制和要求，避免偏离预期

实践2：性能优化策略

• 简洁高效：移除冗余信息，保持提示简洁
• 批量处理：合并相似提示，提高处理效率
• 缓存机制：缓存常用提示模板和结果
• 异步处理：使用异步I/O提高并发能力

实践3：版本控制

• 模板管理：建立模板版本管理系统
• 变更追踪：记录模板变更历史和原因
• A/B测试：通过A/B测试验证模板效果

坑点1：变量混乱

• 问题表现：模板中变量定义不清或重复
• 解决方案：统一变量命名规范，建立变量映射表
• 预防措施：使用变量验证工具，定期检查变量使用

坑点2：输出不一致

• 问题表现：相同输入得到不同格式输出
• 解决方案：加强模板约束，添加输出格式要求
• 预防措施：使用示例约束，建立格式检查机制

坑点3：性能瓶颈

• 问题表现：模板渲染速度慢，影响用户体验
• 解决方案：优化模板结构，简化复杂逻辑
• 预防措施：性能监控，定期优化模板设计

本节小结

本节详细介绍了Haystack中提示模板设计的完整实现，涵盖了从基础模板到高级模板的各个方面。我们学习了：

1. 基础提示模板：问答模板、摘要模板的设计和使用
2. 高级提示模板：条件模板、少样本模板的设计原理和实现
3. 动态提示模板：基于上下文和内容的智能模板生成
4. 模板优化技术：性能优化、一致性保证、版本控制
5. 测试和调试：系统化的模板测试方法和调试技巧

提示工程是LLM应用的核心技术，通过精心设计的提示模板可以显著提升系统的输出质量和用户体验。通过本节的学习，我们已经掌握了构建高效、可靠、可扩展的提示模板系统的关键技术。

下一节我们将学习4.3生成优化，深入研究如何通过参数调优、后处理和评估方法来进一步提升LLM的生成质量。

延伸阅读

• Haystack官方文档 - Prompt Templates
• Jinja2模板引擎文档
• Prompt Engineering Guide
• OpenAI Prompt Engineering
• LangChain Prompt Templates

关键词：提示模板, 提示工程, Jinja2, 模板设计, 少样本学习, 动态模板, 性能优化
难度：进阶
预计阅读：25分钟