Las aplicaciones de IA generativa no necesitan más memoria, sino un olvido más inteligente. Al construir aplicaciones basadas en LLM, comienza por definir una memoria de trabajo eficaz.
Borras una dependencia, ChatGPT lo reconoce. Cinco respuestas después, vuelve a incluir esa misma librería obsoleta en tu código. La corriges otra vez—él asiente, se disculpa—y lo vuelve a hacer.
Esto no es solo un error molesto. Es un síntoma de un problema más profundo: las aplicaciones LLM no saben qué olvidar.
Los desarrolladores asumen que las herramientas basadas en IA generativa mejoran dinámicamente, aprenden de los errores, refinan su conocimiento y se adaptan. Pero no es así.
Los modelos de lenguaje grandes (LLM) son sin estado por diseño. Cada solicitud se procesa de forma aislada a menos que un sistema externo proporcione contexto previo.
Eso significa que la “memoria” no está integrada en el modelo, sino que se añade encima, a menudo de forma imperfecta.
Si has usado ChatGPT por un tiempo, probablemente has notado que:
- Recuerda algunas cosas entre sesiones pero olvida otras por completo.
- Se aferra a suposiciones obsoletas aunque las hayas corregido varias veces.
- A veces “olvida” detalles importantes dentro de una misma sesión.
Estos no son fallos del modelo, sino fallos en la gestión de la memoria.
Cómo funciona la memoria en aplicaciones LLM
Los LLM no tienen memoria persistente. Lo que parece “memoria” es en realidad reconstrucción de contexto, donde el historial relevante se recarga manualmente en cada solicitud.
En la práctica, una aplicación como ChatGPT agrega múltiples capas de memoria sobre el modelo base:
- Ventana de contexto: Cada sesión mantiene un buffer rodante de mensajes anteriores. GPT-4o soporta hasta 128K tokens; otros modelos tienen distintos límites (por ejemplo, Claude soporta 200K tokens).
- Memoria a largo plazo: Algunos detalles se mantienen entre sesiones, pero la retención es inconsistente.
- Mensajes del sistema: Prompts invisibles que guían las respuestas del modelo; a menudo contienen la memoria a largo plazo.
- Contexto de ejecución: Estado temporal como variables en Python, que solo existen hasta que la sesión se reinicia.
Sin un soporte externo de memoria, las aplicaciones LLM permanecen sin estado. Cada llamada a la API es independiente, por lo que se debe recargar el contexto previo explícitamente para mantener la continuidad.
Por qué los LLM son sin estado por defecto
En integraciones vía API, los modelos no guardan memoria entre solicitudes. Si no pasas los mensajes anteriores, cada prompt se interpreta de forma aislada. Por ejemplo:
import { OpenAI } from "openai";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const response = await openai.chat.completions.create({
model: "gpt-4o",
messages: [
{ role: "system", content: "Eres un experto en Python que ayuda al usuario a depurar." },
{ role: "user", content: "¿Por qué mi función lanza un TypeError?" },
{ role: "assistant", content: "¿Puedes compartir el mensaje de error y el código de la función?" },
{ role: "user", content: "Claro, aquí está..." },
],
});
Cada petición debe incluir explícitamente el historial de mensajes si se requiere continuidad. Si el historial es muy largo, debes diseñar un sistema de memoria que lo gestione o arriesgarte a respuestas que omitan detalles clave o mantengan contexto obsoleto.
Cuando las aplicaciones LLM no quieren olvidar
Algunas aplicaciones LLM tienen el problema opuesto: no olvidan demasiado, sino que recuerdan lo equivocado.
¿Alguna vez le dijiste a ChatGPT “ignora eso que dije” y luego lo vuelve a mencionar? Eso es lo que llamo “memoria traumática”: un modelo que se aferra a detalles obsoletos o irrelevantes, degradando su utilidad.
Por ejemplo, probé una librería Python que no era útil, le dije a ChatGPT que la había eliminado.
Él lo reconoció—y siguió sugiriendo código que usaba esa librería obsoleta. No es un problema de alucinación, sino de mala recuperación de memoria.
Anthropic Claude, que ofrece caché de prompts y memoria persistente, va en la dirección correcta. Claude permite pasar fragmentos almacenados con identificadores validados para mejorar eficiencia y evitar repeticiones.
Pero aunque el caché mejora la continuidad, no resuelve el reto mayor: las aplicaciones deben decidir qué mantener activo en la memoria de trabajo, qué relegar a almacenamiento a largo plazo y qué descartar completamente.
Una memoria más inteligente requiere olvidar mejor
La memoria humana no solo recuerda; es selectiva. Filtramos detalles según relevancia, manteniendo en la memoria de trabajo la información importante y descartando ruido.
Las aplicaciones LLM no tienen esta habilidad a menos que se diseñe explícitamente.
Actualmente, los sistemas de memoria para LLM suelen caer en dos categorías erróneas:
- IA sin estado: Olvida todas las interacciones pasadas a menos que se recarguen manualmente.
- IA con memoria aumentada: Retiene información, pero elimina detalles incorrectos sin priorización real.
Para una mejor memoria en LLM se necesitan:
- Memoria de trabajo contextual: Gestión activa del contexto con resumen de mensajes y recuperación selectiva para evitar saturación de tokens.
- Memoria persistente: Almacenamiento a largo plazo que recupere según relevancia, no solo transcripciones completas (usando búsqueda vectorial, por ejemplo).
- Control atencional de la memoria: Sistema que priorice información útil y deje que los detalles obsoletos se desvanezcan. Por ejemplo, un asistente de código debería dejar de sugerir dependencias obsoletas tras múltiples correcciones.
La próxima generación de IA no necesita más memoria, sino mejor olvido
Aumentar la ventana de contexto no solucionará el problema.
Las aplicaciones LLM necesitan:
- Retención selectiva: Guardar solo conocimiento relevante, no transcripciones completas.
- Recuperación atencional: Priorizar detalles importantes y dejar atrás lo irrelevante.
- Mecanismos de olvido: Los detalles obsoletos o de bajo valor deben decaer con el tiempo.
Los próximos avances serán para modelos que sepan qué olvidar, no para los que recuerden todo.
Los desarrolladores deben empezar diseñando la memoria de trabajo para priorizar relevancia en el contexto, incluso si la memoria persistente se expande con el tiempo.