提示工程模式

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-anthropic</artifactId>
</dependency>

.options(ChatOptions.builder()
        .model("claude-3-7-sonnet-latest")  // 使用 Anthropic 的 Claude 模型
        .build())

// 实现第 2.1 节：通用提示/零样本（第 15 页）
public void pt_zero_shot(ChatClient chatClient) {
    enum Sentiment {
        POSITIVE, NEUTRAL, NEGATIVE
    }

    Sentiment reviewSentiment = chatClient.prompt("""
            将电影评论分类为 POSITIVE、NEUTRAL 或 NEGATIVE。
            评论："Her"是一部揭示如果人工智能继续不受控制地发展，人类将走向何方的令人不安的研究。
            我希望有更多像这样的杰作。
            情感：
            """)
            .options(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(0.1)
                    .maxTokens(5)
                    .build())
            .call()
            .entity(Sentiment.class);

    System.out.println("输出：" + reviewSentiment);
}

// 实现第 2.2 节：单样本和少样本（第 16 页）
public void pt_one_shot_few_shots(ChatClient chatClient) {
    String pizzaOrder = chatClient.prompt("""
            将客户的披萨订单解析为有效的 JSON

            示例 1：
            我想要一个小披萨，加奶酪、番茄酱和意大利辣香肠。
            JSON 响应：
            ```
            {
                "size": "small",
                "type": "normal",
                "ingredients": ["cheese", "tomato sauce", "pepperoni"]
            }
            ```

            示例 2：
            我能要一个大披萨，加番茄酱、罗勒和马苏里拉奶酪吗。
            JSON 响应：
            ```
            {
                "size": "large",
                "type": "normal",
                "ingredients": ["tomato sauce", "basil", "mozzarella"]
            }
            ```

            现在，我想要一个大披萨，前半部分加奶酪和马苏里拉奶酪。
            后半部分加番茄酱、火腿和菠萝。
            """)
            .options(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(0.1)
                    .maxTokens(250)
                    .build())
            .call()
            .content();
}

// 实现第 2.4 节：退步提示
public void pt_step_back_prompting(ChatClient.Builder chatClientBuilder) {
    // 为聊天客户端设置通用选项
    var chatClient = chatClientBuilder
            .defaultOptions(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(1.0)
                    .topK(40)
                    .topP(0.8)
                    .maxTokens(1024)
                    .build())
            .build();

    // 首先获取高级概念
    String stepBack = chatClient
            .prompt("""
                    基于流行的第一人称射击动作游戏，在第一人称射击视频游戏中，
                    哪些 5 个虚构的关键设置有助于创造具有挑战性和吸引力的关卡故事情节？
                    """)
            .call()
            .content();

    // 然后在主要任务中使用这些概念
    String story = chatClient
            .prompt()
            .user(u -> u.text("""
                    为一个具有挑战性和吸引力的第一人称射击视频游戏的新关卡写一段故事情节。

                    上下文：{step-back}
                    """)
                    .param("step-back", stepBack))
            .call()
            .content();
}

// 实现第 2.5 节：思维链（CoT）- 零样本方法
public void pt_chain_of_thought_zero_shot(ChatClient chatClient) {
    String output = chatClient
            .prompt("""
                    当我 3 岁时，我的伴侣的年龄是我的 3 倍。现在，我 20 岁了。
                    我的伴侣多大了？

                    让我们一步一步思考。
                    """)
            .call()
            .content();
}

// 实现第 2.5 节：思维链（CoT）- 少样本方法
public void pt_chain_of_thought_singleshot_fewshots(ChatClient chatClient) {
    String output = chatClient
            .prompt("""
                    问：当我弟弟 2 岁时，我的年龄是他的两倍。现在我 40 岁了。
                    我弟弟多大了？让我们一步一步思考。
                    答：当我弟弟 2 岁时，我 2 * 2 = 4 岁。年龄差是 2 岁，我更大。
                    现在我 40 岁了，所以我弟弟是 40 - 2 = 38 岁。答案是 38。

                    问：当我 3 岁时，我的伴侣的年龄是我的 3 倍。现在我 20 岁了。
                    我的伴侣多大了？让我们一步一步思考。
                    答：
                    """)
            .call()
            .content();
}

// 实现第 2.6 节：自一致性
public void pt_self_consistency(ChatClient chatClient) {
    String email = """
            你好，
            我看到你使用 Wordpress 做网站。这是一个很棒的开源内容管理系统。
            我过去也使用过它。它有很多很棒的用户插件。而且设置起来相当容易。
            我确实注意到联系表单中有一个错误，当你选择名字字段时就会发生。
            看我附加的截图，我在名字字段中输入文本。注意我触发的 JavaScript 警告框。
            但除此之外，这是一个很棒的网站。我很喜欢阅读它。你可以把错误留在网站上，
            因为它让我有更多有趣的东西可读。
            祝好，
            黑客哈利。
            """;

    record EmailClassification(Classification classification, String reasoning) {
        enum Classification {
            IMPORTANT, NOT_IMPORTANT
        }
    }

    int importantCount = 0;
    int notImportantCount = 0;

    // 使用相同输入运行模型 5 次
    for (int i = 0; i < 5; i++) {
        EmailClassification output = chatClient
                .prompt()
                .user(u -> u.text("""
                        邮件：{email}
                        将上述邮件分类为重要或不重要。让我们一步一步思考并解释原因。
                        """)
                        .param("email", email))
                .options(ChatOptions.builder()
                        .temperature(1.0)  // 更高的温度以获得更多变化
                        .build())
                .call()
                .entity(EmailClassification.class);

        // 统计结果
        if (output.classification() == EmailClassification.Classification.IMPORTANT) {
            importantCount++;
        } else {
            notImportantCount++;
        }
    }

    // 通过多数投票确定最终分类
    String finalClassification = importantCount > notImportantCount ?
            "重要" : "不重要";
}

