深入Spring AI：PromptTemplate从模板到高级技巧

UserMessage userMessage = new UserMessage(text);
String content = chatClient.prompt(new Prompt(userMessage)).call().content();

public class Prompt implements ModelRequest<List<Message>> {

    /**
     * 返回构成 Prompt 的消息列表。
     * 对于聊天模型，这通常包含用户消息、系统消息和助手消息。
     * 对于文本生成或嵌入模型，可能只有一个或多个用户消息。
     * @return 消息列表
     */
    private final List<Message> messages;

    /**
     * 返回与 Prompt 相关的选项。
     * 这些选项可能包含模型特定的参数，例如温度、最大 Token 数等。
     */
    @Nullable
    private ChatOptions chatOptions;

    ......

    /**
     * 返回 Prompt 的文本表示，这可能是将消息列表组合成单个字符串的结果。
     * 不同的模型可能需要不同格式的文本输入。
     * @return Prompt 的文本内容，如果没有则返回 null 或空字符串
     */
    public String getContents() {
       StringBuilder sb = new StringBuilder();
       for (Message message : getInstructions()) {
          sb.append(message.getText());
       }
       return sb.toString();
    }
}

public interface Content {

    String getText();
    Map<String, Object> getMetadata();

}


public interface Message extends Content {
    // MessageType用来区分消息类型，如USER, SYSTEM，ASSISTANT等
    MessageType getMessageType();
}

@GetMapping("/promptTemplate")
public String promptTemplate() {
    // 使用系统消息预定好角色风格
    SystemPromptTemplate systemTemplate = new SystemPromptTemplate ("你是一位风格{style}的演说家");
    Message systemMessage = systemTemplate.createMessage(Map.of("style", "幽默诙谐"));

    PromptTemplate userTemplate = new PromptTemplate("请介绍一下自己的{store}");
    Message userMessage = userTemplate.createMessage(Map.of("store", "情感经历"));

    List<Message> messages = List.of(systemMessage, userMessage);
    String content = chatClient.prompt(new Prompt(messages)).call().content();
    System.out.println(content);
    return content;
}

public class PromptTemplate implements PromptTemplateActions, PromptTemplateMessageActions {
    protected String template;
    protected TemplateFormat templateFormat = TemplateFormat.ST;
    private ST st;
    private Map<String, Object> dynamicModel = new HashMap<>();


    /**
     * 可以根据Resource 方式创建一个PromptTemplate对象
     * @param resource
     */
    public PromptTemplate(Resource resource) {
       // 将Resource资源文件中的数据读取出来
       try (InputStream inputStream = resource.getInputStream()) {
          this.template = StreamUtils.copyToString(inputStream, Charset.defaultCharset());
       }
       catch (IOException ex) {
          throw new RuntimeException("Failed to read resource", ex);
       }
       try {
          // 构建StringTemplate实例
          this.st = new ST(this.template, '{', '}');
       }
       catch (Exception ex) {
          throw new IllegalArgumentException("The template string is not valid.", ex);
       }
    }


    /**
     * 可以根据Resource 方式创建一个PromptTemplate对象
     * @param template
     */
    public PromptTemplate(String template) {
       this.template = template;
       // If the template string is not valid, an exception will be thrown
       try {
          // 构建StringTemplate实例
          this.st = new ST(this.template, '{', '}');
       }
       catch (Exception ex) {
          throw new IllegalArgumentException("The template string is not valid.", ex);
       }
    }

    public PromptTemplate(String template, Map<String, Object> model) {
       this.template = template;
       // If the template string is not valid, an exception will be thrown
       try {
          this.st = new ST(this.template, '{', '}');
          for (Entry<String, Object> entry : model.entrySet()) {
             add(entry.getKey(), entry.getValue());
          }
       }
       catch (Exception ex) {
          throw new IllegalArgumentException("The template string is not valid.", ex);
       }
    }
    
    
    @Override
    public String render() {
       validate(this.dynamicModel);
       return this.st.render();
    }


    /**
     * 最终封装message时，会调用该方法进行渲染
     * @return
     */
    @Override
    public String render(Map<String, Object> model) {
        
       // 校验传入的变量，与占位符是否一致。如果不一致则不通过
       validate(model);
       for (Entry<String, Object> entry : model.entrySet()) {
          if (this.st.getAttribute(entry.getKey()) != null) {
             this.st.remove(entry.getKey());
          }
          // 读取资源文件
          if (entry.getValue() instanceof Resource) {
             this.st.add(entry.getKey(), renderResource((Resource) entry.getValue()));
          }
          else {
             this.st.add(entry.getKey(), entry.getValue());
          }

       }
       // 最终调用render生成提示词
       return this.st.render();
    }

    /**
     * promptTemplate生成提示词
     */
    @Override
    public Message createMessage(Map<String, Object> model) {
        return new UserMessage(render(model));
    }
    
    private String renderResource(Resource resource) {
       try {
          return resource.getContentAsString(Charset.defaultCharset());
       }
       catch (IOException e) {
          throw new RuntimeException(e);
       }
    }

    protected void validate(Map<String, Object> model) {

       Set<String> templateTokens = getInputVariables();
       Set<String> modelKeys = getModelKeys(model);

       // Check if model provides all keys required by the template
       if (!modelKeys.containsAll(templateTokens)) {
          templateTokens.removeAll(modelKeys);
          throw new IllegalStateException(
                "Not all template variables were replaced. Missing variable names are " + templateTokens);
       }
    }
}

讲两个冷笑话，笑话的主题分别是{subject1}和{subject2}

@RestController
public class PromptTemplateWithSTController {

    @Value("classpath:/templates/user-message.st")
    private Resource promptUserMessage;

    private final ChatClient chatClient;
    public PromptTemplateWithSTController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/st")
    public String st() {
        PromptTemplate promptTemplate = new PromptTemplate(promptUserMessage);
        Prompt prompt = promptTemplate.create(Map.of("subject1", "程序员", "subject2", "打工人"));
        return chatClient.prompt(prompt)
                .call().content();
    }

}