跳到主要内容

提示工程模式

DeepSeek V3 中英对照 Prompt Engineering Patterns

基于全面的提示工程指南，本文提供了提示工程技术的实际实现。该指南涵盖了有效提示工程的理论、原则和模式，而这里我们将演示如何使用 Spring AI 流畅的 ChatClient API 将这些概念转化为可运行的 Java 代码。本文使用的演示源代码可在以下位置找到：提示工程模式示例。

1. 配置​

配置部分概述了如何使用 Spring AI 设置和调整您的大型语言模型（LLM）。它涵盖了为您的用例选择合适的 LLM 提供商，以及配置控制模型输出质量、风格和格式的重要生成参数。

LLM 提供商选择​

在提示工程中，您首先需要选择一个模型。Spring AI 支持多个 LLM 提供商（例如 OpenAI、Anthropic、Google Vertex AI、AWS Bedrock、Ollama 等），让您无需更改应用程序代码即可切换提供商——只需更新配置即可。只需添加选定的启动器依赖项 spring-ai-starter-model-<MODEL-PROVIDER-NAME>。例如，以下是如何启用 Anthropic Claude API：

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

你可以像这样指定LLM模型名称：

.options(ChatOptions.builder()
        .model("claude-3-7-sonnet-latest")  // Use Anthropic's Claude model
        .build())

有关启用每个模型的详细信息，请参阅参考文档。

LLM 输出配置​

聊天选项流程

在深入探讨提示工程技巧之前，理解如何配置大语言模型的输出行为至关重要。Spring AI 提供了多种配置选项，允许您通过 ChatOptions 构建器来控制生成的各个方面。

所有配置都可以通过编程方式应用，如下面的示例所示，也可以在启动时通过 Spring 应用程序属性进行配置。

温度​

温度控制模型响应的随机性或“创造性”。

  • 较低值（0.0-0.3）：更具确定性，回答更聚焦。适用于事实性问题、分类或对一致性要求严格的任务。

  • 中等值（0.4-0.7）：在确定性和创造性之间取得平衡。适用于一般用例。

  • 较高值（0.8-1.0）：更具创造性、多样性，可能产生出人意料的回答。适用于创意写作、头脑风暴或生成多样化选项。

.options(ChatOptions.builder()
        .temperature(0.1)  // Very deterministic output
        .build())

理解温度对于提示工程至关重要，因为不同的技术需要不同的温度设置。

输出长度（MaxTokens）​

maxTokens 参数限制了模型在其响应中可以生成的标记（词片段）数量。

  • 低值（5-25）：适用于单个词语、短句或分类标签。

  • 中值（50-500）：适用于段落或简短说明。

  • 高值（1000+）：适用于长篇内容、故事或复杂说明。

.options(ChatOptions.builder()
        .maxTokens(250)  // Medium-length response
        .build())

设置合适的输出长度对于确保获得完整回复且避免不必要的冗长至关重要。

采样控制（Top-K 与 Top-P）​

这些参数让你能够在生成过程中对令牌选择过程进行精细控制。

  • Top-K: 将下一个令牌的选择限制在概率最高的 K 个令牌中。较高的值（例如 40-50）会引入更多多样性。

  • Top-P（核采样）: 动态地从累积概率超过 P 的最小令牌集合中进行选择。常见的值如 0.8-0.95。

.options(ChatOptions.builder()
        .topK(40)      // Consider only the top 40 tokens
        .topP(0.8)     // Sample from tokens that cover 80% of probability mass
        .build())

这些采样控制与温度参数协同工作，共同塑造模型的响应特性。

结构化响应格式​

除了纯文本响应（使用 .content() 方法），Spring AI 还通过 .entity() 方法，让开发者能够轻松地将 LLM 的响应直接映射到 Java 对象。

enum Sentiment {
    POSITIVE, NEUTRAL, NEGATIVE
}

Sentiment result = chatClient.prompt("...")
        .call()
        .entity(Sentiment.class);

当与指示模型返回结构化数据的系统提示结合使用时，这一功能尤为强大。

模型特定选项​

