Advisors & Conversation Memory

The flow

1. 1.Authorize conversation
2. 2.Build scoped key
3. 3.Read window
4. 4.Call model
5. 5.Store turn

Memory is selected context

MessageWindowChatMemory retains a bounded number of messages for future requests. It is not a complete audit archive or a knowledge base. A message-count window also does not guarantee a token budget when individual messages are large.

MessageChatMemoryAdvisor applies the memory to the client flow. Advisor ordering affects which information reaches later steps; test combinations of retrieval, memory and tool execution rather than assuming their order is irrelevant.

A conversation key is not permission

The example combines a validated trusted user identifier and a UUID. Two users using the same UUID still receive different memory keys. Before invoking it, a real endpoint must resolve the conversation and verify ownership; a user-chosen UUID is not proof of ownership.

Do not store a current conversation ID in a shared field. In-memory repositories are appropriate for a local example but lose data on restart and do not coordinate across replicas.

Test isolation and retention

The fake model captures actual prompts. Tests prove that alpha's earlier topic is absent from beta's request, then present again in alpha's follow-up. Extend this with eviction, deletion and restart tests for the chosen repository.

Keep sensitive history retention explicit. Storing everything forever to make a chatbot feel consistent is not a context or privacy strategy.

Try it

package com.interviewpreparator.lab;
import java.util.UUID;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.model.ChatModel;
public final class ConversationExample {
    private final ChatClient client;
    public ConversationExample(ChatModel model) {
        ChatMemory memory = MessageWindowChatMemory.builder().maxMessages(6).build();
        this.client = ChatClient.builder(model)
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(memory).build()).build();
    }
    public String reply(String authenticatedUser, UUID conversation, String text) {
        if (authenticatedUser == null || !authenticatedUser.matches("[a-zA-Z0-9-]+")) {
            throw new IllegalArgumentException("Invalid trusted user ID");
        }
        if (conversation == null || text == null || text.isBlank() || text.length() > 500) {
            throw new IllegalArgumentException("Conversation and bounded message are required");
        }
        // Resolve and authorize conversation ownership before calling this method in a real service.
        String key = authenticatedUser + ":" + conversation;
        return client.prompt().user(text).advisors(advisor -> advisor.param(ChatMemory.CONVERSATION_ID, key))
                .call().content();
    }
}

examples/spring-ai-lab/src/main/java/com/interviewpreparator/lab/ConversationExample.java · mvn -f examples/spring-ai-lab/pom.xml test. Java 21+, Spring Boot 4.0.5, Spring AI 2.0.2 where applicable. The demo uses synthetic models; live inference quality is a separate check.

Interview questions

Official references

• Spring AI — chat memory

Continue learning

• Spring AI Tool Calling →
• Testing & Evaluation for Spring AI →