第2040篇：Meta-Prompt工程——用LLM优化LLM的Prompt

适读人群：希望自动化Prompt优化过程的工程师 | 阅读时长：约17分钟 | 核心价值：掌握用LLM自动生成和优化Prompt的方法，减少人工Prompt设计的工作量

手工写Prompt是一个反复试错的过程，很消耗时间。

有没有办法让AI帮我写Prompt？这个想法听起来有点循环，但实际上完全可行——用一个强大的模型（GPT-4o）来生成和优化另一个模型（本地7B）的Prompt，是一种高效的Prompt工程方法。

---

Meta-Prompt的基本思路

这个自动化迭代的过程，可以在几分钟内完成人工可能需要几天的Prompt优化工作。

---

基础实现：自动化Prompt生成

/**
 * Meta-Prompt服务：用强大LLM生成任务的Prompt
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class MetaPromptService {
    
    private final ChatClient metaLlm;       // 用于生成Prompt的强大模型（GPT-4o）
    private final ChatClient targetLlm;     // 被优化的目标模型（本地7B）
    private final PromptTestRunner testRunner;
    
    /**
     * 给定任务描述，自动生成System Prompt
     */
    public String generateSystemPrompt(
            String taskDescription,
            List<PromptTestCase> testCases,
            int maxIterations) {
        
        // 第一步：让强模型生成初始Prompt
        String initialPrompt = generateInitialPrompt(taskDescription);
        log.info("生成初始Prompt，长度: {} 字符", initialPrompt.length());
        
        String currentPrompt = initialPrompt;
        
        // 迭代优化
        for (int iteration = 1; iteration <= maxIterations; iteration++) {
            // 测试当前Prompt
            TestSuiteReport report = testRunner.runTestSuite(currentPrompt, testCases);
            log.info("迭代{}: 通过率 {:.1f}%", iteration, report.getOverallPassRate() * 100);
            
            // 如果通过率足够高，停止
            if (report.getOverallPassRate() >= 0.90) {
                log.info("通过率达到目标，停止迭代");
                break;
            }
            
            // 分析失败原因，优化Prompt
            List<TestCaseResult> failedCases = report.getResults().stream()
                .filter(r -> !r.isPassed())
                .collect(Collectors.toList());
            
            currentPrompt = optimizePrompt(currentPrompt, failedCases, taskDescription);
        }
        
        return currentPrompt;
    }
    
    private String generateInitialPrompt(String taskDescription) {
        String metaPrompt = """
            你是一个Prompt工程专家，你的任务是为AI助手编写高质量的System Prompt。
            
            用户任务描述：
            %s
            
            请生成一个专业的System Prompt，要求：
            1. 清晰定义AI助手的角色和职责
            2. 明确规定输入/输出的格式要求
            3. 列出处理边界情况的规则
            4. 包含必要的示例说明
            
            直接输出System Prompt内容，不要包含任何解释：
            """.formatted(taskDescription);
        
        return metaLlm.prompt()
            .user(metaPrompt)
            .call()
            .content();
    }
    
    private String optimizePrompt(
            String currentPrompt, 
            List<TestCaseResult> failedCases,
            String taskDescription) {
        
        // 整理失败案例
        String failureSummary = failedCases.stream()
            .limit(5)  // 最多分析5个失败案例，避免Prompt太长
            .map(tc -> String.format("""
                案例：%s
                用户输入：%s
                期望输出：%s
                实际输出：%s
                失败原因：%s
                """,
                tc.getTestCase().getDescription(),
                tc.getTestCase().getInput(),
                tc.getTestCase().getExactExpected() != null ? tc.getTestCase().getExactExpected() : "（见关键词要求）",
                tc.getActualOutput(),
                tc.getFailReason()))
            .collect(Collectors.joining("\n---\n"));
        
        String optimizationPrompt = """
            以下是一个System Prompt，以及使用它时出现的失败案例。
            请分析失败原因，对Prompt进行针对性改进。
            
            原始Prompt：
            %s
            
            失败案例（共%d个）：
            %s
            
            任务要求：
            %s
            
            请输出改进后的Prompt（直接输出内容，不要包含解释）：
            """.formatted(currentPrompt, failedCases.size(), failureSummary, taskDescription);
        
        return metaLlm.prompt()
            .user(optimizationPrompt)
            .call()
            .content();
    }
}

---

通用Prompt模板库生成

Meta-Prompt不只能生成具体任务的Prompt，还能生成可复用的模板：

/**
 * 自动生成可复用的Prompt模板
 */
@Service
@RequiredArgsConstructor
public class PromptTemplateGenerator {
    
    private final ChatClient metaLlm;
    private final PromptTemplateRepository templateRepo;
    