虽然可移植的 ChatOptions 为不同的 LLM 提供商提供了一致的接口，但 Spring AI 也提供了特定于模型的选项类，这些类公开了特定于提供商的功能和配置。这些特定于模型的选项允许您利用每个 LLM 提供商的独特功能。

// Using OpenAI-specific options
OpenAiChatOptions openAiOptions = OpenAiChatOptions.builder()
        .model("gpt-4o")
        .temperature(0.2)
        .frequencyPenalty(0.5)      // OpenAI-specific parameter
        .presencePenalty(0.3)       // OpenAI-specific parameter
        .responseFormat(new ResponseFormat("json_object"))  // OpenAI-specific JSON mode
        .seed(42)                   // OpenAI-specific deterministic generation
        .build();

String result = chatClient.prompt("...")
        .options(openAiOptions)
        .call()
        .content();

// Using Anthropic-specific options
AnthropicChatOptions anthropicOptions = AnthropicChatOptions.builder()
        .model("claude-3-7-sonnet-latest")
        .temperature(0.2)
        .topK(40)                   // Anthropic-specific parameter
        .thinking(AnthropicApi.ThinkingType.ENABLED, 1000)  // Anthropic-specific thinking configuration
        .build();

String result = chatClient.prompt("...")
        .options(anthropicOptions)
        .call()
        .content();

每个模型提供商都有其自己的聊天选项实现（例如 OpenAiChatOptions、AnthropicChatOptions、MistralAiChatOptions），这些实现暴露了特定于提供商的参数，同时仍然遵循通用接口。这种方法为您提供了灵活性：您可以使用可移植的选项以实现跨提供商的兼容性，或者在需要访问特定提供商的独特功能时使用模型特定的选项。

请注意，在使用模型特定选项时，您的代码会与该特定提供商绑定，从而降低可移植性。这是在访问高级提供商特定功能与在应用程序中保持提供商独立性之间的权衡。

2. 提示工程技巧​

以下每个部分都实现了指南中的一种特定提示工程技巧。通过同时学习"提示工程"指南和这些实现，您不仅能全面了解可用的提示工程技术，还能掌握如何在生产级Java应用中有效实施它们。

2.1 零样本提示​

零样本提示（Zero-shot prompting）是指在不提供任何示例的情况下，要求AI执行任务。这种方法测试模型从头开始理解和执行指令的能力。大型语言模型在大量文本语料上进行训练，使它们能够理解"翻译"、"摘要"或"分类"等任务的含义，而无需明确的演示。

零样本（Zero-shot）适用于模型在训练中可能见过类似示例的简单任务，以及当你希望最小化提示长度时。然而，性能可能会因任务复杂性和指令表述的清晰度而有所不同。

// Implementation of Section 2.1: General prompting / zero shot (page 15)
public void pt_zero_shot(ChatClient chatClient) {
    enum Sentiment {
        POSITIVE, NEUTRAL, NEGATIVE
    }

    Sentiment reviewSentiment = chatClient.prompt("""
            Classify movie reviews as POSITIVE, NEUTRAL or NEGATIVE.
            Review: "Her" is a disturbing study revealing the direction
            humanity is headed if AI is allowed to keep evolving,
            unchecked. I wish there were more movies like this masterpiece.
            Sentiment:
            """)
            .options(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(0.1)
                    .maxTokens(5)
                    .build())
            .call()
            .entity(Sentiment.class);

    System.out.println("Output: " + reviewSentiment);
}

此示例展示了如何在不提供示例的情况下对电影评论情感进行分类。请注意较低的温度值（0.1）以获得更确定性的结果，以及直接使用 .entity(Sentiment.class) 映射到 Java 枚举。

参考文献： Brown, T. B., et al. (2020). "Language Models are Few-Shot Learners." arXiv:2005.14165. https://arxiv.org/abs/2005.14165

2.2 单样本与少样本提示​

Few-shot prompting 为模型提供一个或多个示例来帮助引导其响应，特别适用于需要特定输出格式的任务。通过向模型展示期望的输入-输出对示例，模型可以学习模式并将其应用于新的输入，而无需显式的参数更新。

