Memoria de chat en Spring AI: ChatMemory, repositorios y advisors
Haz que tu asistente recuerde la conversación con Spring AI 2.0: ChatMemory, ventana de mensajes, repositorio JDBC, MessageChatMemoryAdvisor y sus límites.
Escrito contra Spring AI 2.0.2, Spring Boot 4.1.2 y Java 21. Código compilado, probado con un modelo falso y ejecutado contra un modelo local (Ollama,
gpt-oss) con H2 en memoria.
Los modelos de lenguaje no recuerdan nada. Si le dices tu nombre en una petición y lo preguntas en la siguiente, no lo sabe, porque cada llamada llega sin contexto. La solución es reenviar el historial relevante en cada petición. Spring AI lo resuelve con dos piezas: ChatMemory, que decide qué mensajes se conservan, y un advisor de ChatClient que los carga y los guarda por ti. Si aún no has visto el cliente, empieza por el ChatClient fluido.
Memoria no es historial
La documentación distingue dos cosas. Memoria es lo que el modelo recibe para mantener el contexto: una selección acotada. Historial es todo lo que se dijo. ChatMemory está pensado para lo primero; si necesitas un registro completo para auditoría o para mostrarlo en tu UI, guárdalo aparte con tu persistencia habitual.
Las piezas
ChatMemory: la estrategia (qué conservar y cuándo descartar). La implementación incluida esMessageWindowChatMemory: una ventana de los últimos N mensajes (20 por defecto).ChatMemoryRepository: solo almacena y recupera. HayInMemoryChatMemoryRepository(por defecto),JdbcChatMemoryRepository, y variantes para Cassandra, Neo4j, MongoDB y Redis.MessageChatMemoryAdvisor: el advisor que, en cada llamada, lee el historial de la conversación, lo añade como mensajes al prompt y guarda la nueva pregunta y la respuesta.VectorStoreChatMemoryAdvisor: alternativa que guarda los mensajes en unVectorStorey recupera los relevantes, añadiéndolos como texto al mensaje de sistema. No lo hemos probado.
Spring AI autoconfigura un ChatMemory ya listo (ventana sobre el repositorio que encuentre). Aquí lo definimos nosotros para elegir el tamaño de la ventana y usar JDBC.
Ejemplo completo
Dependencias: el starter del modelo, el del repositorio JDBC y una base de datos (H2 para el ejemplo).
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
@Configuration
class MemoryConfig {
@Bean
ChatMemory chatMemory(ChatMemoryRepository repository) {
return MessageWindowChatMemory.builder()
.chatMemoryRepository(repository)
.maxMessages(10)
.build();
}
@Bean
ChatClient assistant(ChatClient.Builder builder, ChatMemory chatMemory) {
return builder
.defaultSystem("Eres un asistente de soporte de una academia de Java. Responde en español, en una frase.")
.defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
.build();
}
}
@PostMapping("/chat/{conversationId}")
String chat(@PathVariable String conversationId, @RequestBody String message) {
return assistant.prompt()
.user(message)
.advisors(a -> a.param(ChatMemory.CONVERSATION_ID, conversationId))
.call()
.content();
}
@DeleteMapping("/chat/{conversationId}")
void forget(@PathVariable String conversationId) {
chatMemory.clear(conversationId);
}
Resultado real contra el modelo local:
POST /chat/ana "Me llamo Ana y estudio el curso de Spring Boot."
→ ¡Hola Ana! ¿En qué aspecto del curso de Spring Boot necesitas ayuda?
POST /chat/ana "¿Cómo me llamo y qué curso estudio?"
→ Te llamas Ana y estudias el curso de Spring Boot.
POST /chat/luis "¿Cómo me llamo?"
→ No lo sé, dime tu nombre.
DELETE /chat/ana, y de nuevo POST /chat/ana "¿Cómo me llamo?"
→ No lo sé, dime tu nombre.
Qué viaja realmente al modelo
Con un modelo falso que registra el prompt, la segunda petición de ana contenía, en orden: SYSTEM: Eres un asistente., USER: Me llamo Ana, ASSISTANT: respuesta 1, USER: ¿Cómo me llamo?. La memoria no es magia: es reenviar mensajes. Cada turno cuesta más tokens que el anterior hasta que la ventana se llena.
El identificador de conversación
Todo se indexa por ChatMemory.CONVERSATION_ID, y es obligatorio en cada llamada con advisor de memoria. Si lo olvidas no hay valor por defecto: la llamada lanza IllegalArgumentException: conversationId cannot be null (lo reprodujimos). Es un fallo ruidoso, y es mejor así que mezclar usuarios.
El riesgo real es el contrario: usar un identificador fijo o compartido, con lo que todos los usuarios comparten conversación. En nuestros tests, dos identificadores distintos no se ven entre sí. Deriva el identificador en el servidor, desde el usuario autenticado (y la conversación, si puede tener varias), nunca de un valor que el cliente pueda elegir libremente.
Cómo se comporta la ventana
Con maxMessages(4) añadimos un mensaje de sistema y cinco turnos usuario/asistente. Lo que quedó fue [SYSTEM: regla, USER: u5, ASSISTANT: a5]: tres mensajes, no cuatro. Dos cosas que la documentación explica y aquí se ven:
- Los mensajes de sistema se conservan siempre.
- La expulsión se hace por turnos completos, no a mitad de uno. Por eso
maxMessageses un máximo, no un número exacto.
Dimensiona la ventana para que quepa al menos un turno típico completo. Y recuerda que una ventana pequeña implica olvido: el usuario dirá "como te dije antes" sobre algo que ya salió de la ventana, y el modelo responderá sin ese dato. Eso no produce ningún error: lo notarás por respuestas que "pierden el hilo". Para conversaciones largas, la opción habitual es resumir los mensajes antiguos; Spring AI no lo incluye en ChatMemory.
Qué repositorio elegir
InMemoryChatMemoryRepository guarda los mensajes en un ConcurrentHashMap: sirve para desarrollo y demos, y se pierde todo al reiniciar o al tener varias instancias de la aplicación detrás de un balanceador. En cuanto tengas más de un nodo o quieras sobrevivir a un despliegue, necesitas un almacén compartido. Si ya tienes una base relacional, JDBC es el camino corto: no añade infraestructura. Cassandra, Neo4j, MongoDB y Redis encajan cuando ya los usas en el proyecto. Como el repositorio solo almacena y la estrategia está en ChatMemory, cambiar de uno a otro no toca el código del controlador ni la configuración del advisor.
Persistencia con JDBC
Con el starter JDBC y H2 embebido, el esquema se crea solo (por defecto solo para bases embebidas; en otras, spring.ai.chat.memory.repository.jdbc.initialize-schema=always o gestiona la tabla con Flyway/Liquibase y pon never). En nuestra ejecución la tabla SPRING_AI_CHAT_MEMORY tenía las columnas CONVERSATION_ID, CONTENT, TYPE, TIMESTAMP y SEQUENCE_ID; tras guardar un mensaje de usuario y una respuesta había dos filas, y al leer volvían en orden. Cada mensaje trae su fecha en los metadatos (JdbcChatMemoryRepository.CONVERSATION_TS, un Instant). Si actualizas desde una versión anterior a 2.0, la columna sequence_id es nueva y hay que migrar el esquema (ver las notas de actualización).
Cómo probarlo sin modelo
Todo el comportamiento anterior se verifica con un ChatModel falso que guarda los prompts recibidos y responde "respuesta N". Así se comprueba, sin gastar tokens, que la segunda petición lleva el primer intercambio, que dos conversaciones no se mezclan, que clear olvida y que falta el identificador:
var c = ChatClient.builder(model)
.defaultSystem("Eres un asistente.")
.defaultAdvisors(MessageChatMemoryAdvisor.builder(memory).build())
.build();
c.prompt().user("Me llamo Ana")
.advisors(a -> a.param(ChatMemory.CONVERSATION_ID, "ana"))
.call().content();
Para el repositorio JDBC usamos un @SpringBootTest con H2 en memoria y consultamos la tabla directamente. Estos tests no dicen si el modelo usa bien lo que recuerda; para eso, la prueba con modelo real del apartado anterior.
Límites que debes conocer
- Herramientas. Según la documentación, los mensajes intermedios de las llamadas a herramientas no se guardan en la memoria, y
JdbcChatMemoryRepository(igual que el de Cassandra) descarta sin avisar los mensajes con llamadas a herramientas. No lo hemos comprobado nosotros. Si tu asistente usa tools, como las del servidor MCP, diseña el historial con eso en cuenta. - Coste. Todo lo que está en la ventana se envía cada vez.
- Privacidad. Estás guardando conversaciones de usuarios: define retención, borrado (
clear) y qué datos personales no deben entrar. - Concurrencia. Dos peticiones simultáneas con el mismo identificador pueden intercalar mensajes; no lo hemos probado, así que serializa por conversación si te importa el orden.
Para llevarlo más lejos
Memoria de conversación es solo una capa. En el curso de Spring AI con Spring Boot la combinamos con herramientas y datos propios, y el máster AI Engineer trabaja la persistencia y el control de costes de asistentes reales.
Artículos relacionados
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.