聊聊Spring AI的Prompt

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

	private final List<Message> messages;

	private ChatOptions chatOptions;

	public Prompt(String contents) {
		this(new UserMessage(contents));
	}

	public Prompt(Message message) {
		this(Collections.singletonList(message));
	}

	public Prompt(List<Message> messages) {
		this(messages, null);
	}

	public Prompt(Message... messages) {
		this(Arrays.asList(messages), null);
	}

	public Prompt(String contents, ChatOptions chatOptions) {
		this(new UserMessage(contents), chatOptions);
	}

	public Prompt(Message message, ChatOptions chatOptions) {
		this(Collections.singletonList(message), chatOptions);
	}

	public Prompt(List<Message> messages, ChatOptions chatOptions) {
		this.messages = messages;
		this.chatOptions = chatOptions;
	}

	public String getContents() {
		StringBuilder sb = new StringBuilder();
		for (Message message : getInstructions()) {
			sb.append(message.getText());
		}
		return sb.toString();
	}

	//......
}	

public interface Message extends Content {

	/**
	 * Get the message type.
	 * @return the message type
	 */
	MessageType getMessageType();

}

public enum MessageType {

	/**
	 * A {@link Message} of type {@literal user}, having the user role and originating
	 * from an end-user or developer.
	 * @see UserMessage
	 */
	USER("user"),

	/**
	 * A {@link Message} of type {@literal assistant} passed in subsequent input
	 * {@link Message Messages} as the {@link Message} generated in response to the user.
	 * @see AssistantMessage
	 */
	ASSISTANT("assistant"),

	/**
	 * A {@link Message} of type {@literal system} passed as input {@link Message
	 * Messages} containing high-level instructions for the conversation, such as behave
	 * like a certain character or provide answers in a specific format.
	 * @see SystemMessage
	 */
	SYSTEM("system"),

	/**
	 * A {@link Message} of type {@literal function} passed as input {@link Message
	 * Messages} with function content in a chat application.
	 * @see ToolResponseMessage
	 */
	TOOL("tool");

	private final String value;

	MessageType(String value) {
		this.value = value;
	}

	public static MessageType fromValue(String value) {
		for (MessageType messageType : MessageType.values()) {
			if (messageType.getValue().equals(value)) {
				return messageType;
			}
		}
		throw new IllegalArgumentException("Invalid MessageType value: " + value);
	}

	public String getValue() {
		return this.value;
	}

}

public interface PromptTemplateMessageActions {

	Message createMessage();

	Message createMessage(List<Media> mediaList);

	Message createMessage(Map<String, Object> model);

}

public interface PromptTemplateStringActions {

	String render();

	String render(Map<String, Object> model);

}

public interface PromptTemplateChatActions {

	List<Message> createMessages();

	List<Message> createMessages(Map<String, Object> model);

}

public interface PromptTemplateActions extends PromptTemplateStringActions {

	Prompt create();

	Prompt create(ChatOptions modelOptions);

	Prompt create(Map<String, Object> model);

	Prompt create(Map<String, Object> model, ChatOptions modelOptions);

}

public class PromptTemplate implements PromptTemplateActions, PromptTemplateMessageActions {

	protected String template;

	protected TemplateFormat templateFormat = TemplateFormat.ST;

	private ST st;

	private Map<String, Object> dynamicModel = new HashMap<>();

	//......

	// Render Methods
	@Override
	public String render() {
		validate(this.dynamicModel);
		return this.st.render();
	}

	@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());
			}

		}
		return this.st.render();
	}

	@Override
	public Message createMessage() {
		return new UserMessage(render());
	}

	@Override
	public Message createMessage(List<Media> mediaList) {
		return new UserMessage(render(), mediaList);
	}

	@Override
	public Message createMessage(Map<String, Object> model) {
		return new UserMessage(render(model));
	}

	@Override
	public Prompt create() {
		return new Prompt(render(new HashMap<>()));
	}

	@Override
	public Prompt create(ChatOptions modelOptions) {
		return new Prompt(render(new HashMap<>()), modelOptions);
	}

	@Override
	public Prompt create(Map<String, Object> model) {
		return new Prompt(render(model));
	}

	@Override
	public Prompt create(Map<String, Object> model, ChatOptions modelOptions) {
		return new Prompt(render(model), modelOptions);
	}

	//......		
}	