One-shot 提供一个示例，适用于示例成本较高或模式相对简单的情况。Few-shot 使用多个示例（通常为 3-5 个），帮助模型更好地理解更复杂任务中的模式，或展示正确输出的不同变体。

// Implementation of Section 2.2: One-shot & few-shot (page 16)
public void pt_one_shot_few_shots(ChatClient chatClient) {
    String pizzaOrder = chatClient.prompt("""
            Parse a customer's pizza order into valid JSON

            EXAMPLE 1:
            I want a small pizza with cheese, tomato sauce, and pepperoni.
            JSON Response:
            ```
            {
                "size": "small",
                "type": "normal",
                "ingredients": ["cheese", "tomato sauce", "pepperoni"]
            }
            ```

            EXAMPLE 2:
            Can I get a large pizza with tomato sauce, basil and mozzarella.
            JSON Response:
            ```
            {
                "size": "large",
                "type": "normal",
                "ingredients": ["tomato sauce", "basil", "mozzarella"]
            }
            ```

            Now, I would like a large pizza, with the first half cheese and mozzarella.
            And the other tomato sauce, ham and pineapple.
            """)
            .options(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(0.1)
                    .maxTokens(250)
                    .build())
            .call()
            .content();
}

Few-shot prompting 对于需要特定格式、处理边缘情况或任务定义在没有示例时可能模糊不清的任务尤其有效。示例的质量和多样性会显著影响性能。

参考文献： Brown, T. B., et al. (2020). "Language Models are Few-Shot Learners." arXiv:2005.14165. https://arxiv.org/abs/2005.14165

2.3 系统提示、上下文提示与角色提示​

系统提示​

系统提示为语言模型设定了整体上下文和目的，定义了模型应该做什么的“大局观”。它建立了模型响应的行为框架、约束条件和高级目标，这些与具体的用户查询是分开的。

系统提示在整个对话中充当持久的“任务声明”，允许您设置全局参数，如输出格式、语气、伦理边界或角色定义。与专注于特定任务的用户提示不同，系统提示框定了所有用户提示应如何被解释。

// Implementation of Section 2.3.1: System prompting
public void pt_system_prompting_1(ChatClient chatClient) {
    String movieReview = chatClient
            .prompt()
            .system("Classify movie reviews as positive, neutral or negative. Only return the label in uppercase.")
            .user("""
                    Review: "Her" is a disturbing study revealing the direction
                    humanity is headed if AI is allowed to keep evolving,
                    unchecked. It's so disturbing I couldn't watch it.

                    Sentiment:
                    """)
            .options(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(1.0)
                    .topK(40)
                    .topP(0.8)
                    .maxTokens(5)
                    .build())
            .call()
            .content();
}

系统提示在与 Spring AI 的实体映射功能结合使用时尤为强大：

// Implementation of Section 2.3.1: System prompting with JSON output
record MovieReviews(Movie[] movie_reviews) {
    enum Sentiment {
        POSITIVE, NEUTRAL, NEGATIVE
    }

    record Movie(Sentiment sentiment, String name) {
    }
}

MovieReviews movieReviews = chatClient
        .prompt()
        .system("""
                Classify movie reviews as positive, neutral or negative. Return
                valid JSON.
                """)
        .user("""
                Review: "Her" is a disturbing study revealing the direction
                humanity is headed if AI is allowed to keep evolving,
                unchecked. It's so disturbing I couldn't watch it.

                JSON Response:
                """)
        .call()
        .entity(MovieReviews.class);

系统提示在多轮对话中尤其有价值，它能确保跨多个查询的行为一致性，并建立适用于所有响应的格式约束，例如JSON输出。

参考： OpenAI. (2022). "系统消息。" https://platform.openai.com/docs/guides/chat/introduction

角色提示​

角色提示（Role prompting）指导模型采用特定的角色或身份，这会影响其生成内容的方式。通过为模型分配特定的身份、专业知识或视角，您可以影响其回答的风格、语气、深度和框架。

角色提示利用模型模拟不同专业领域和沟通风格的能力。常见的角色包括专家（例如，“你是一位经验丰富的数据科学家”）、专业人士（例如，“扮演一位旅行向导”）或风格化角色（例如，“像莎士比亚一样解释”）。

