tessl/maven-org-springframework-ai--spring-ai-model

Core model interfaces and abstractions for Spring AI framework providing portable API for chat, embeddings, images, audio, and tool calling across multiple AI providers

Overview

Eval results

Files

Chat Memory

Name: tessl/maven-org-springframework-ai--spring-ai-model
Author: tessl

Conversation history management including chat memory interfaces, message window implementations, and repository abstractions for persisting conversation state across interactions.

Capabilities

ChatMemory Interface

Interface for managing chat conversation history.

public interface ChatMemory {
    /**
     * Default conversation ID used when none is specified.
     */
    String DEFAULT_CONVERSATION_ID = "default";

    /**
     * Metadata key for conversation ID in messages.
     */
    String CONVERSATION_ID = "conversationId";

    /**
     * Add a single message to the conversation history.
     *
     * @param conversationId the conversation identifier
     * @param message the message to add
     */
    void add(String conversationId, Message message);

    /**
     * Add multiple messages to the conversation history.
     *
     * @param conversationId the conversation identifier
     * @param messages the messages to add
     */
    void add(String conversationId, List<Message> messages);

    /**
     * Get all messages for a conversation.
     *
     * @param conversationId the conversation identifier
     * @return list of messages in chronological order
     */
    List<Message> get(String conversationId);

    /**
     * Clear all messages for a conversation.
     *
     * @param conversationId the conversation identifier
     */
    void clear(String conversationId);
}

ChatMemoryRepository Interface

Repository interface for persisting chat history to storage.

public interface ChatMemoryRepository {
    /**
     * Save messages for a conversation to storage.
     *
     * @param conversationId the conversation identifier
     * @param messages the messages to save
     */
    void save(String conversationId, List<Message> messages);

    /**
     * Get messages for a conversation from storage.
     *
     * @param conversationId the conversation identifier
     * @return list of messages in chronological order
     */
    List<Message> get(String conversationId);

    /**
     * Clear all messages for a conversation from storage.
     *
     * @param conversationId the conversation identifier
     */
    void clear(String conversationId);
}

MessageWindowChatMemory

Sliding window implementation of ChatMemory that maintains a fixed number of recent messages.

public class MessageWindowChatMemory implements ChatMemory {
    /**
     * Construct a MessageWindowChatMemory with a repository and window size.
     *
     * @param repository the backing repository for persistence
     * @param maxMessages the maximum number of messages to retain
     */
    public MessageWindowChatMemory(ChatMemoryRepository repository, int maxMessages);

    @Override
    public void add(String conversationId, Message message);

    @Override
    public void add(String conversationId, List<Message> messages);

    @Override
    public List<Message> get(String conversationId);

    @Override
    public void clear(String conversationId);
}

InMemoryChatMemoryRepository

In-memory implementation of ChatMemoryRepository using ConcurrentHashMap.

public class InMemoryChatMemoryRepository implements ChatMemoryRepository {
    /**
     * Construct an InMemoryChatMemoryRepository.
     * Stores all conversations in memory.
     */
    public InMemoryChatMemoryRepository();

    @Override
    public void save(String conversationId, List<Message> messages);

    @Override
    public List<Message> get(String conversationId);

    @Override
    public void clear(String conversationId);
}

Usage Examples

Basic Chat Memory

import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.InMemoryChatMemoryRepository;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.messages.*;

// Create memory with window of 10 messages
ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    10
);

// Add messages
memory.add("user_123", new UserMessage("Hello!"));
memory.add("user_123", new AssistantMessage("Hi! How can I help?"));
memory.add("user_123", new UserMessage("What's the weather?"));

// Get conversation history
List<Message> history = memory.get("user_123");
System.out.println("Messages in history: " + history.size());

Using with ChatModel

import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.memory.ChatMemory;

@Service
public class ConversationService {
    private final ChatModel chatModel;
    private final ChatMemory chatMemory;

    public ConversationService(ChatModel chatModel, ChatMemory chatMemory) {
        this.chatModel = chatModel;
        this.chatMemory = chatMemory;
    }

