Contexto y memoria

Sin estado: lo que realmente se envía

En una API de chat, la llamada de cada turno lleva la lista completa de mensajes; el modelo devuelve solo el mensaje nuevo, y la aplicación lo agrega a su lista antes del turno siguiente:

{
  "system": "Eres un asistente de logística. ...",
  "messages": [
    {"role": "user", "content": "Me llamo Ana y trabajo en logística."},
    {"role": "assistant", "content": "Mucho gusto, Ana. ¿En qué te ayudo?"},
    {"role": "user", "content": "¿Cómo me llamo?"}
  ]
}

La documentación de Anthropic lo dice así: «la API de mensajes es sin estado: siempre se envía a la API el historial completo de la conversación» (en el original, stateless). Las instrucciones del sistema van en un campo aparte, system. Algunas plataformas guardan el historial en sus servidores y lo reinsertan por ti: el modelo sigue sin estado; solo cambia quién guarda el historial.

Qué cuenta en la ventana

Según esa misma documentación, la ventana es «todo el texto al que el modelo puede referirse al generar una respuesta, incluida la propia respuesta»: las instrucciones del sistema, cada mensaje (con documentos e imágenes), las definiciones de herramientas y lo que el modelo escribe en el turno. Si la entrada sola ya excede la ventana, la API devuelve un error («prompt is too long»); qué hacer entonces lo decide la aplicación. La documentación señala que interfaces de chat como claude.ai pueden manejar la ventana como una cola, «lo primero que entra es lo primero que sale», o resumir lo viejo («compactación»).

¿Por qué hay un límite? GPT-1 usó «posiciones aprendidas» en lugar de las ondas del artículo original (lección 22), y GPT-3 conserva esa arquitectura con $n_{\text{ctx}}=2048$ (Brown et al., 2020): aprendió una lista por lugar y no tiene listas para más. Los modelos actuales codifican la posición de otra forma, pero el largo útil sigue dependiendo de con qué largos se entrenaron, y servir contextos largos cuesta memoria: la caché KV crece con cada token (lección 26). En Llama 3 de 8 mil millones (32 bloques, 8 cabezas de clave-valor de 128 números, 2 bytes por número) son $2\cdot 32\cdot 8\cdot 128\cdot 2 = 131\,072$ bytes por token: con 128 000 tokens, casi 17 GB.

Modelo	Año	Ventana (tokens)	Fuente
GPT-1	2018	512	Radford et al.
GPT-2	2019	1 024	Radford et al.
GPT-3	2020	2 048	Brown et al.
Claude	2023	100 000 (≈ 75 000 palabras)	Anthropic
Llama 3.1	2024	128 000	Llama Team
Gemini 1.5	2024	más de 1 millón (hasta 10 millones en sus pruebas)	Gemini Team

Pesos fijos, ejemplos en el contexto

El modelo puede seguir un patrón que le muestras en el contexto (aprendizaje en contexto): Brown et al. (2020) lo evalúan «sin actualizaciones de gradiente ni ajuste fino». Es temporal: cuando esos ejemplos salen de la ventana, el comportamiento desaparece. Cambiar los pesos exige entrenar (lecciones 4, 8 y 27). El informe técnico de GPT-4 lo resume: tiene «una ventana de contexto limitada y no aprende de la experiencia».

Cuánto cuesta reenviar la conversación

Sea $s$ el tamaño de las instrucciones del sistema y $m$ los tokens que agrega cada turno (tu mensaje $u$ más la respuesta $a$). En el turno $k$ el modelo procesa $s + k\,m$ tokens (lee todo lo anterior y escribe lo nuevo); en $n$ turnos,

Con $s=0$ y $m=100$: 5 500 tokens en 10 turnos y 21 000 en 20, frente a 1 000 y 2 000 de texto. El término $m\,n^2/2$ domina: el total crece con el cuadrado de los turnos. Las instrucciones también se pagan en cada turno: con $s = 2\,000$, $u = 50$, $a = 150$ y 20 turnos, la entrada suma $\sum_k \big(s + (k-1)m + u\big) = 79\,000$ tokens, y la mitad son las instrucciones repetidas.

Por eso existe la caché del prefijo: el proveedor guarda el trabajo hecho sobre el inicio repetido (la caché KV de la lección 26) y cobra menos por releerlo. En la documentación de Anthropic, leer de la caché cuesta $0.1\times$ el precio base de entrada (menos en algunos modelos) y escribir en ella, $1.25\times$ (caché de 5 minutos). Si acierta en cada turno, el ejemplo anterior baja a unos 14 628 tokens equivalentes, el 19 %. La caché cambia lo que pagas, no lo que ocupa la ventana.