// Implementation of Section 2.3.2: Role prompting
public void pt_role_prompting_1(ChatClient chatClient) {
    String travelSuggestions = chatClient
            .prompt()
            .system("""
                    I want you to act as a travel guide. I will write to you
                    about my location and you will suggest 3 places to visit near
                    me. In some cases, I will also give you the type of places I
                    will visit.
                    """)
            .user("""
                    My suggestion: "I am in Amsterdam and I want to visit only museums."
                    Travel Suggestions:
                    """)
            .call()
            .content();
}

角色提示可以通过风格指令来增强：

// Implementation of Section 2.3.2: Role prompting with style instructions
public void pt_role_prompting_2(ChatClient chatClient) {
    String humorousTravelSuggestions = chatClient
            .prompt()
            .system("""
                    I want you to act as a travel guide. I will write to you about
                    my location and you will suggest 3 places to visit near me in
                    a humorous style.
                    """)
            .user("""
                    My suggestion: "I am in Amsterdam and I want to visit only museums."
                    Travel Suggestions:
                    """)
            .call()
            .content();
}

这项技术对于专业领域知识特别有效，能够确保回答语气的一致性，并创造更具吸引力、个性化的用户互动体验。

参考文献： Shanahan, M., et al. (2023). "Role-Play with Large Language Models." arXiv:2305.16367. https://arxiv.org/abs/2305.16367

上下文提示​

上下文提示通过传递上下文参数为模型提供额外的背景信息。这一技术丰富了模型对特定情境的理解，使其能够生成更相关、更贴合需求的响应，同时避免主指令变得冗杂。

通过提供上下文信息，您可以帮助模型理解与当前查询相关的特定领域、受众、约束条件或背景事实。这有助于获得更准确、相关且框架更合适的回答。

// Implementation of Section 2.3.3: Contextual prompting
public void pt_contextual_prompting(ChatClient chatClient) {
    String articleSuggestions = chatClient
            .prompt()
            .user(u -> u.text("""
                    Suggest 3 topics to write an article about with a few lines of
                    description of what this article should contain.

                    Context: {context}
                    """)
                    .param("context", "You are writing for a blog about retro 80's arcade video games."))
            .call()
            .content();
}

Spring AI 通过 param() 方法实现上下文提示的清晰化，从而注入上下文变量。当模型需要特定领域知识、需要根据特定受众或场景调整响应，以及确保响应符合特定约束或要求时，这种技术尤其有价值。

参考文献： Liu, P., et al. (2021). "What Makes Good In-Context Examples for GPT-3?" arXiv:2101.06804. https://arxiv.org/abs/2101.06804

2.4 退一步思考提示法​

Step-back prompting 通过先获取背景知识，将复杂请求分解为更简单的步骤。这项技术鼓励模型在处理具体查询之前，先从直接问题中"退一步"，考虑更广泛的背景、基本原理或与问题相关的一般性知识。

通过将复杂问题分解为更易管理的组成部分，并首先建立基础知识，该模型能够对困难问题提供更准确的回答。

// Implementation of Section 2.4: Step-back prompting
public void pt_step_back_prompting(ChatClient.Builder chatClientBuilder) {
    // Set common options for the chat client
    var chatClient = chatClientBuilder
            .defaultOptions(ChatOptions.builder()
                    .model("claude-3-7-sonnet-latest")
                    .temperature(1.0)
                    .topK(40)
                    .topP(0.8)
                    .maxTokens(1024)
                    .build())
            .build();

    // First get high-level concepts
    String stepBack = chatClient
            .prompt("""
                    Based on popular first-person shooter action games, what are
                    5 fictional key settings that contribute to a challenging and
                    engaging level storyline in a first-person shooter video game?
                    """)
            .call()
            .content();

    // Then use those concepts in the main task
    String story = chatClient
            .prompt()
            .user(u -> u.text("""
                    Write a one paragraph storyline for a new level of a first-
                    person shooter video game that is challenging and engaging.

                    Context: {step-back}
                    """)
                    .param("step-back", stepBack))
            .call()
            .content();
}

