Ventana de contexto: por qué llenarla no te hace más listo

Más contexto no es más señal

Sale un modelo con 1 millón de tokens de ventana y la reacción por defecto es la misma: “genial, le meto el manual entero y que se apañe”. Es la tentación de tratar la ventana de contexto como un cajón de sastre. Cabe todo, así que metemos todo.

El problema es que la ventana mide capacidad, no atención. Que quepan 200.000 tokens no significa que el modelo los lea con el mismo cuidado. De hecho, casi nunca lo hace. Y cuando falla, no lo hace a lo bruto: te devuelve una respuesta con aplomo que ignora justo el dato que le pusiste en medio.

Lo que de verdad ocurre dentro de la ventana

Hay un patrón bien documentado: los modelos prestan más atención al principio y al final del contexto que al centro. Le das veinte documentos, la respuesta correcta está en el número diez, y el rendimiento cae en picado frente a tenerla en el primero o el último. El paper que lo popularizó lo bautizó como lost in the middle, y el nombre se quedó porque describe exactamente lo que ves en producción.

La intuición es sencilla si piensas en cómo se entrena el modelo. El principio del prompt es donde suelen ir las instrucciones; el final es lo más reciente, lo que “acaba de leer”. El centro es tierra de nadie. Por eso un dato crítico enterrado en el párrafo 40 de 80 tiene todas las papeletas de pasar desapercibido.

Añade a esto que más tokens es más coste y más latencia. Cada token del prompt se paga y se procesa. Un contexto hinchado no solo distrae al modelo: te sale caro y lento para, encima, funcionar peor.

El experimento que deberías hacer una vez

Antes de fiarte de tu intuición, mídelo con tu modelo y tu caso. La prueba clásica es la needle in a haystack: escondes una frase concreta (la aguja) en un texto largo de relleno (el pajar) y preguntas por ella variando la posición.

import openai

client = openai.OpenAI()

def prueba_aguja(posicion_relativa: float, tokens_relleno: int = 8000) -> bool:
    """Esconde un dato en un texto largo y comprueba si el modelo lo recupera.

    posicion_relativa: 0.0 = al principio, 0.5 = en el centro, 1.0 = al final.
    """
    aguja = "El código de acceso al laboratorio es 7Z-Delta-19."
    relleno = "El sistema opera con normalidad. " * (tokens_relleno // 6)

    # Insertamos la aguja en la posición pedida dentro del relleno
    corte = int(len(relleno) * posicion_relativa)
    contexto = relleno[:corte] + aguja + relleno[corte:]

    respuesta = client.chat.completions.create(
        model="gpt-5-6",
        messages=[
            {"role": "system", "content": "Responde solo con el dato exacto que se pide."},
            {"role": "user", "content": f"{contexto}\n\n¿Cuál es el código de acceso al laboratorio?"},
        ],
        temperature=0,
    )
    return "7Z-Delta-19" in respuesta.choices[0].message.content


# Barrido de posiciones: el centro es donde más falla
for pos in (0.0, 0.25, 0.5, 0.75, 1.0):
    aciertos = sum(prueba_aguja(pos) for _ in range(5))
    print(f"posición {pos:>4}: {aciertos}/5 aciertos")

No hace falta que sea sofisticado. Con este esqueleto ya ves la forma de la curva: casi siempre una U, con el valle en el centro. Repítelo con el volumen de contexto que usas en real y sabrás cuánto margen tienes antes de que el modelo empiece a perderse.

Curar el contexto, no llenarlo

La conclusión operativa es incómoda para quien busca atajos: el trabajo no es meter más, es meter menos y mejor. A esto se le llama context engineering, y es donde se gana o se pierde la calidad de un sistema con LLM.

Algunas reglas que aguantan bien en producción:

• Recupera poco y bueno. En un RAG, cinco fragmentos relevantes baten a veinte fragmentos “por si acaso”. El ruido no es neutro; compite por la atención del modelo.
• Coloca lo importante en los extremos. Si sabes cuál es el dato clave, ponlo al principio o al final, no sepultado en medio. Instrucciones arriba, pregunta abajo.
• Reordena tras el reranking. Si ya tienes un reranker que ordena por relevancia, aprovéchalo para poner lo mejor en las posiciones que el modelo sí mira.
• Resume antes de acumular. En agentes con memoria larga, comprime el historial en lugar de arrastrarlo entero turno tras turno. Un resumen de 300 tokens rinde más que 6.000 de conversación cruda.

Ventana grande y RAG no son rivales

Cuando sale una ventana enorme, siempre aparece el mismo titular: “esto mata al RAG”. No. Cambia la pregunta de “¿cabe?” a “¿conviene?”.

La ventana grande es una herramienta excelente para lo que antes era imposible: razonar sobre un documento entero, un repositorio, una transcripción larga. Pero para responder preguntas puntuales sobre una base de conocimiento que cambia, curar el contexto sigue ganando en coste, velocidad y trazabilidad.

Qué hacer el lunes

Mide antes de opinar: monta la prueba de la aguja con tu modelo y tu volumen real de contexto, y mira dónde está el valle. Con ese dato, audita tus prompts más largos y pregúntate por cada bloque si de verdad aporta o solo abulta. Casi siempre hay un 30 % de relleno que puedes tirar sin perder nada, y a veces ganas precisión al hacerlo.

La ventana de contexto es espacio, no comprensión. Trátala como un presupuesto que gastar con criterio, no como un vertedero donde cabe todo. El modelo no premia al que más le da; premia al que le da lo justo, donde toca.

Fuentes

• Liu et al., “Lost in the Middle: How Language Models Use Long Contexts” (2023).