本期导读
在前五期，我们学习了RAG检索增强、Function Calling工具调用、MCP协议、Agent架构和A2A协作。现在我们要深入探讨如何与AI有效沟通——Prompt Engineering（提示词工程）。
Prompt Engineering不是简单的"问问题"，而是系统性的AI交互技术，通过精心设计的提示词来引导AI产生更准确、更可靠的输出。
本文将深入讲解提示词工程的核心原理、设计方法、优化技巧和实际应用。
本文内容包括：
- AI提问的多种方式和最佳实践
- 提示词的系统化设计方法
- 提示词的组成结构和各部分作用
- 温度参数的含义和调整策略
- 提示词模板和工程化实践
- 提示词优化和评估方法
- Java实战：构建提示词管理系统
- 生产环境的提示词最佳实践
一、AI提问的多种方式
1.1 提问方式分类
1.1.1 按问题类型分类
| 问题类型 | 特点 | 示例 | 适用场景 |
|---|---|---|---|
| 直接提问 | 简单直接，一问一答 | "什么是人工智能？" | 知识查询、概念解释 |
| 引导式提问 | 通过上下文引导回答 | "基于你的专业知识，请分析..." | 专业分析、深度思考 |
| 对比式提问 | 要求比较不同选项 | "比较A和B的优缺点" | 决策支持、方案选择 |
| 假设式提问 | 基于假设条件提问 | "如果...会怎样？" | 情景分析、预测 |
| 步骤式提问 | 要求分步骤回答 | "请分步骤说明..." | 流程指导、教学 |
| 角色扮演 | 让AI扮演特定角色 | "你是一个专业医生..." | 专业咨询、模拟对话 |
1.1.2 按复杂度分类
简单提问：
用户：什么是机器学习？
AI：机器学习是人工智能的一个分支...
复杂提问：
用户：请分析机器学习在金融风控中的应用，包括：
1. 主要技术方法
2. 实际应用案例
3. 面临的挑战
4. 未来发展趋势
请结合具体数据和技术细节进行说明。
AI：[详细的多维度分析]
1.2 如何提问才能更加准确可靠
1.2.1 提问的5W1H原则
Who（谁）： 明确目标受众
❌ 不好的提问：解释一下区块链
✅ 好的提问：请向一个没有技术背景的投资者解释区块链的基本概念
What（什么）： 明确具体内容
❌ 不好的提问：帮我写代码
✅ 好的提问：请用Java写一个单例模式的实现，要求线程安全
When（何时）： 明确时间范围
❌ 不好的提问：分析市场趋势
✅ 好的提问：分析2024年人工智能市场的趋势变化
Where（何地）： 明确应用场景
❌ 不好的提问：设计一个系统
✅ 好的提问：设计一个适用于中小企业的客户关系管理系统
Why（为什么）： 明确目的和原因
❌ 不好的提问：推荐一些技术
✅ 好的提问：为了构建一个高并发的电商系统，请推荐合适的技术栈并说明原因
How（如何）： 明确方法和步骤
❌ 不好的提问：优化性能
✅ 好的提问：请提供3种优化数据库查询性能的方法，并说明每种方法的适用场景
1.2.2 提问的STAR方法
Situation（情境）： 描述背景情况
"在当前的微服务架构中，我们遇到了服务间通信延迟过高的问题..."
Task（任务）： 明确具体任务
"需要设计一个服务间通信优化方案..."
Action（行动）： 说明期望的行动
"请提供具体的优化策略和实现方案..."
Result（结果）： 明确期望的结果
"目标是降低通信延迟50%以上，同时保证系统稳定性..."
1.2.3 提问的最佳实践
1. 提供充分的上下文
❌ 不好的提问：
"帮我写一个函数"
✅ 好的提问：
"我需要一个Java函数，用于验证邮箱格式。要求：
- 支持常见的邮箱格式
- 返回boolean类型
- 包含详细的注释
- 处理边界情况"
2. 使用具体的示例
❌ 不好的提问：
"如何优化数据库查询？"
✅ 好的提问：
"我有一个用户表查询，当前SQL是：
SELECT * FROM users WHERE age > 25 AND city = 'Beijing'
查询很慢，请提供优化建议。表结构如下：
- users表有100万条记录
- age字段有索引
- city字段没有索引"
3. 明确输出格式
❌ 不好的提问：
"分析一下这个需求"
✅ 好的提问：
"请分析以下需求，输出格式要求：
1. 需求概述
2. 技术难点
3. 实现方案
4. 风险评估
5. 时间估算"
4. 设置约束条件
❌ 不好的提问：
"设计一个架构"
✅ 好的提问：
"设计一个微服务架构，约束条件：
- 团队规模：5人
- 预算：有限
- 技术栈：Java + Spring Boot
- 部署：云原生
- 性能：支持1000并发用户"
二、提示词的设计
2.1 提示词设计原则
2.1.1 清晰性原则
明确性： 避免歧义，使用精确的语言
❌ 模糊：帮我处理数据
✅ 明确：请将CSV文件中的用户数据按年龄分组，计算每组的平均收入
具体性： 提供具体的细节和要求
❌ 抽象：写一个算法
✅ 具体：实现一个快速排序算法，要求：
- 时间复杂度O(n log n)
- 空间复杂度O(log n)
- 包含详细注释
- 处理重复元素
2.1.2 结构化原则
层次化： 使用标题、编号、列表等结构化元素
请按以下结构分析问题：
## 1. 问题分析
- 核心问题
- 影响因素
- 约束条件
## 2. 解决方案
- 方案A：...
- 方案B：...
- 方案C：...
## 3. 推荐方案
- 选择理由
- 实施步骤
- 风险控制
模块化： 将复杂任务分解为多个模块
任务：构建一个电商系统
模块1：用户管理
- 用户注册/登录
- 用户信息管理
- 权限控制
模块2：商品管理
- 商品信息维护
- 库存管理
- 分类管理
模块3：订单管理
- 购物车
- 订单处理
- 支付集成
2.1.3 引导性原则
角色设定： 让AI扮演特定角色
你是一位资深的Java架构师，拥有10年的微服务开发经验。
请基于你的专业经验，分析以下技术选型问题...
思维引导： 引导AI的思考过程
请按以下步骤分析：
1. 首先识别问题的核心
2. 然后分析可能的解决方案
3. 接着评估每种方案的优缺点
4. 最后给出推荐方案和理由
示例引导： 提供示例来引导输出格式
请按照以下格式回答问题：
问题：[用户问题]
分析：[详细分析]
建议：[具体建议]
示例：[代码示例或案例]
示例：
问题：如何实现单例模式？
分析：单例模式确保一个类只有一个实例...
建议：推荐使用双重检查锁定模式...
示例：[代码示例]
2.2 提示词设计模式
2.2.1 Chain of Thought（思维链）
原理： 引导AI逐步思考，展示推理过程
模板：
请按以下步骤思考并回答问题：
步骤1：理解问题
- 问题的核心是什么？
- 需要解决什么？
步骤2：分析问题
- 问题的关键因素有哪些？
- 可能的解决方案是什么？
步骤3：评估方案
- 每种方案的优缺点是什么？
- 哪种方案最适合？
步骤4：得出结论
- 最终答案是什么？
- 理由是什么？
问题：[具体问题]
示例：
请按以下步骤分析这个技术问题：
步骤1：理解问题
- 问题：如何优化数据库查询性能？
- 核心：提高查询速度，减少响应时间
步骤2：分析问题
- 关键因素：索引、查询语句、数据量、硬件资源
- 可能方案：添加索引、优化SQL、分库分表、缓存
步骤3：评估方案
- 添加索引：简单有效，但影响写入性能
- 优化SQL：成本低，效果明显
- 分库分表：效果好，但复杂度高
- 缓存：效果显著，但数据一致性复杂
步骤4：得出结论
- 推荐：先优化SQL和添加索引，再考虑缓存
- 理由：成本低，效果明显，风险可控
2.2.2 Few-Shot Learning（少样本学习）
原理： 通过提供少量示例来引导AI学习期望的输出格式
模板：
以下是几个示例，请按照相同的格式回答问题：
示例1：
问题：什么是单例模式？
答案：单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。
实现方式：懒汉式、饿汉式、双重检查锁定等。
应用场景：数据库连接池、日志记录器、配置管理器等。
示例2：
问题：什么是工厂模式？
答案：工厂模式是一种创建型设计模式，通过工厂类创建对象，而不直接使用new关键字。
实现方式：简单工厂、工厂方法、抽象工厂等。
应用场景：数据库驱动、UI组件创建、插件系统等。
现在请回答：
问题：[用户问题]
答案：[按照示例格式回答]
2.2.3 Role-Playing（角色扮演）
原理： 让AI扮演特定角色，利用角色的专业知识和经验
模板：
你是一位[角色描述]，拥有[专业背景]。
你的职责是[职责描述]。
请基于你的专业知识和经验，[具体任务]。
角色：资深Java架构师
背景：10年微服务开发经验，熟悉Spring生态
职责：技术选型、架构设计、性能优化
任务：分析以下技术问题并提供专业建议
示例：
你是一位资深的DevOps工程师，拥有8年的云原生开发经验。
你熟悉Kubernetes、Docker、CI/CD等工具。
你的职责是设计部署方案、优化系统性能、保障系统稳定性。
请基于你的专业经验，分析以下部署问题：
问题：我们的Java应用在Kubernetes上部署后，经常出现内存溢出。
- 应用：Spring Boot微服务
- 配置：2核4G内存
- 问题：运行一段时间后OOM
- 环境：Kubernetes 1.24
请提供详细的诊断和解决方案。
2.2.4 Constraint-Based（约束导向）
原理： 通过设置约束条件来限制和引导AI的输出
模板：
请回答以下问题，要求：
1. 答案长度不超过200字
2. 使用专业术语
3. 提供具体示例
4. 包含实施步骤
5. 考虑成本效益
问题：[具体问题]
示例：
请设计一个用户认证系统，要求：
1. 支持多种认证方式（用户名密码、手机号、邮箱）
2. 安全性要求：密码加密、防暴力破解、会话管理
3. 性能要求：支持1000并发用户
4. 技术栈：Java + Spring Security
5. 部署：Docker容器化
6. 预算：有限
请提供：
- 技术架构图
- 核心代码示例
- 安全策略
- 性能优化方案
- 部署方案
三、提示词的组成结构
3.1 提示词的基本结构
┌─────────────────────────────────────────┐
│ 完整提示词 │
├─────────────────────────────────────────┤
│ 1. 系统提示词 (System Prompt) │
│ - 角色定义 │
│ - 行为准则 │
│ - 输出格式 │
├─────────────────────────────────────────┤
│ 2. 上下文提示词 (Context Prompt) │
│ - 背景信息 │
│ - 相关数据 │
│ - 约束条件 │
├─────────────────────────────────────────┤
│ 3. 用户提示词 (User Prompt) │
│ - 具体问题 │
│ - 期望输出 │
│ - 特殊要求 │
├─────────────────────────────────────────┤
│ 4. 示例提示词 (Example Prompt) │
│ - 输入示例 │
│ - 输出示例 │
│ - 格式说明 │
└─────────────────────────────────────────┘
3.2 系统提示词（System Prompt）
3.2.1 作用和特点
作用：
- 定义AI的角色和身份
- 设定行为准则和约束
- 指定输出格式和风格
- 提供专业知识和背景
特点：
- 影响整个对话的基调
- 通常放在提示词的开头
- 对整个对话过程有效
- 优先级最高
3.2.2 系统提示词设计
基础模板：
你是一位[角色描述]，拥有[专业背景]。
你的职责是[职责描述]。
请遵循以下原则：
1. [原则1]
2. [原则2]
3. [原则3]
输出要求：
- 格式：[格式要求]
- 语言：[语言要求]
- 长度：[长度要求]
- 风格：[风格要求]
示例：
你是一位资深的Java开发工程师，拥有8年的企业级应用开发经验。
你熟悉Spring生态、微服务架构、数据库优化等技术。
你的职责是为开发团队提供技术指导和代码审查。
请遵循以下原则：
1. 代码质量优先，注重可读性和可维护性
2. 考虑性能和安全性
3. 提供具体的实现方案和代码示例
4. 考虑团队的技术水平和项目约束
输出要求：
- 格式：使用Markdown格式，包含代码块
- 语言：使用专业术语，但保持易懂
- 长度：详细但不冗长
- 风格：专业、实用、具体
3.2.3 系统提示词类型
技术专家型：
你是一位[技术领域]专家，拥有[年限]年的[相关经验]。
你精通[技术栈]，熟悉[相关技术]。
请基于你的专业经验，提供准确、实用的技术建议。
教学指导型：
你是一位耐心的技术导师，擅长将复杂的技术概念用简单易懂的方式解释。
请用循序渐进的方式，帮助学习者理解和掌握[技术主题]。
分析评估型：
你是一位技术分析师，擅长从多个角度分析技术问题。
请提供客观、全面的分析，包括优缺点、适用场景、风险评估等。
3.3 上下文提示词（Context Prompt）
3.3.1 作用和特点
作用：
- 提供背景信息和相关数据
- 设定约束条件和限制
- 建立问题域和范围
- 提供必要的上下文
特点：
- 影响AI对问题的理解
- 提供决策的依据
- 限制输出的范围
- 提高回答的准确性
3.3.2 上下文提示词设计
背景信息：
项目背景：
- 项目类型：[项目类型]
- 团队规模：[团队规模]
- 技术栈：[技术栈]
- 预算：[预算情况]
- 时间：[时间要求]
约束条件：
约束条件：
1. 技术约束：[技术限制]
2. 资源约束：[资源限制]
3. 时间约束：[时间限制]
4. 合规约束：[合规要求]
相关数据：
相关数据：
- 用户数量：[用户规模]
- 数据量：[数据规模]
- 性能要求：[性能指标]
- 可用性要求：[可用性指标]
示例：
项目背景：
- 项目类型：电商平台
- 团队规模：15人（5个后端，3个前端，2个测试，2个运维，3个产品）
- 技术栈：Java + Spring Boot + MySQL + Redis + Vue.js
- 预算：有限，优先使用开源方案
- 时间：6个月上线
约束条件：
1. 技术约束：必须使用Java技术栈，数据库使用MySQL
2. 资源约束：服务器资源有限，需要优化性能
3. 时间约束：开发周期紧张，需要快速迭代
4. 合规约束：需要符合数据保护法规
相关数据：
- 用户数量：预期10万注册用户，日活1万
- 数据量：商品数据10万条，订单数据100万条
- 性能要求：页面响应时间<2秒，支持1000并发
- 可用性要求：99.9%可用性
3.4 用户提示词（User Prompt）
3.4.1 作用和特点
作用：
- 提出具体的问题或需求
- 指定期望的输出内容
- 设置特殊的要求
- 触发AI的响应
特点：
- 直接影响AI的回答
- 决定输出的具体内容
- 可以包含多个子问题
- 支持迭代和细化
3.4.2 用户提示词设计
问题描述：
问题：[具体问题描述]
期望：[期望的输出]
要求：[特殊要求]
示例：
问题：设计一个用户认证系统，支持多种登录方式
期望：提供完整的技术方案，包括架构设计、核心代码、安全策略
要求：
1. 支持用户名密码、手机号、邮箱登录
2. 集成第三方登录（微信、QQ）
3. 实现单点登录（SSO）
4. 包含密码重置功能
5. 提供详细的实现步骤
3.5 示例提示词（Example Prompt）
3.5.1 作用和特点
作用：
- 提供输入输出示例
- 指导输出格式
- 展示期望的质量
- 减少理解偏差
特点：
- 通过示例学习
- 格式标准化
- 质量参考
- 减少错误
3.5.2 示例提示词设计
Few-Shot示例：
以下是几个示例，请按照相同的格式和风格回答问题：
示例1：
输入：如何实现单例模式？
输出：
## 单例模式实现
### 1. 懒汉式（线程不安全）
```java
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. 懒汉式（线程安全）
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
3. 双重检查锁定
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
现在请回答： 输入：[用户问题] 输出：[按照示例格式回答]
---
## 四、温度参数的含义和调整策略
### 4.1 温度参数的含义
#### 4.1.1 技术原理
**温度（Temperature）**是控制AI输出随机性的重要参数：
- **取值范围：** 0.0 - 2.0（通常使用0.0 - 1.0）
- **默认值：** 0.7（大多数模型的默认值）
- **作用机制：** 影响token选择的概率分布
**数学原理：**
P(token) = exp(logits/temperature) / Σ(exp(logits/temperature))
#### 4.1.2 温度对输出的影响
| 温度值 | 输出特点 | 适用场景 | 示例 |
|--------|----------|----------|------|
| **0.0** | 完全确定性，每次输出相同 | 代码生成、数学计算、事实查询 | 1+1=2（总是相同） |
| **0.1-0.3** | 高度确定性，轻微变化 | 技术文档、API文档、标准答案 | 技术问题（答案基本一致） |
| **0.4-0.6** | 平衡确定性和创造性 | 一般对话、问题解答 | 日常问答（有变化但合理） |
| **0.7-0.9** | 较高创造性，适度变化 | 创意写作、头脑风暴 | 创意内容（有变化和创意） |
| **1.0-2.0** | 高创造性，大幅变化 | 艺术创作、实验性内容 | 诗歌、故事（高度创意） |
### 4.2 温度调整策略
#### 4.2.1 基于任务类型的调整
**确定性任务（Temperature: 0.0-0.3）**
```java
// 代码生成
@Configuration
public class CodeGenerationConfig {
@Bean
public ChatModel codeGenerationModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.1) // 低温度，确保代码准确性
.build();
}
}
// 数学计算
@Bean
public ChatModel mathCalculationModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.0) // 零温度，确保计算准确性
.build();
}
平衡性任务（Temperature: 0.4-0.6）
// 技术问答
@Bean
public ChatModel technicalQAModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.5) // 中等温度，平衡准确性和多样性
.build();
}
// 文档生成
@Bean
public ChatModel documentationModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.4) // 稍低温度，保持专业性
.build();
}
创造性任务（Temperature: 0.7-1.0）
// 创意写作
@Bean
public ChatModel creativeWritingModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.8) // 高温度，鼓励创意
.build();
}
// 头脑风暴
@Bean
public ChatModel brainstormingModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.9) // 很高温度，鼓励多样性
.build();
}
4.2.2 基于用户需求的调整
动态温度调整：
@Service
public class DynamicTemperatureService {
public ChatModel getModelForTask(String taskType, String userPreference) {
double temperature = calculateTemperature(taskType, userPreference);
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(temperature)
.build();
}
private double calculateTemperature(String taskType, String userPreference) {
double baseTemperature = getBaseTemperature(taskType);
double preferenceAdjustment = getPreferenceAdjustment(userPreference);
return Math.max(0.0, Math.min(2.0, baseTemperature + preferenceAdjustment));
}
private double getBaseTemperature(String taskType) {
return switch (taskType.toLowerCase()) {
case "code_generation" -> 0.1;
case "math_calculation" -> 0.0;
case "technical_qa" -> 0.5;
case "creative_writing" -> 0.8;
case "brainstorming" -> 0.9;
default -> 0.7;
};
}
private double getPreferenceAdjustment(String userPreference) {
return switch (userPreference.toLowerCase()) {
case "conservative" -> -0.2;
case "balanced" -> 0.0;
case "creative" -> 0.2;
case "experimental" -> 0.4;
default -> 0.0;
};
}
}
4.2.3 基于内容质量的调整
质量反馈调整：
@Service
public class AdaptiveTemperatureService {
private final Map<String, TemperatureHistory> temperatureHistory = new ConcurrentHashMap<>();
public double getAdaptiveTemperature(String sessionId, String taskType, QualityFeedback feedback) {
TemperatureHistory history = temperatureHistory.computeIfAbsent(
sessionId, k -> new TemperatureHistory()
);
double currentTemperature = history.getCurrentTemperature();
// 根据质量反馈调整温度
if (feedback.getQuality() < 0.6) {
// 质量低，降低温度（更确定性）
currentTemperature = Math.max(0.0, currentTemperature - 0.1);
} else if (feedback.getQuality() > 0.8) {
// 质量高，可以适当提高温度（更多样性）
currentTemperature = Math.min(1.0, currentTemperature + 0.05);
}
history.updateTemperature(currentTemperature);
return currentTemperature;
}
private static class TemperatureHistory {
private double currentTemperature = 0.7;
private final List<Double> history = new ArrayList<>();
public double getCurrentTemperature() {
return currentTemperature;
}
public void updateTemperature(double newTemperature) {
history.add(newTemperature);
currentTemperature = newTemperature;
}
}
}
4.3 温度参数的最佳实践
4.3.1 温度选择指南
开发环境：
@Configuration
@Profile("development")
public class DevelopmentConfig {
@Bean
public ChatModel developmentModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.3) // 开发环境使用较低温度，确保稳定性
.build();
}
}
生产环境：
@Configuration
@Profile("production")
public class ProductionConfig {
@Bean
public ChatModel productionModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.1) // 生产环境使用低温度，确保一致性
.build();
}
}
测试环境：
@Configuration
@Profile("test")
public class TestConfig {
@Bean
public ChatModel testModel() {
return ChatModel.builder()
.model("gpt-4o-mini")
.temperature(0.0) // 测试环境使用零温度，确保可重复性
.build();
}
}
4.3.2 温度监控和优化
温度监控：
@Component
public class TemperatureMonitor {
private final MeterRegistry meterRegistry;
public TemperatureMonitor(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
}
public void recordTemperatureUsage(String taskType, double temperature, QualityMetrics metrics) {
// 记录温度使用情况
Timer.Sample sample = Timer.start(meterRegistry);
sample.stop(Timer.builder("ai.temperature.usage")
.tag("task_type", taskType)
.tag("temperature_range", getTemperatureRange(temperature))
.register(meterRegistry));
// 记录质量指标
Gauge.builder("ai.response.quality")
.tag("task_type", taskType)
.tag("temperature_range", getTemperatureRange(temperature))
.register(meterRegistry, () -> metrics.getQualityScore());
}
private String getTemperatureRange(double temperature) {
if (temperature <= 0.3) return "low";
if (temperature <= 0.7) return "medium";
return "high";
}
}
五、提示词模板和工程化实践
5.1 提示词模板系统
5.1.1 模板结构设计
public class PromptTemplate {
private String templateId;
private String name;
private String description;
private PromptType type;
private String systemPrompt;
private String contextPrompt;
private String userPromptTemplate;
private List<PromptExample> examples;
private Map<String, Object> parameters;
private PromptMetadata metadata;
public enum PromptType {
CODE_GENERATION,
TECHNICAL_QA,
DOCUMENTATION,
CREATIVE_WRITING,
ANALYSIS,
TRANSLATION
}
}
5.1.2 模板管理器
@Service
public class PromptTemplateManager {
private final Map<String, PromptTemplate> templates = new ConcurrentHashMap<>();
private final PromptTemplateRepository repository;
@PostConstruct
public void initializeTemplates() {
loadBuiltInTemplates();
loadCustomTemplates();
}
private void loadBuiltInTemplates() {
// 代码生成模板
PromptTemplate codeGenTemplate = PromptTemplate.builder()
.templateId("code_generation")
.name("代码生成模板")
.description("用于生成各种编程语言的代码")
.type(PromptType.CODE_GENERATION)
.systemPrompt("""
你是一位资深的{language}开发工程师，拥有{experience}年的开发经验。
你精通{framework}框架，熟悉{technologies}等技术。
请基于你的专业经验，生成高质量、可维护的代码。
""")
.contextPrompt("""
项目背景：
- 项目类型：{projectType}
- 团队规模：{teamSize}
- 技术栈：{techStack}
- 约束条件：{constraints}
""")
.userPromptTemplate("""
请生成{language}代码，要求：
1. 功能：{functionality}
2. 输入：{input}
3. 输出：{output}
4. 特殊要求：{specialRequirements}
请提供：
- 完整的代码实现
- 详细的注释
- 使用示例
- 测试用例
""")
.build();
templates.put("code_generation", codeGenTemplate);
// 技术问答模板
PromptTemplate techQATemplate = PromptTemplate.builder()
.templateId("technical_qa")
.name("技术问答模板")
.description("用于回答技术相关问题")
.type(PromptType.TECHNICAL_QA)
.systemPrompt("""
你是一位{domain}专家，拥有{experience}年的{domain}开发经验。
你熟悉{technologies}等技术栈。
请基于你的专业知识和实践经验，提供准确、实用的技术建议。
""")
.contextPrompt("""
问题背景：
- 技术领域：{domain}
- 经验水平：{experienceLevel}
- 项目规模：{projectScale}
- 时间要求：{timeConstraint}
""")
.userPromptTemplate("""
问题：{question}
请提供：
1. 问题分析
2. 解决方案
3. 最佳实践
4. 注意事项
5. 相关资源
""")
.build();
templates.put("technical_qa", techQATemplate);
}
public PromptTemplate getTemplate(String templateId) {
return templates.get(templateId);
}
public List<PromptTemplate> getTemplatesByType(PromptType type) {
return templates.values().stream()
.filter(template -> template.getType() == type)
.collect(Collectors.toList());
}
public PromptTemplate createCustomTemplate(PromptTemplate template) {
template.setTemplateId("custom_" + UUID.randomUUID().toString());
templates.put(template.getTemplateId(), template);
repository.save(template);
return template;
}
}
5.2 提示词渲染引擎
5.2.1 模板渲染器
@Service
public class PromptRenderer {
private final TemplateEngine templateEngine;
public PromptRenderer() {
this.templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(new StringTemplateResolver());
}
public RenderedPrompt renderPrompt(String templateId, Map<String, Object> variables) {
PromptTemplate template = promptTemplateManager.getTemplate(templateId);
if (template == null) {
throw new TemplateNotFoundException("Template not found: " + templateId);
}
String systemPrompt = renderTemplate(template.getSystemPrompt(), variables);
String contextPrompt = renderTemplate(template.getContextPrompt(), variables);
String userPrompt = renderTemplate(template.getUserPromptTemplate(), variables);
return RenderedPrompt.builder()
.systemPrompt(systemPrompt)
.contextPrompt(contextPrompt)
.userPrompt(userPrompt)
.variables(variables)
.build();
}
private String renderTemplate(String template, Map<String, Object> variables) {
if (template == null) return "";
Context context = new Context();
variables.forEach(context::setVariable);
return templateEngine.process(template, context);
}
public RenderedPrompt renderPromptWithExamples(String templateId, Map<String, Object> variables, List<PromptExample> examples) {
RenderedPrompt basePrompt = renderPrompt(templateId, variables);
StringBuilder examplesPrompt = new StringBuilder();
examplesPrompt.append("\n\n以下是几个示例，请按照相同的格式和风格回答问题：\n\n");
for (int i = 0; i < examples.size(); i++) {
PromptExample example = examples.get(i);
examplesPrompt.append("示例").append(i + 1).append("：\n");
examplesPrompt.append("输入：").append(example.getInput()).append("\n");
examplesPrompt.append("输出：").append(example.getOutput()).append("\n\n");
}
examplesPrompt.append("现在请回答：\n");
examplesPrompt.append("输入：").append(basePrompt.getUserPrompt()).append("\n");
examplesPrompt.append("输出：");
return RenderedPrompt.builder()
.systemPrompt(basePrompt.getSystemPrompt())
.contextPrompt(basePrompt.getContextPrompt())
.userPrompt(examplesPrompt.toString())
.variables(basePrompt.getVariables())
.build();
}
}
5.2.2 动态提示词生成
@Service
public class DynamicPromptGenerator {
private final PromptTemplateManager templateManager;
private final PromptRenderer renderer;
private final ContextAnalyzer contextAnalyzer;
public RenderedPrompt generatePrompt(String taskType, String userInput, Map<String, Object> additionalContext) {
// 分析用户输入和上下文
ContextAnalysis analysis = contextAnalyzer.analyze(userInput, additionalContext);
// 选择合适的模板
PromptTemplate template = selectTemplate(taskType, analysis);
// 提取变量
Map<String, Object> variables = extractVariables(template, userInput, analysis);
// 渲染提示词
return renderer.renderPrompt(template.getTemplateId(), variables);
}
private PromptTemplate selectTemplate(String taskType, ContextAnalysis analysis) {
// 根据任务类型和上下文分析选择合适的模板
List<PromptTemplate> candidates = templateManager.getTemplatesByType(
PromptTemplate.PromptType.valueOf(taskType.toUpperCase())
);
// 使用评分机制选择最佳模板
return candidates.stream()
.max(Comparator.comparing(template -> scoreTemplate(template, analysis)))
.orElseThrow(() -> new TemplateNotFoundException("No suitable template found"));
}
private int scoreTemplate(PromptTemplate template, ContextAnalysis analysis) {
int score = 0;
// 根据复杂度匹配
if (template.getComplexity() == analysis.getComplexity()) {
score += 10;
}
// 根据领域匹配
if (template.getDomain().equals(analysis.getDomain())) {
score += 15;
}
// 根据输出格式匹配
if (template.getOutputFormat().equals(analysis.getPreferredFormat())) {
score += 5;
}
return score;
}
private Map<String, Object> extractVariables(PromptTemplate template, String userInput, ContextAnalysis analysis) {
Map<String, Object> variables = new HashMap<>();
// 从用户输入中提取变量
variables.putAll(extractVariablesFromInput(userInput));
// 从上下文分析中提取变量
variables.putAll(analysis.getExtractedVariables());
// 设置默认变量
variables.putAll(getDefaultVariables());
return variables;
}
}
5.3 提示词优化和评估
5.3.1 提示词评估器
@Service
public class PromptEvaluator {
public PromptQualityMetrics evaluatePrompt(RenderedPrompt prompt, String response) {
PromptQualityMetrics metrics = new PromptQualityMetrics();
// 评估清晰度
metrics.setClarityScore(evaluateClarity(prompt));
// 评估相关性
metrics.setRelevanceScore(evaluateRelevance(prompt, response));
// 评估完整性
metrics.setCompletenessScore(evaluateCompleteness(prompt, response));
// 评估准确性
metrics.setAccuracyScore(evaluateAccuracy(response));
// 评估格式
metrics.setFormatScore(evaluateFormat(prompt, response));
// 计算总体质量分数
metrics.setOverallScore(calculateOverallScore(metrics));
return metrics;
}
private double evaluateClarity(RenderedPrompt prompt) {
// 评估提示词的清晰度
double score = 0.0;
// 检查是否有明确的指令
if (prompt.getUserPrompt().contains("请") || prompt.getUserPrompt().contains("要求")) {
score += 0.3;
}
// 检查是否有具体的输出格式要求
if (prompt.getUserPrompt().contains("格式") || prompt.getUserPrompt().contains("输出")) {
score += 0.3;
}
// 检查是否有约束条件
if (prompt.getContextPrompt().contains("约束") || prompt.getContextPrompt().contains("限制")) {
score += 0.2;
}
// 检查是否有示例
if (prompt.getUserPrompt().contains("示例") || prompt.getUserPrompt().contains("例如")) {
score += 0.2;
}
return Math.min(1.0, score);
}
private double evaluateRelevance(RenderedPrompt prompt, String response) {
// 评估回答的相关性
// 这里可以使用NLP技术进行语义相似度分析
return 0.8; // 简化实现
}
private double evaluateCompleteness(RenderedPrompt prompt, String response) {
// 评估回答的完整性
// 检查是否回答了所有要求的问题
return 0.7; // 简化实现
}
private double evaluateAccuracy(String response) {
// 评估回答的准确性
// 这里可以使用事实检查或知识库验证
return 0.9; // 简化实现
}
private double evaluateFormat(RenderedPrompt prompt, String response) {
// 评估输出格式是否符合要求
return 0.8; // 简化实现
}
private double calculateOverallScore(PromptQualityMetrics metrics) {
return (metrics.getClarityScore() * 0.2 +
metrics.getRelevanceScore() * 0.25 +
metrics.getCompletenessScore() * 0.25 +
metrics.getAccuracyScore() * 0.2 +
metrics.getFormatScore() * 0.1);
}
}
5.3.2 提示词优化器
@Service
public class PromptOptimizer {
private final PromptEvaluator evaluator;
private final PromptTemplateManager templateManager;
public OptimizedPrompt optimizePrompt(RenderedPrompt originalPrompt, List<String> sampleResponses) {
// 分析当前提示词的问题
List<PromptIssue> issues = analyzePromptIssues(originalPrompt, sampleResponses);
// 生成优化建议
List<OptimizationSuggestion> suggestions = generateOptimizationSuggestions(issues);
// 应用优化
RenderedPrompt optimizedPrompt = applyOptimizations(originalPrompt, suggestions);
return OptimizedPrompt.builder()
.originalPrompt(originalPrompt)
.optimizedPrompt(optimizedPrompt)
.issues(issues)
.suggestions(suggestions)
.improvementScore(calculateImprovementScore(originalPrompt, optimizedPrompt))
.build();
}
private List<PromptIssue> analyzePromptIssues(RenderedPrompt prompt, List<String> responses) {
List<PromptIssue> issues = new ArrayList<>();
// 分析常见问题
if (isVague(prompt.getUserPrompt())) {
issues.add(new PromptIssue("VAGUE_INSTRUCTION", "指令不够明确", "HIGH"));
}
if (isMissingContext(prompt)) {
issues.add(new PromptIssue("MISSING_CONTEXT", "缺少必要的上下文信息", "MEDIUM"));
}
if (isInconsistentFormat(responses)) {
issues.add(new PromptIssue("INCONSISTENT_FORMAT", "输出格式不一致", "MEDIUM"));
}
return issues;
}
private List<OptimizationSuggestion> generateOptimizationSuggestions(List<PromptIssue> issues) {
List<OptimizationSuggestion> suggestions = new ArrayList<>();
for (PromptIssue issue : issues) {
switch (issue.getType()) {
case "VAGUE_INSTRUCTION":
suggestions.add(new OptimizationSuggestion(
"添加具体的指令和要求",
"在用户提示词中添加明确的指令，如'请按以下格式回答'、'必须包含以下内容'等"
));
break;
case "MISSING_CONTEXT":
suggestions.add(new OptimizationSuggestion(
"补充上下文信息",
"在上下文提示词中添加相关的背景信息、约束条件和数据"
));
break;
case "INCONSISTENT_FORMAT":
suggestions.add(new OptimizationSuggestion(
"规范输出格式",
"在提示词中明确指定输出格式，并提供示例"
));
break;
}
}
return suggestions;
}
private RenderedPrompt applyOptimizations(RenderedPrompt originalPrompt, List<OptimizationSuggestion> suggestions) {
// 应用优化建议
String optimizedUserPrompt = originalPrompt.getUserPrompt();
String optimizedContextPrompt = originalPrompt.getContextPrompt();
for (OptimizationSuggestion suggestion : suggestions) {
switch (suggestion.getType()) {
case "添加具体的指令和要求":
optimizedUserPrompt = addSpecificInstructions(optimizedUserPrompt);
break;
case "补充上下文信息":
optimizedContextPrompt = addContextInformation(optimizedContextPrompt);
break;
case "规范输出格式":
optimizedUserPrompt = addFormatSpecification(optimizedUserPrompt);
break;
}
}
return RenderedPrompt.builder()
.systemPrompt(originalPrompt.getSystemPrompt())
.contextPrompt(optimizedContextPrompt)
.userPrompt(optimizedUserPrompt)
.variables(originalPrompt.getVariables())
.build();
}
}
六、Java实战：构建提示词管理系统
6.1 环境准备
<!-- pom.xml -->
<project>
<properties>
<spring-ai.version>1.1.0-M3</spring-ai.version>
</properties>
<dependencies>
<!-- Spring AI Starter -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>
<!-- Spring Boot Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- Thymeleaf模板引擎 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!-- H2 Database -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Micrometer监控 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
</project>
# application.yml
spring:
ai:
openai:
api-key: ${OPENAI_API_KEY}
chat:
options:
model: gpt-4o-mini
temperature: 0.7
datasource:
url: jdbc:h2:mem:testdb
driver-class-name: org.h2.Driver
username: sa
password: password
jpa:
hibernate:
ddl-auto: create-drop
show-sql: true
6.2 核心实体定义
package com.example.prompt.entity;
import jakarta.persistence.*;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* 提示词模板实体
*/
@Entity
@Table(name = "prompt_templates")
public class PromptTemplateEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(unique = true, nullable = false)
private String templateId;
@Column(nullable = false)
private String name;
@Column(columnDefinition = "TEXT")
private String description;
@Enumerated(EnumType.STRING)
private PromptType type;
@Column(columnDefinition = "TEXT")
private String systemPrompt;
@Column(columnDefinition = "TEXT")
private String contextPrompt;
@Column(columnDefinition = "TEXT")
private String userPromptTemplate;
@Column(columnDefinition = "TEXT")
private String examples; // JSON格式存储示例
@Column(columnDefinition = "TEXT")
private String parameters; // JSON格式存储参数
@Column(columnDefinition = "TEXT")
private String metadata; // JSON格式存储元数据
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
@OneToMany(mappedBy = "template", cascade = CascadeType.ALL)
private List<PromptUsageEntity> usages;
// 构造函数、getter、setter
public PromptTemplateEntity() {}
public PromptTemplateEntity(String templateId, String name, String description, PromptType type) {
this.templateId = templateId;
this.name = name;
this.description = description;
this.type = type;
this.createdAt = LocalDateTime.now();
this.updatedAt = LocalDateTime.now();
}
// getter和setter方法
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getTemplateId() { return templateId; }
public void setTemplateId(String templateId) { this.templateId = templateId; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public PromptType getType() { return type; }
public void setType(PromptType type) { this.type = type; }
public String getSystemPrompt() { return systemPrompt; }
public void setSystemPrompt(String systemPrompt) { this.systemPrompt = systemPrompt; }
public String getContextPrompt() { return contextPrompt; }
public void setContextPrompt(String contextPrompt) { this.contextPrompt = contextPrompt; }
public String getUserPromptTemplate() { return userPromptTemplate; }
public void setUserPromptTemplate(String userPromptTemplate) { this.userPromptTemplate = userPromptTemplate; }
public String getExamples() { return examples; }
public void setExamples(String examples) { this.examples = examples; }
public String getParameters() { return parameters; }
public void setParameters(String parameters) { this.parameters = parameters; }
public String getMetadata() { return metadata; }
public void setMetadata(String metadata) { this.metadata = metadata; }
public LocalDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
public LocalDateTime getUpdatedAt() { return updatedAt; }
public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
public List<PromptUsageEntity> getUsages() { return usages; }
public void setUsages(List<PromptUsageEntity> usages) { this.usages = usages; }
}
/**
* 提示词类型枚举
*/
public enum PromptType {
CODE_GENERATION("代码生成"),
TECHNICAL_QA("技术问答"),
DOCUMENTATION("文档生成"),
CREATIVE_WRITING("创意写作"),
ANALYSIS("分析报告"),
TRANSLATION("翻译"),
SUMMARIZATION("摘要生成"),
CLASSIFICATION("分类"),
EXTRACTION("信息提取");
private final String description;
PromptType(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
}
/**
* 提示词使用记录实体
*/
@Entity
@Table(name = "prompt_usages")
public class PromptUsageEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "template_id")
private PromptTemplateEntity template;
@Column(columnDefinition = "TEXT")
private String renderedPrompt;
@Column(columnDefinition = "TEXT")
private String response;
@Column(columnDefinition = "TEXT")
private String qualityMetrics; // JSON格式
private Double temperature;
private Long responseTime;
private String userId;
private String sessionId;
private LocalDateTime createdAt;
// 构造函数、getter、setter
public PromptUsageEntity() {}
public PromptUsageEntity(PromptTemplateEntity template, String renderedPrompt, String response) {
this.template = template;
this.renderedPrompt = renderedPrompt;
this.response = response;
this.createdAt = LocalDateTime.now();
}
// getter和setter方法
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public PromptTemplateEntity getTemplate() { return template; }
public void setTemplate(PromptTemplateEntity template) { this.template = template; }
public String getRenderedPrompt() { return renderedPrompt; }
public void setRenderedPrompt(String renderedPrompt) { this.renderedPrompt = renderedPrompt; }
public String getResponse() { return response; }
public void setResponse(String response) { this.response = response; }
public String getQualityMetrics() { return qualityMetrics; }
public void setQualityMetrics(String qualityMetrics) { this.qualityMetrics = qualityMetrics; }
public Double getTemperature() { return temperature; }
public void setTemperature(Double temperature) { this.temperature = temperature; }
public Long getResponseTime() { return responseTime; }
public void setResponseTime(Long responseTime) { this.responseTime = responseTime; }
public String getUserId() { return userId; }
public void setUserId(String userId) { this.userId = userId; }
public String getSessionId() { return sessionId; }
public void setSessionId(String sessionId) { this.sessionId = sessionId; }
public LocalDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
}
6.3 提示词服务实现
package com.example.prompt.service;
import com.example.prompt.entity.PromptTemplateEntity;
import com.example.prompt.entity.PromptUsageEntity;
import com.example.prompt.entity.PromptType;
import com.example.prompt.repository.PromptTemplateRepository;
import com.example.prompt.repository.PromptUsageRepository;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
/**
* 提示词服务
*/
@Service
@Transactional
public class PromptService {
private final PromptTemplateRepository templateRepository;
private final PromptUsageRepository usageRepository;
private final PromptRenderer promptRenderer;
private final PromptEvaluator promptEvaluator;
private final ChatClient chatClient;
public PromptService(PromptTemplateRepository templateRepository,
PromptUsageRepository usageRepository,
PromptRenderer promptRenderer,
PromptEvaluator promptEvaluator,
ChatClient.Builder chatClientBuilder) {
this.templateRepository = templateRepository;
this.usageRepository = usageRepository;
this.promptRenderer = promptRenderer;
this.promptEvaluator = promptEvaluator;
this.chatClient = chatClientBuilder.build();
}
/**
* 执行提示词
*/
public CompletableFuture<PromptExecutionResult> executePrompt(String templateId, Map<String, Object> variables) {
return CompletableFuture.supplyAsync(() -> {
long startTime = System.currentTimeMillis();
try {
// 获取模板
PromptTemplateEntity template = templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
// 渲染提示词
RenderedPrompt renderedPrompt = promptRenderer.renderPrompt(template, variables);
// 执行AI调用
String response = chatClient.prompt()
.user(renderedPrompt.getUserPrompt())
.call()
.content();
long responseTime = System.currentTimeMillis() - startTime;
// 评估质量
PromptQualityMetrics qualityMetrics = promptEvaluator.evaluatePrompt(renderedPrompt, response);
// 保存使用记录
PromptUsageEntity usage = new PromptUsageEntity(template, renderedPrompt.toString(), response);
usage.setResponseTime(responseTime);
usage.setQualityMetrics(qualityMetrics.toJson());
usageRepository.save(usage);
return PromptExecutionResult.builder()
.templateId(templateId)
.renderedPrompt(renderedPrompt)
.response(response)
.qualityMetrics(qualityMetrics)
.responseTime(responseTime)
.success(true)
.build();
} catch (Exception e) {
return PromptExecutionResult.builder()
.templateId(templateId)
.success(false)
.error(e.getMessage())
.responseTime(System.currentTimeMillis() - startTime)
.build();
}
});
}
/**
* 创建模板
*/
public PromptTemplateEntity createTemplate(CreateTemplateRequest request) {
PromptTemplateEntity template = new PromptTemplateEntity(
request.getTemplateId(),
request.getName(),
request.getDescription(),
request.getType()
);
template.setSystemPrompt(request.getSystemPrompt());
template.setContextPrompt(request.getContextPrompt());
template.setUserPromptTemplate(request.getUserPromptTemplate());
template.setExamples(request.getExamples());
template.setParameters(request.getParameters());
template.setMetadata(request.getMetadata());
return templateRepository.save(template);
}
/**
* 更新模板
*/
public PromptTemplateEntity updateTemplate(String templateId, UpdateTemplateRequest request) {
PromptTemplateEntity template = templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
if (request.getName() != null) template.setName(request.getName());
if (request.getDescription() != null) template.setDescription(request.getDescription());
if (request.getSystemPrompt() != null) template.setSystemPrompt(request.getSystemPrompt());
if (request.getContextPrompt() != null) template.setContextPrompt(request.getContextPrompt());
if (request.getUserPromptTemplate() != null) template.setUserPromptTemplate(request.getUserPromptTemplate());
if (request.getExamples() != null) template.setExamples(request.getExamples());
if (request.getParameters() != null) template.setParameters(request.getParameters());
if (request.getMetadata() != null) template.setMetadata(request.getMetadata());
template.setUpdatedAt(LocalDateTime.now());
return templateRepository.save(template);
}
/**
* 获取模板
*/
public Optional<PromptTemplateEntity> getTemplate(String templateId) {
return templateRepository.findByTemplateId(templateId);
}
/**
* 获取模板列表
*/
public List<PromptTemplateEntity> getTemplates(PromptType type) {
if (type != null) {
return templateRepository.findByType(type);
}
return templateRepository.findAll();
}
/**
* 删除模板
*/
public void deleteTemplate(String templateId) {
PromptTemplateEntity template = templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
templateRepository.delete(template);
}
/**
* 获取模板使用统计
*/
public TemplateUsageStats getTemplateUsageStats(String templateId) {
PromptTemplateEntity template = templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
List<PromptUsageEntity> usages = usageRepository.findByTemplate(template);
return TemplateUsageStats.builder()
.templateId(templateId)
.totalUsages(usages.size())
.averageResponseTime(usages.stream().mapToLong(PromptUsageEntity::getResponseTime).average().orElse(0.0))
.averageQualityScore(usages.stream()
.mapToDouble(usage -> {
try {
PromptQualityMetrics metrics = PromptQualityMetrics.fromJson(usage.getQualityMetrics());
return metrics.getOverallScore();
} catch (Exception e) {
return 0.0;
}
})
.average().orElse(0.0))
.build();
}
}
/**
* 提示词执行结果
*/
public class PromptExecutionResult {
private String templateId;
private RenderedPrompt renderedPrompt;
private String response;
private PromptQualityMetrics qualityMetrics;
private long responseTime;
private boolean success;
private String error;
// 构造函数、getter、setter
public PromptExecutionResult() {}
public static PromptExecutionResultBuilder builder() {
return new PromptExecutionResultBuilder();
}
public static class PromptExecutionResultBuilder {
private String templateId;
private RenderedPrompt renderedPrompt;
private String response;
private PromptQualityMetrics qualityMetrics;
private long responseTime;
private boolean success;
private String error;
public PromptExecutionResultBuilder templateId(String templateId) {
this.templateId = templateId;
return this;
}
public PromptExecutionResultBuilder renderedPrompt(RenderedPrompt renderedPrompt) {
this.renderedPrompt = renderedPrompt;
return this;
}
public PromptExecutionResultBuilder response(String response) {
this.response = response;
return this;
}
public PromptExecutionResultBuilder qualityMetrics(PromptQualityMetrics qualityMetrics) {
this.qualityMetrics = qualityMetrics;
return this;
}
public PromptExecutionResultBuilder responseTime(long responseTime) {
this.responseTime = responseTime;
return this;
}
public PromptExecutionResultBuilder success(boolean success) {
this.success = success;
return this;
}
public PromptExecutionResultBuilder error(String error) {
this.error = error;
return this;
}
public PromptExecutionResult build() {
PromptExecutionResult result = new PromptExecutionResult();
result.templateId = this.templateId;
result.renderedPrompt = this.renderedPrompt;
result.response = this.response;
result.qualityMetrics = this.qualityMetrics;
result.responseTime = this.responseTime;
result.success = this.success;
result.error = this.error;
return result;
}
}
// getter和setter方法
public String getTemplateId() { return templateId; }
public void setTemplateId(String templateId) { this.templateId = templateId; }
public RenderedPrompt getRenderedPrompt() { return renderedPrompt; }
public void setRenderedPrompt(RenderedPrompt renderedPrompt) { this.renderedPrompt = renderedPrompt; }
public String getResponse() { return response; }
public void setResponse(String response) { this.response = response; }
public PromptQualityMetrics getQualityMetrics() { return qualityMetrics; }
public void setQualityMetrics(PromptQualityMetrics qualityMetrics) { this.qualityMetrics = qualityMetrics; }
public long getResponseTime() { return responseTime; }
public void setResponseTime(long responseTime) { this.responseTime = responseTime; }
public boolean isSuccess() { return success; }
public void setSuccess(boolean success) { this.success = success; }
public String getError() { return error; }
public void setError(String error) { this.error = error; }
}
6.4 REST API控制器
package com.example.prompt.controller;
import com.example.prompt.entity.PromptTemplateEntity;
import com.example.prompt.entity.PromptType;
import com.example.prompt.service.PromptService;
import com.example.prompt.dto.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
/**
* 提示词REST API控制器
*/
@RestController
@RequestMapping("/api/prompts")
public class PromptController {
private final PromptService promptService;
public PromptController(PromptService promptService) {
this.promptService = promptService;
}
/**
* 执行提示词
*/
@PostMapping("/{templateId}/execute")
public CompletableFuture<ResponseEntity<PromptExecutionResult>> executePrompt(
@PathVariable String templateId,
@RequestBody Map<String, Object> variables) {
return promptService.executePrompt(templateId, variables)
.thenApply(result -> {
if (result.isSuccess()) {
return ResponseEntity.ok(result);
} else {
return ResponseEntity.badRequest().body(result);
}
});
}
/**
* 创建模板
*/
@PostMapping("/templates")
public ResponseEntity<PromptTemplateEntity> createTemplate(@RequestBody CreateTemplateRequest request) {
PromptTemplateEntity template = promptService.createTemplate(request);
return ResponseEntity.ok(template);
}
/**
* 更新模板
*/
@PutMapping("/templates/{templateId}")
public ResponseEntity<PromptTemplateEntity> updateTemplate(
@PathVariable String templateId,
@RequestBody UpdateTemplateRequest request) {
PromptTemplateEntity template = promptService.updateTemplate(templateId, request);
return ResponseEntity.ok(template);
}
/**
* 获取模板
*/
@GetMapping("/templates/{templateId}")
public ResponseEntity<PromptTemplateEntity> getTemplate(@PathVariable String templateId) {
return promptService.getTemplate(templateId)
.map(template -> ResponseEntity.ok(template))
.orElse(ResponseEntity.notFound().build());
}
/**
* 获取模板列表
*/
@GetMapping("/templates")
public ResponseEntity<List<PromptTemplateEntity>> getTemplates(@RequestParam(required = false) PromptType type) {
List<PromptTemplateEntity> templates = promptService.getTemplates(type);
return ResponseEntity.ok(templates);
}
/**
* 删除模板
*/
@DeleteMapping("/templates/{templateId}")
public ResponseEntity<Void> deleteTemplate(@PathVariable String templateId) {
promptService.deleteTemplate(templateId);
return ResponseEntity.ok().build();
}
/**
* 获取模板使用统计
*/
@GetMapping("/templates/{templateId}/stats")
public ResponseEntity<TemplateUsageStats> getTemplateStats(@PathVariable String templateId) {
TemplateUsageStats stats = promptService.getTemplateUsageStats(templateId);
return ResponseEntity.ok(stats);
}
/**
* 批量执行提示词
*/
@PostMapping("/batch-execute")
public CompletableFuture<ResponseEntity<List<PromptExecutionResult>>> batchExecutePrompts(
@RequestBody BatchExecuteRequest request) {
List<CompletableFuture<PromptExecutionResult>> futures = request.getExecutions().stream()
.map(execution -> promptService.executePrompt(execution.getTemplateId(), execution.getVariables()))
.toList();
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenApply(v -> {
List<PromptExecutionResult> results = futures.stream()
.map(CompletableFuture::join)
.toList();
return ResponseEntity.ok(results);
});
}
}
/**
* 创建模板请求
*/
public class CreateTemplateRequest {
private String templateId;
private String name;
private String description;
private PromptType type;
private String systemPrompt;
private String contextPrompt;
private String userPromptTemplate;
private String examples;
private String parameters;
private String metadata;
// 构造函数、getter、setter
public CreateTemplateRequest() {}
// getter和setter方法
public String getTemplateId() { return templateId; }
public void setTemplateId(String templateId) { this.templateId = templateId; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public PromptType getType() { return type; }
public void setType(PromptType type) { this.type = type; }
public String getSystemPrompt() { return systemPrompt; }
public void setSystemPrompt(String systemPrompt) { this.systemPrompt = systemPrompt; }
public String getContextPrompt() { return contextPrompt; }
public void setContextPrompt(String contextPrompt) { this.contextPrompt = contextPrompt; }
public String getUserPromptTemplate() { return userPromptTemplate; }
public void setUserPromptTemplate(String userPromptTemplate) { this.userPromptTemplate = userPromptTemplate; }
public String getExamples() { return examples; }
public void setExamples(String examples) { this.examples = examples; }
public String getParameters() { return parameters; }
public void setParameters(String parameters) { this.parameters = parameters; }
public String getMetadata() { return metadata; }
public void setMetadata(String metadata) { this.metadata = metadata; }
}
/**
* 更新模板请求
*/
public class UpdateTemplateRequest {
private String name;
private String description;
private String systemPrompt;
private String contextPrompt;
private String userPromptTemplate;
private String examples;
private String parameters;
private String metadata;
// 构造函数、getter、setter
public UpdateTemplateRequest() {}
// getter和setter方法
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public String getSystemPrompt() { return systemPrompt; }
public void setSystemPrompt(String systemPrompt) { this.systemPrompt = systemPrompt; }
public String getContextPrompt() { return contextPrompt; }
public void setContextPrompt(String contextPrompt) { this.contextPrompt = contextPrompt; }
public String getUserPromptTemplate() { return userPromptTemplate; }
public void setUserPromptTemplate(String userPromptTemplate) { this.userPromptTemplate = userPromptTemplate; }
public String getExamples() { return examples; }
public void setExamples(String examples) { this.examples = examples; }
public String getParameters() { return parameters; }
public void setParameters(String parameters) { this.parameters = parameters; }
public String getMetadata() { return metadata; }
public void setMetadata(String metadata) { this.metadata = metadata; }
}
/**
* 批量执行请求
*/
public class BatchExecuteRequest {
private List<PromptExecution> executions;
// 构造函数、getter、setter
public BatchExecuteRequest() {}
public List<PromptExecution> getExecutions() { return executions; }
public void setExecutions(List<PromptExecution> executions) { this.executions = executions; }
}
/**
* 提示词执行
*/
public class PromptExecution {
private String templateId;
private Map<String, Object> variables;
// 构造函数、getter、setter
public PromptExecution() {}
public String getTemplateId() { return templateId; }
public void setTemplateId(String templateId) { this.templateId = templateId; }
public Map<String, Object> getVariables() { return variables; }
public void setVariables(Map<String, Object> variables) { this.variables = variables; }
}
七、生产环境最佳实践
7.1 提示词管理最佳实践
7.1.1 版本控制
@Service
public class PromptVersionControl {
private final PromptTemplateRepository templateRepository;
private final PromptVersionRepository versionRepository;
public PromptTemplateEntity createVersion(String templateId, String version, String description) {
PromptTemplateEntity originalTemplate = templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
PromptTemplateEntity versionTemplate = new PromptTemplateEntity(
templateId + "_v" + version,
originalTemplate.getName() + " v" + version,
description,
originalTemplate.getType()
);
// 复制模板内容
versionTemplate.setSystemPrompt(originalTemplate.getSystemPrompt());
versionTemplate.setContextPrompt(originalTemplate.getContextPrompt());
versionTemplate.setUserPromptTemplate(originalTemplate.getUserPromptTemplate());
versionTemplate.setExamples(originalTemplate.getExamples());
versionTemplate.setParameters(originalTemplate.getParameters());
versionTemplate.setMetadata(originalTemplate.getMetadata());
PromptTemplateEntity savedTemplate = templateRepository.save(versionTemplate);
// 记录版本信息
PromptVersionEntity versionEntity = new PromptVersionEntity(
templateId, version, description, savedTemplate.getId()
);
versionRepository.save(versionEntity);
return savedTemplate;
}
public List<PromptVersionEntity> getTemplateVersions(String templateId) {
return versionRepository.findByTemplateIdOrderByCreatedAtDesc(templateId);
}
public PromptTemplateEntity rollbackToVersion(String templateId, String version) {
PromptVersionEntity versionEntity = versionRepository.findByTemplateIdAndVersion(templateId, version)
.orElseThrow(() -> new VersionNotFoundException("Version not found: " + version));
PromptTemplateEntity versionTemplate = templateRepository.findById(versionEntity.getTemplateEntityId())
.orElseThrow(() -> new TemplateNotFoundException("Template not found"));
// 创建回滚版本
return createVersion(templateId, "rollback_" + System.currentTimeMillis(),
"Rollback to version " + version);
}
}
7.1.2 性能优化
@Service
public class PromptPerformanceOptimizer {
private final CacheManager cacheManager;
private final PromptTemplateRepository templateRepository;
@Cacheable(value = "promptTemplates", key = "#templateId")
public PromptTemplateEntity getCachedTemplate(String templateId) {
return templateRepository.findByTemplateId(templateId)
.orElseThrow(() -> new TemplateNotFoundException("Template not found: " + templateId));
}
@Cacheable(value = "renderedPrompts", key = "#templateId + '_' + #variables.hashCode()")
public RenderedPrompt getCachedRenderedPrompt(String templateId, Map<String, Object> variables) {
PromptTemplateEntity template = getCachedTemplate(templateId);
return promptRenderer.renderPrompt(template, variables);
}
@Async
public CompletableFuture<PromptExecutionResult> executePromptAsync(String templateId, Map<String, Object> variables) {
return CompletableFuture.supplyAsync(() -> {
// 异步执行提示词
return promptService.executePrompt(templateId, variables).join();
});
}
public List<PromptExecutionResult> executePromptsInParallel(List<PromptExecution> executions) {
List<CompletableFuture<PromptExecutionResult>> futures = executions.stream()
.map(execution -> executePromptAsync(execution.getTemplateId(), execution.getVariables()))
.toList();
return futures.stream()
.map(CompletableFuture::join)
.toList();
}
}
7.2 监控和告警
@Component
public class PromptMonitoring {
private final MeterRegistry meterRegistry;
private final AlertManager alertManager;
public void recordPromptExecution(String templateId, long responseTime, boolean success, double qualityScore) {
// 记录执行时间
Timer.Sample sample = Timer.start(meterRegistry);
sample.stop(Timer.builder("prompt.execution.time")
.tag("template_id", templateId)
.tag("success", String.valueOf(success))
.register(meterRegistry));
// 记录质量分数
Gauge.builder("prompt.quality.score")
.tag("template_id", templateId)
.register(meterRegistry, () -> qualityScore);
// 检查告警条件
checkAlerts(templateId, responseTime, success, qualityScore);
}
private void checkAlerts(String templateId, long responseTime, boolean success, double qualityScore) {
// 响应时间告警
if (responseTime > 10000) { // 10秒
alertManager.sendAlert(AlertType.RESPONSE_TIME_HIGH,
"Template " + templateId + " response time is " + responseTime + "ms");
}
// 成功率告警
if (!success) {
alertManager.sendAlert(AlertType.EXECUTION_FAILED,
"Template " + templateId + " execution failed");
}
// 质量分数告警
if (qualityScore < 0.6) {
alertManager.sendAlert(AlertType.QUALITY_LOW,
"Template " + templateId + " quality score is " + qualityScore);
}
}
}
八、总结
核心要点回顾
- AI提问有多种方式：直接提问、引导式提问、对比式提问、假设式提问、步骤式提问、角色扮演
- 提问最佳实践：5W1H原则、STAR方法、提供充分上下文、使用具体示例、明确输出格式、设置约束条件
- 提示词设计原则：清晰性、结构化、引导性，使用Chain of Thought、Few-Shot Learning、Role-Playing、Constraint-Based等模式
- 提示词组成结构：系统提示词、上下文提示词、用户提示词、示例提示词，各部分有不同作用
- 温度参数控制：0.0-2.0范围，影响输出随机性，需要根据任务类型、用户需求、内容质量动态调整
- 工程化实践：模板系统、渲染引擎、评估优化、版本控制、性能优化、监控告警
技术选型建议
应用场景 → 推荐方案
─────────────────────────────────
代码生成 → Temperature: 0.1, 结构化模板
技术问答 → Temperature: 0.5, 角色扮演模板
创意写作 → Temperature: 0.8, 引导式模板
分析报告 → Temperature: 0.3, Chain of Thought
文档生成 → Temperature: 0.4, Few-Shot模板
未来趋势
- 智能化提示词：AI自动生成和优化提示词
- 个性化提示词：根据用户偏好和历史数据定制
- 多模态提示词：支持文本、图像、音频等多种输入
- 实时优化：基于反馈实时调整提示词参数
- 标准化协议：统一的提示词交换格式和标准