Step-back prompting 对于复杂的推理任务、需要专业领域知识的问题，以及当你希望获得更全面、更周到的回答而非即时答案时，尤其有效。

参考文献： Zheng, Z., et al. (2023). "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models." arXiv:2310.06117. https://arxiv.org/abs/2310.06117

2.5 思维链 (CoT)​

思维链提示鼓励模型逐步推理问题，这提高了复杂推理任务的准确性。通过明确要求模型展示其工作过程或按逻辑步骤思考问题，可以显著提升需要多步推理的任务性能。

CoT（思维链）的工作原理是鼓励模型在生成最终答案之前，先生成中间推理步骤，类似于人类解决复杂问题的方式。这使得模型的思考过程变得明确，并帮助其得出更准确的结论。

// Implementation of Section 2.5: Chain of Thought (CoT) - Zero-shot approach
public void pt_chain_of_thought_zero_shot(ChatClient chatClient) {
    String output = chatClient
            .prompt("""
                    When I was 3 years old, my partner was 3 times my age. Now,
                    I am 20 years old. How old is my partner?

                    Let's think step by step.
                    """)
            .call()
            .content();
}

// Implementation of Section 2.5: Chain of Thought (CoT) - Few-shot approach
public void pt_chain_of_thought_singleshot_fewshots(ChatClient chatClient) {
    String output = chatClient
            .prompt("""
                    Q: When my brother was 2 years old, I was double his age. Now
                    I am 40 years old. How old is my brother? Let's think step
                    by step.
                    A: When my brother was 2 years, I was 2 * 2 = 4 years old.
                    That's an age difference of 2 years and I am older. Now I am 40
                    years old, so my brother is 40 - 2 = 38 years old. The answer
                    is 38.
                    Q: When I was 3 years old, my partner was 3 times my age. Now,
                    I am 20 years old. How old is my partner? Let's think step
                    by step.
                    A:
                    """)
            .call()
            .content();
}

关键短语 "Let’s think step by step" 会触发模型展示其推理过程。CoT 对于数学问题、逻辑推理任务以及任何需要多步推理的问题尤其有价值。它通过使中间推理过程显式化，有助于减少错误。

参考文献： Wei, J., et al. (2022). "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." arXiv:2201.11903. https://arxiv.org/abs/2201.11903

2.6 自我一致性​

自洽性（Self-consistency）通过多次运行模型并聚合结果来获得更可靠的答案。该技术通过为同一问题采样多样化的推理路径，并通过多数投票选择最一致的答案，来解决大语言模型（LLM）输出的可变性问题。

通过在不同温度或采样设置下生成多条推理路径，然后聚合最终答案，自我一致性提高了复杂推理任务的准确性。这本质上是一种用于大语言模型输出的集成方法。

// Implementation of Section 2.6: Self-consistency
public void pt_self_consistency(ChatClient chatClient) {
    String email = """
            Hi,
            I have seen you use Wordpress for your website. A great open
            source content management system. I have used it in the past
            too. It comes with lots of great user plugins. And it's pretty
            easy to set up.
            I did notice a bug in the contact form, which happens when
            you select the name field. See the attached screenshot of me
            entering text in the name field. Notice the JavaScript alert
            box that I inv0k3d.
            But for the rest it's a great website. I enjoy reading it. Feel
            free to leave the bug in the website, because it gives me more
            interesting things to read.
            Cheers,
            Harry the Hacker.
            """;

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

    int importantCount = 0;
    int notImportantCount = 0;

    // Run the model 5 times with the same input
    for (int i = 0; i < 5; i++) {
        EmailClassification output = chatClient
                .prompt()
                .user(u -> u.text("""
                        Email: {email}
                        Classify the above email as IMPORTANT or NOT IMPORTANT. Let's
                        think step by step and explain why.
                        """)
                        .param("email", email))
                .options(ChatOptions.builder()
                        .temperature(1.0)  // Higher temperature for more variation
                        .build())
                .call()
                .entity(EmailClassification.class);

        // Count results
        if (output.classification() == EmailClassification.Classification.IMPORTANT) {
            importantCount++;
        } else {
            notImportantCount++;
        }
    }

    // Determine the final classification by majority vote
    String finalClassification = importantCount > notImportantCount ?
            "IMPORTANT" : "NOT IMPORTANT";
}