    public String chat(String userId, String userInput) {
        // Create user message
        UserMessage userMessage = new UserMessage(userInput);

        // Get conversation history
        List<Message> history = chatMemory.get(userId);

        // Add new message to history
        List<Message> messages = new ArrayList<>(history);
        messages.add(userMessage);

        // Create prompt with full history
        Prompt prompt = new Prompt(messages);

        // Get response
        ChatResponse response = chatModel.call(prompt);
        AssistantMessage assistantMessage = response.getResult().getOutput();

        // Save both messages to memory
        chatMemory.add(userId, userMessage);
        chatMemory.add(userId, assistantMessage);

        return assistantMessage.getText();
    }

    public void clearHistory(String userId) {
        chatMemory.clear(userId);
    }
}

Multiple Conversations

ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    20
);

// Different conversations for different users
memory.add("user_1", new UserMessage("Hello from user 1"));
memory.add("user_2", new UserMessage("Hello from user 2"));

// Each conversation is isolated
List<Message> user1History = memory.get("user_1"); // Only user 1 messages
List<Message> user2History = memory.get("user_2"); // Only user 2 messages

Configuring Window Size

// Small window for short-term memory (5 messages)
ChatMemory shortTermMemory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    5
);

// Large window for longer conversations (100 messages)
ChatMemory longTermMemory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    100
);

// Add many messages - only last N are retained
for (int i = 0; i < 20; i++) {
    shortTermMemory.add("conv_1", new UserMessage("Message " + i));
}

// Only last 5 messages retained
List<Message> retained = shortTermMemory.get("conv_1");
System.out.println("Retained: " + retained.size()); // 5

Spring Bean Configuration

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ChatMemoryConfig {

    @Bean
    public ChatMemoryRepository chatMemoryRepository() {
        return new InMemoryChatMemoryRepository();
    }

    @Bean
    public ChatMemory chatMemory(ChatMemoryRepository repository) {
        return new MessageWindowChatMemory(repository, 50);
    }
}

Using Default Conversation ID

import org.springframework.ai.chat.memory.ChatMemory;

ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    10
);

// Use default conversation ID
memory.add(
    ChatMemory.DEFAULT_CONVERSATION_ID,
    new UserMessage("Hello")
);

List<Message> messages = memory.get(ChatMemory.DEFAULT_CONVERSATION_ID);

Clearing Conversation History

ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    10
);

// Add messages
memory.add("conv_1", new UserMessage("Message 1"));
memory.add("conv_1", new UserMessage("Message 2"));

// Clear conversation
memory.clear("conv_1");

// History is now empty
List<Message> history = memory.get("conv_1");
System.out.println("Size after clear: " + history.size()); // 0

Adding Batch Messages

ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    20
);

// Add multiple messages at once
List<Message> messages = List.of(
    new SystemMessage("You are a helpful assistant."),
    new UserMessage("Hello!"),
    new AssistantMessage("Hi! How can I help?")
);

memory.add("conv_1", messages);

Custom Repository Implementation

import org.springframework.ai.chat.memory.ChatMemoryRepository;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

public class DatabaseChatMemoryRepository implements ChatMemoryRepository {
    // Could use JPA, JDBC, Redis, etc.

    @Override
    public void save(String conversationId, List<Message> messages) {
        // Save to database
        // Implementation depends on your persistence layer
    }

    @Override
    public List<Message> get(String conversationId) {
        // Load from database
        // Implementation depends on your persistence layer
        return List.of();
    }

    @Override
    public void clear(String conversationId) {
        // Delete from database
        // Implementation depends on your persistence layer
    }
}

// Use custom repository
ChatMemory memory = new MessageWindowChatMemory(
    new DatabaseChatMemoryRepository(),
    50
);

Conversation Metadata

ChatMemory memory = new MessageWindowChatMemory(
    new InMemoryChatMemoryRepository(),
    10
);

// Add metadata to track conversation ID
Map<String, Object> metadata = Map.of(
    ChatMemory.CONVERSATION_ID, "conv_123",
    "userId", "user_456",
    "timestamp", System.currentTimeMillis()
);

UserMessage message = new UserMessage("Hello", List.of(), metadata);
memory.add("conv_123", message);

// Retrieve and check metadata
List<Message> history = memory.get("conv_123");
Message first = history.get(0);
String convId = (String) first.getMetadata().get(ChatMemory.CONVERSATION_ID);

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-ai--spring-ai-model