public class SystemPromptTemplate extends PromptTemplate {

	public SystemPromptTemplate(String template) {
		super(template);
	}

	public SystemPromptTemplate(Resource resource) {
		super(resource);
	}

	@Override
	public Message createMessage() {
		return new SystemMessage(render());
	}

	@Override
	public Message createMessage(Map<String, Object> model) {
		return new SystemMessage(render(model));
	}

	@Override
	public Prompt create() {
		return new Prompt(new SystemMessage(render()));
	}

	@Override
	public Prompt create(Map<String, Object> model) {
		return new Prompt(new SystemMessage(render(model)));
	}

}

public class FunctionPromptTemplate extends PromptTemplate {

	private String name;

	public FunctionPromptTemplate(String template) {
		super(template);
	}

}

public class ChatPromptTemplate implements PromptTemplateActions, PromptTemplateChatActions {

	private final List<PromptTemplate> promptTemplates;

	public ChatPromptTemplate(List<PromptTemplate> promptTemplates) {
		this.promptTemplates = promptTemplates;
	}

	@Override
	public String render() {
		StringBuilder sb = new StringBuilder();
		for (PromptTemplate promptTemplate : this.promptTemplates) {
			sb.append(promptTemplate.render());
		}
		return sb.toString();
	}

	@Override
	public String render(Map<String, Object> model) {
		StringBuilder sb = new StringBuilder();
		for (PromptTemplate promptTemplate : this.promptTemplates) {
			sb.append(promptTemplate.render(model));
		}
		return sb.toString();
	}

	@Override
	public List<Message> createMessages() {
		List<Message> messages = new ArrayList<>();
		for (PromptTemplate promptTemplate : this.promptTemplates) {
			messages.add(promptTemplate.createMessage());
		}
		return messages;
	}

	@Override
	public List<Message> createMessages(Map<String, Object> model) {
		List<Message> messages = new ArrayList<>();
		for (PromptTemplate promptTemplate : this.promptTemplates) {
			messages.add(promptTemplate.createMessage(model));
		}
		return messages;
	}

	@Override
	public Prompt create() {
		List<Message> messages = createMessages();
		return new Prompt(messages);
	}

	@Override
	public Prompt create(ChatOptions modelOptions) {
		List<Message> messages = createMessages();
		return new Prompt(messages, modelOptions);
	}

	@Override
	public Prompt create(Map<String, Object> model) {
		List<Message> messages = createMessages(model);
		return new Prompt(messages);
	}

	@Override
	public Prompt create(Map<String, Object> model, ChatOptions modelOptions) {
		List<Message> messages = createMessages(model);
		return new Prompt(messages, modelOptions);
	}

}

public class AssistantPromptTemplate extends PromptTemplate {

	public AssistantPromptTemplate(String template) {
		super(template);
	}

	public AssistantPromptTemplate(Resource resource) {
		super(resource);
	}

	@Override
	public Prompt create() {
		return new Prompt(new AssistantMessage(render()));
	}

	@Override
	public Prompt create(Map<String, Object> model) {
		return new Prompt(new AssistantMessage(render(model)));
	}

	@Override
	public Message createMessage() {
		return new AssistantMessage(render());
	}

	@Override
	public Message createMessage(Map<String, Object> model) {
		return new AssistantMessage(render(model));
	}

}

PromptTemplate promptTemplate = new PromptTemplate("Tell me a {adjective} joke about {topic}");

Prompt prompt = promptTemplate.create(Map.of("adjective", adjective, "topic", topic));

return chatModel.call(prompt).getResult();

String userText = """
    Tell me about three famous pirates from the Golden Age of Piracy and why they did.
    Write at least a sentence for each pirate.
    """;

Message userMessage = new UserMessage(userText);

String systemText = """
  You are a helpful AI assistant that helps people find information.
  Your name is {name}
  You should reply to the user's request with your name and also in the style of a {voice}.
  """;

SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(systemText);
Message systemMessage = systemPromptTemplate.createMessage(Map.of("name", name, "voice", voice));

Prompt prompt = new Prompt(List.of(userMessage, systemMessage));

List<Generation> response = chatModel.call(prompt).getResults();