自洽性对于高风险决策、复杂推理任务以及需要比单一回答更可靠的答案时尤其有价值。其代价是由于多次API调用而增加的计算成本和延迟。

参考文献： Wang, X., et al. (2022). "Self-Consistency Improves Chain of Thought Reasoning in Language Models." arXiv:2203.11171. https://arxiv.org/abs/2203.11171

2.7 思维树 (ToT)​

Tree of Thoughts (ToT) 是一种先进的推理框架，它通过同时探索多条推理路径来扩展思维链。它将问题解决视为一个搜索过程，模型在其中生成不同的中间步骤，评估它们的潜力，并探索最有希望的路径。

这种技术对于具有多种可能方法的复杂问题，或是在找到最优路径前需要探索各种替代方案的情况尤为有效。

备注

原始的“提示工程”指南并未提供ToT的实现示例，这可能是由于其复杂性。以下是一个简化示例，用于演示其核心概念。

游戏求解思维树示例：

// Implementation of Section 2.7: Tree of Thoughts (ToT) - Game solving example
public void pt_tree_of_thoughts_game(ChatClient chatClient) {
    // Step 1: Generate multiple initial moves
    String initialMoves = chatClient
            .prompt("""
                    You are playing a game of chess. The board is in the starting position.
                    Generate 3 different possible opening moves. For each move:
                    1. Describe the move in algebraic notation
                    2. Explain the strategic thinking behind this move
                    3. Rate the move's strength from 1-10
                    """)
            .options(ChatOptions.builder()
                    .temperature(0.7)
                    .build())
            .call()
            .content();

    // Step 2: Evaluate and select the most promising move
    String bestMove = chatClient
            .prompt()
            .user(u -> u.text("""
                    Analyze these opening moves and select the strongest one:
                    {moves}

                    Explain your reasoning step by step, considering:
                    1. Position control
                    2. Development potential
                    3. Long-term strategic advantage

                    Then select the single best move.
                    """).param("moves", initialMoves))
            .call()
            .content();

    // Step 3: Explore future game states from the best move
    String gameProjection = chatClient
            .prompt()
            .user(u -> u.text("""
                    Based on this selected opening move:
                    {best_move}

                    Project the next 3 moves for both players. For each potential branch:
                    1. Describe the move and counter-move
                    2. Evaluate the resulting position
                    3. Identify the most promising continuation

                    Finally, determine the most advantageous sequence of moves.
                    """).param("best_move", bestMove))
            .call()
            .content();
}

参考文献： Yao, S., et al. (2023). "Tree of Thoughts: Deliberate Problem Solving with Large Language Models." arXiv:2305.10601. https://arxiv.org/abs/2305.10601

2.8 自动提示工程​

自动提示工程利用人工智能来生成和评估替代提示。这种元技术利用语言模型本身来创建、优化和基准测试不同的提示变体，从而为特定任务找到最优的表述。

通过系统性地生成和评估提示词变体，自动提示工程师（APE）能够找到比人工设计更有效的提示词，尤其适用于复杂任务。这是一种利用人工智能提升自身性能的方法。

// Implementation of Section 2.8: Automatic Prompt Engineering
public void pt_automatic_prompt_engineering(ChatClient chatClient) {
    // Generate variants of the same request
    String orderVariants = chatClient
            .prompt("""
                    We have a band merchandise t-shirt webshop, and to train a
                    chatbot we need various ways to order: "One Metallica t-shirt
                    size S". Generate 10 variants, with the same semantics but keep
                    the same meaning.
                    """)
            .options(ChatOptions.builder()
                    .temperature(1.0)  // High temperature for creativity
                    .build())
            .call()
            .content();

    // Evaluate and select the best variant
    String output = chatClient
            .prompt()
            .user(u -> u.text("""
                    Please perform BLEU (Bilingual Evaluation Understudy) evaluation on the following variants:
                    ----
                    {variants}
                    ----

                    Select the instruction candidate with the highest evaluation score.
                    """).param("variants", orderVariants))
            .call()
            .content();
}