La posición importa: «Perdido en el medio»

Liu et al. (2023) dieron a cada modelo 20 documentos (unos 4 000 tokens), uno solo con la respuesta, y cambiaron su lugar. Acierto (%), valores de la tabla 6 (apéndice G); las dos últimas columnas son de la tabla 1:

Modelo	1.º	5.º	10.º	15.º	20.º	Sin documentos	Solo el correcto
GPT-3.5-Turbo	75.8	57.2	53.8	55.4	63.2	56.1	88.3
Claude-1.3	59.9	55.9	56.8	57.2	60.1	48.3	76.1
LongChat-13B (16K)	68.6	57.4	55.3	52.5	55.0	35.0	83.4
MPT-30B-Instruct	53.7	51.8	52.2	52.7	56.3	31.5	81.9

Son modelos de 2023 y una sola tarea: la forma exacta cambia con el modelo y con la prueba, y los autores no encuentran que una ventana mayor, por sí sola, use mejor el contexto. RULER (Hsieh et al., 2024) amplía el hallazgo: entre los modelos que declaraban 32 000 tokens o más, solo la mitad mantenía un rendimiento satisfactorio a esa longitud. La documentación de Anthropic lo llama context rot: al crecer el número de tokens, la exactitud y el recuerdo se degradan.

Memoria fuera del modelo

Las funciones de «memoria» guardan texto fuera de la ventana y lo vuelven a meter: un resumen que reemplaza los turnos viejos (la compactación de Anthropic), o archivos de notas que el modelo lee y escribe entre conversaciones (la herramienta de memoria de Anthropic; MemGPT, de Packer et al., 2023, se inspira en la jerarquía de memoria de un sistema operativo). Lo guardado puede quedar equivocado u obsoleto, y es información que sale de tu organización.

En código

def recortar(mensajes, limite, contar):
    """Deja las instrucciones y los turnos más recientes que quepan: lo primero que entró sale primero."""
    sistema, resto = mensajes[0], mensajes[1:]
    usado, dentro = contar(sistema), []
    for m in reversed(resto):                       # de lo más nuevo a lo más viejo
        if usado + contar(m) > limite:
            break
        dentro.append(m)
        usado += contar(m)
    return [sistema] + dentro[::-1]

def procesados(turnos, s, m):
    """Tokens que procesa el modelo: en el turno k, las instrucciones s más k turnos de m tokens."""
    return sum(s + k * m for k in range(1, turnos + 1))

def entrada_con_cache(turnos, s, u, a, lectura=0.1, escritura=1.25):
    """Tokens de entrada equivalentes con caché del prefijo (supuesto: acierta en cada turno)."""
    m = u + a
    total = escritura * (s + u)                     # turno 1: se escribe todo
    for k in range(2, turnos + 1):
        prefijo = s + (k - 2) * m + u               # lo que se envió en el turno anterior
        total += lectura * prefijo + escritura * m  # se lee el prefijo y se escribe lo nuevo
    return total

contar = lambda m: len(m["texto"].split())         # aproximación: una palabra ≈ un token
historial = [
    {"rol": "sistema",   "texto": "Eres un asistente de logística."},
    {"rol": "usuario",   "texto": "Me llamo Ana y trabajo en logística."},
    {"rol": "asistente", "texto": "Mucho gusto, Ana. ¿En qué te ayudo?"},
    {"rol": "usuario",   "texto": "Dame una idea para ahorrar en envíos."},
    {"rol": "asistente", "texto": "Junta pedidos pequeños en un solo camión."},
    {"rol": "usuario",   "texto": "¿Cómo me llamo?"},
]
dentro = recortar(historial, limite=25, contar=contar)
print([m["rol"] for m in dentro])
print("¿Sigue el nombre en la ventana?", any("Ana" in m["texto"] for m in dentro))
print(procesados(10, s=0, m=100), procesados(20, s=0, m=100))
sin = sum(2000 + (k - 1) * 200 + 50 for k in range(1, 21))
con = entrada_con_cache(20, s=2000, u=50, a=150)
print(sin, round(con), f"{con / sin:.0%}")
# ['sistema', 'usuario', 'asistente', 'usuario']
# ¿Sigue el nombre en la ventana? False
# 5500 21000
# 79000 14628 19%

Lo que viene

En la lección 31 (RAG) el almacén externo se vuelve un sistema completo: buscar los fragmentos relevantes de tus documentos y ponerlos en la ventana. En la 32, los agentes usan esa misma idea, con memoria en archivos, para trabajos que duran más que una ventana.