// 实现第 2.7 节：思维树（ToT）- 游戏解决示例
public void pt_tree_of_thoughts_game(ChatClient chatClient) {
    // 步骤 1：生成多个初始移动
    String initialMoves = chatClient
            .prompt("""
                    你正在下国际象棋。棋盘处于起始位置。
                    生成 3 个不同的可能开局移动。对于每个移动：
                    1. 用代数记谱法描述移动
                    2. 解释这个移动背后的战略思考
                    3. 从 1-10 评分这个移动的强度
                    """)
            .options(ChatOptions.builder()
                    .temperature(0.7)
                    .build())
            .call()
            .content();

    // 步骤 2：评估并选择最有希望的移动
    String bestMove = chatClient
            .prompt()
            .user(u -> u.text("""
                    分析这些开局移动并选择最强的一个：
                    {moves}

                    一步一步解释你的推理，考虑：
                    1. 位置控制
                    2. 发展潜力
                    3. 长期战略优势

                    然后选择单个最佳移动。
                    """).param("moves", initialMoves))
            .call()
            .content();

    // 步骤 3：从最佳移动探索未来游戏状态
    String gameProjection = chatClient
            .prompt()
            .user(u -> u.text("""
                    基于这个选定的开局移动：
                    {best_move}

                    预测双方接下来的 3 步。对于每个潜在分支：
                    1. 描述移动和反移动
                    2. 评估结果位置
                    3. 确定最有希望的延续

                    最后，确定最有利的移动序列。
                    """).param("best_move", bestMove))
            .call()
            .content();
}

// 实现第 2.8 节：自动提示工程
public void pt_automatic_prompt_engineering(ChatClient chatClient) {
    // 生成相同请求的变体
    String orderVariants = chatClient
            .prompt("""
                    我们有一个乐队周边 T 恤网店，为了训练聊天机器人，我们需要各种订购方式：
                    "一件 Metallica T 恤，尺码 S"。生成 10 个变体，保持相同的语义但保持相同的含义。
                    """)
            .options(ChatOptions.builder()
                    .temperature(1.0)  // 高温度以获得创造性
                    .build())
            .call()
            .content();

    // 评估并选择最佳变体
    String output = chatClient
            .prompt()
            .user(u -> u.text("""
                    请对以下变体进行 BLEU（双语评估研究）评估：
                    ----
                    {variants}
                    ----

                    选择评估分数最高的指令候选。
                    """).param("variants", orderVariants))
            .call()
            .content();
}

// 实现第 2.9.1 节：编写代码的提示
public void pt_code_prompting_writing_code(ChatClient chatClient) {
    String bashScript = chatClient
            .prompt("""
                    用 Bash 写一个代码片段，它要求输入一个文件夹名称。
                    然后它获取文件夹的内容并重命名其中的所有文件，在文件名前添加 draft 前缀。
                    """)
            .options(ChatOptions.builder()
                    .temperature(0.1)  // 低温度以获得确定性代码
                    .build())
            .call()
            .content();
}

// 实现第 2.9.2 节：解释代码的提示
public void pt_code_prompting_explaining_code(ChatClient chatClient) {
    String code = """
            #!/bin/bash
            echo "Enter the folder name: "
            read folder_name
            if [ ! -d "$folder_name" ]; then
            echo "Folder does not exist."
            exit 1
            fi
            files=( "$folder_name"/* )
            for file in "${files[@]}"; do
            new_file_name="draft_$(basename "$file")"
            mv "$file" "$new_file_name"
            done
            echo "Files renamed successfully."
            """;

    String explanation = chatClient
            .prompt()
            .user(u -> u.text("""
                    向我解释下面的 Bash 代码：
                    ```
                    {code}
                    ```
                    """).param("code", code))
            .call()
            .content();
}

// 实现第 2.9.3 节：翻译代码的提示
public void pt_code_prompting_translating_code(ChatClient chatClient) {
    String bashCode = """
            #!/bin/bash
            echo "Enter the folder name: "
            read folder_name
            if [ ! -d "$folder_name" ]; then
            echo "Folder does not exist."
            exit 1
            fi
            files=( "$folder_name"/* )
            for file in "${files[@]}"; do
            new_file_name="draft_$(basename "$file")"
            mv "$file" "$new_file_name"
            done
            echo "Files renamed successfully."
            """;

    String pythonCode = chatClient
            .prompt()
            .user(u -> u.text("""
                    将下面的 Bash 代码翻译成 Python 片段：
                    {code}
                    """).param("code", bashCode))
            .call()
            .content();
}