Memoria Short-term (Checkpointers)

Qué es la memoria Short-term

La Short-term Memory en LangGraph, técnicamente conocida como Checkpointing, es el mecanismo que permite a un agente pausar, reanudar y mantener el estado de una conversación a lo largo del tiempo. A diferencia de la memoria tradicional que simplemente concatena strings, el Checkpointing guarda el estado completo del grafo (Snapshot) en cada paso de la ejecución.

Esto es fundamental para aplicaciones reales, ya que permite:

• Persistencia entre turnos: El servidor puede apagarse y encenderse, y la conversación continúa donde se quedó.
• Time Travel: Puedes retroceder a un punto anterior de la conversación y bifurcarla (útil para debugging o corrección humana).
• Human-in-the-loop: El agente puede pausar para esperar aprobación humana antes de ejecutar una herramienta, persistiendo su estado mientras espera.

La clave para acceder a esta memoria es el thread_id. Si usas el mismo ID, el agente carga el estado previo; si usas uno nuevo, empieza desde cero.

InMemorySaver: Memoria volátil para desarrollo

El InMemorySaver es la forma más simple de persistencia. Guarda el estado en un diccionario en la memoria RAM de tu aplicación Python. Es ideal para scripts de prueba, aprendizaje y prototipado rápido, pero no sirve para producción porque si reinicias el script, pierdes todo el historial.

Características:

• Velocidad: Extremadamente rápido (sin latencia de red).
• Volatilidad: Los datos viven lo que dura el proceso de Python.
• Configuración: Cero configuración, solo importar y usar.

Ejemplo de implementación:

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# 1. Inicializamos el modelo y la memoria en RAM
model = ChatOpenAI(model="gpt-4o")
memory = InMemorySaver()

# 2. Creamos el agente pasándole el checkpointer
agent = create_react_agent(model, tools=[], checkpointer=memory)

# 3. Configuración del hilo (thread_id)
config = {"configurable": {"thread_id": "1"}}

# 4. Primera interacción
response = agent.invoke(
    {"messages": [("user", "Hola, me llamo Mike. ¿Cuánto es 1 + 1?")]},
    config=config
)
# El agente guarda en RAM que el usuario es Mike

# 5. Segunda interacción (mismo thread_id)
response = agent.invoke(
    {"messages": [("user", "¿Cómo me llamo?")]},
    config=config
)
print(response["messages"][-1].content) 
# Salida: "Te llamas Mike."

PostgresSaver: Persistencia robusta para producción

Para aplicaciones reales, necesitas que la memoria sobreviva a reinicios del servidor y pueda escalar. Aquí entra PostgresSaver, que serializa el estado del grafo y lo guarda en una base de datos PostgreSQL.

Esto permite que tu backend sea stateless: no importa qué instancia del servidor atienda la petición, siempre que se conecte a la misma base de datos y reciba el mismo thread_id, recuperará el contexto perfecto.

Requisitos:

• Librería langgraph-checkpoint-postgres.
• Una base de datos PostgreSQL corriendo.
• Tabla de checkpoints (se crea automáticamente con .setup()).

Ejemplo de implementación:

from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from psycopg_pool import ConnectionPool

# URI de conexión a tu base de datos Postgres
DB_URI = "postgresql://postgres:postgres@localhost:5432/mi_db"

# Usamos un ConnectionPool para manejar las conexiones eficientemente
with ConnectionPool(DB_URI) as pool:
    # 1. Inicializamos el checkpointer con el pool
    checkpointer = PostgresSaver(pool)
    
    # 2. IMPORTANTE: Crear las tablas necesarias en la primera ejecución
    checkpointer.setup()
    
    model = ChatOpenAI(model="gpt-4o")
    
    # 3. Creamos el agente conectado a la BD
    agent = create_react_agent(model, tools=[], checkpointer=checkpointer)
    
    # 4. Interactuamos usando un thread_id persistente
    config = {"configurable": {"thread_id": "hilo_persistente_1"}}
    
    response = agent.invoke(
        {"messages": [("user", "Guarda este dato: El código secreto es 1234")]},
        config=config
    )
    
    print("Mensaje procesado y estado guardado en Postgres.")

# Si ahora detienes el script y lo vuelves a correr con el mismo thread_id,
# el agente recordará el código secreto.

Diferencias clave en el código

Observa que para Short-term memory, la diferencia principal en el código es simplemente qué objeto checkpointer pasamos al compilar el grafo o crear el agente. La lógica de interacción (invoke) no cambia, lo que facilita pasar de desarrollo (InMemorySaver) a producción (PostgresSaver) cambiando solo la inyección de dependencias.