    /**
     * 从历史成功案例中提炼Prompt模板
     */
    public PromptTemplate extractTemplate(List<SuccessfulPrompt> examples) {
        String examplesText = examples.stream()
            .map(ex -> String.format("""
                任务类型：%s
                System Prompt：
                %s
                """, ex.getTaskType(), ex.getPromptContent()))
            .collect(Collectors.joining("\n---\n"));
        
        String extractionPrompt = """
            以下是多个不同任务类型的高质量System Prompt示例。
            请分析这些Prompt的共同模式和结构，提炼一个通用的Prompt模板。
            
            模板要求：
            1. 使用{{变量名}}作为需要替换的占位符
            2. 保留所有任务中通用的指令部分
            3. 把特定任务的部分抽象为可替换的变量
            
            示例集合：
            %s
            
            请输出模板（包含变量说明）：
            """.formatted(examplesText);
        
        String templateContent = metaLlm.prompt()
            .user(extractionPrompt)
            .call()
            .content();
        
        // 提取模板中的变量
        List<String> variables = extractVariables(templateContent);
        
        PromptTemplate template = PromptTemplate.builder()
            .name(inferTemplateName(examples))
            .content(templateContent)
            .variables(variables)
            .createdFrom(examples.stream().map(SuccessfulPrompt::getId).collect(Collectors.toList()))
            .build();
        
        return templateRepo.save(template);
    }
    
    /**
     * 使用模板实例化具体Prompt
     */
    public String instantiateTemplate(String templateId, Map<String, String> variables) {
        PromptTemplate template = templateRepo.findById(templateId)
            .orElseThrow(() -> new TemplateNotFoundException(templateId));
        
        String content = template.getContent();
        for (Map.Entry<String, String> var : variables.entrySet()) {
            content = content.replace("{{" + var.getKey() + "}}", var.getValue());
        }
        
        // 检查是否还有未替换的变量
        List<String> unreplaced = extractVariables(content);
        if (!unreplaced.isEmpty()) {
            log.warn("模板中还有未替换的变量: {}", unreplaced);
        }
        
        return content;
    }
    
    private List<String> extractVariables(String content) {
        List<String> variables = new ArrayList<>();
        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("\\{\\{(\\w+)\\}\\}");
        java.util.regex.Matcher matcher = pattern.matcher(content);
        while (matcher.find()) {
            variables.add(matcher.group(1));
        }
        return variables;
    }
    
    private String inferTemplateName(List<SuccessfulPrompt> examples) {
        // 从案例中提取共同的任务关键词
        return examples.stream()
            .map(SuccessfulPrompt::getTaskType)
            .collect(Collectors.groupingBy(t -> t, Collectors.counting()))
            .entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(e -> e.getKey() + "-template")
            .orElse("general-template");
    }
}

---

Prompt质量评分器

/**
 * 自动评估Prompt质量的评分器
 * 不需要运行测试，直接对Prompt文本打分
 */
@Component
@RequiredArgsConstructor
public class PromptQualityScorer {
    
    private final ChatClient evaluatorLlm;
    
    /**
     * 从多个维度评估Prompt质量
     */
    public PromptQualityReport score(String prompt, String taskDescription) {
        String scoringPrompt = """
            请从以下维度评估这个System Prompt的质量（每项1-10分）：
            
            任务描述：%s
            
            System Prompt：
            %s
            
            评估维度：
            1. 清晰度：指令是否清晰、无歧义
            2. 完整性：是否覆盖了主要场景和边界情况
            3. 格式规范：是否明确了输出格式要求
            4. 安全性：是否包含适当的安全指令
            5. 简洁性：是否精练，没有冗余内容
            
            输出格式（严格按此格式）：
            清晰度: X/10
            完整性: X/10
            格式规范: X/10
            安全性: X/10
            简洁性: X/10
            总体建议: 一句话改进建议
            """.formatted(taskDescription, prompt);
        
        String scoreResponse = evaluatorLlm.prompt()
            .user(scoringPrompt)
            .call()
            .content();
        
        return parseScoreResponse(scoreResponse);
    }
    
    private PromptQualityReport parseScoreResponse(String response) {
        Map<String, Double> scores = new HashMap<>();
        String recommendation = "";
        
        for (String line : response.split("\n")) {
            if (line.contains(": ") && line.contains("/10")) {
                String[] parts = line.split(": ");
                String dimension = parts[0].trim();
                try {
                    double score = Double.parseDouble(
                        parts[1].replace("/10", "").trim());
                    scores.put(dimension, score);
                } catch (NumberFormatException e) {
                    // 跳过解析失败的行
                }
            } else if (line.startsWith("总体建议:")) {
                recommendation = line.substring("总体建议:".length()).trim();
            }
        }
        
        double avgScore = scores.values().stream()
            .mapToDouble(Double::doubleValue)
            .average()
            .orElse(0.0);
        
        return PromptQualityReport.builder()
            .dimensionScores(scores)
            .overallScore(avgScore)
            .recommendation(recommendation)
            .build();
    }
}

---

Meta-Prompt工程的核心价值是：把Prompt优化从反复手工试错，变成自动化的数据驱动过程。

当然，全自动生成的Prompt需要人工审核——AI生成的不一定完美，但通常是一个很好的起点，能节省70-80%的手工优化时间。