APE 对于优化生产系统的提示词尤其有价值，它适用于手动提示工程已达到极限的具有挑战性的任务，并可用于大规模系统性地提升提示词质量。

参考文献： Zhou, Y., et al. (2022). "Large Language Models Are Human-Level Prompt Engineers." arXiv:2211.01910. https://arxiv.org/abs/2211.01910

2.9 代码提示​

代码提示（Code prompting）指的是针对代码相关任务的专门技术。这些技术利用大型语言模型理解和生成编程语言的能力，使其能够编写新代码、解释现有代码、调试问题以及在语言之间进行转换。

有效的代码提示通常需要清晰的规范、适当的上下文（库、框架、风格指南），有时还需要类似代码的示例。为了获得更确定性的输出，温度设置往往较低（0.1-0.3）。

// Implementation of Section 2.9.1: Prompts for writing code
public void pt_code_prompting_writing_code(ChatClient chatClient) {
    String bashScript = chatClient
            .prompt("""
                    Write a code snippet in Bash, which asks for a folder name.
                    Then it takes the contents of the folder and renames all the
                    files inside by prepending the name draft to the file name.
                    """)
            .options(ChatOptions.builder()
                    .temperature(0.1)  // Low temperature for deterministic code
                    .build())
            .call()
            .content();
}

// Implementation of Section 2.9.2: Prompts for explaining code
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("""
                    Explain to me the below Bash code:
                    ```
                    {code}
                    ```
                    """).param("code", code))
            .call()
            .content();
}

// Implementation of Section 2.9.3: Prompts for translating code
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("""
                    Translate the below Bash code to a Python snippet:
                    {code}
                    """).param("code", bashCode))
            .call()
            .content();
}

代码提示在自动化代码文档生成、原型设计、学习编程概念以及编程语言之间转换方面尤其有价值。通过将其与小样本提示或思维链等技术结合使用，可以进一步提高其有效性。

参考文献： Chen, M., et al. (2021). "Evaluating Large Language Models Trained on Code." arXiv:2107.03374. https://arxiv.org/abs/2107.03374

结论​

Spring AI 为所有主流提示工程技术提供了优雅的Java API。通过将这些技术与Spring强大的实体映射和流畅的API相结合，开发者能够用清晰、可维护的代码构建复杂的AI驱动应用程序。

最有效的方法通常涉及结合多种技术——例如，将系统提示与少量示例结合使用，或将思维链与角色提示结合使用。Spring AI 灵活的 API 使得这些组合的实现变得简单直接。

对于生产环境应用，请记住：

  1. 使用不同参数（temperature、top-k、top-p）测试提示词

  2. 对于关键决策，考虑使用自我一致性方法

  3. 利用 Spring AI 的实体映射功能实现类型安全的响应

  4. 使用上下文提示来提供特定于应用程序的知识

借助这些技术以及Spring AI强大的抽象能力，您可以构建出稳健的AI驱动应用程序，持续交付高质量的结果。

参考文献​

  1. Brown, T. B., 等人. (2020). "Language Models are Few-Shot Learners." arXiv:2005.14165.
  2. Wei, J., 等人. (2022). "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." arXiv:2201.11903.
  3. Wang, X., 等人. (2022). "Self-Consistency Improves Chain of Thought Reasoning in Language Models." arXiv:2203.11171.
  4. Yao, S., 等人. (2023). "Tree of Thoughts: Deliberate Problem Solving with Large Language Models." arXiv:2305.10601.
  5. Zhou, Y., 等人. (2022). "Large Language Models Are Human-Level Prompt Engineers." arXiv:2211.01910.
  6. Zheng, Z., 等人. (2023). "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models." arXiv:2310.06117.
  7. Liu, P., 等人. (2021). "What Makes Good In-Context Examples for GPT-3?" arXiv:2101.06804.
  8. Shanahan, M., 等人. (2023). "Role-Play with Large Language Models." arXiv:2305.16367.
  9. Chen, M., 等人. (2021). "Evaluating Large Language Models Trained on Code." arXiv:2107.03374.
  10. Spring AI 文档
  11. ChatClient API 参考
  12. Google 的提示工程指南