¿Qué es el context window de una IA?

Es la cantidad máxima de texto (en tokens) que un modelo puede procesar en una sola conversación. Incluye el historial de mensajes, el código que compartes, los archivos adjuntos y la respuesta del modelo. Cuando se llena, el modelo empieza a 'olvidar' el inicio de la conversación.

¿Cuánto contexto tienen Claude, GPT-4 y Gemini?

En 2026: Claude Sonnet tiene 200K tokens (~150.000 palabras), GPT-4.1 tiene 128K tokens, Gemini 1.5 Pro tiene 1M tokens. Pero más contexto no siempre es mejor — los modelos pierden atención en el 'lost in the middle', ignorando información a mitad del contexto.

¿Cómo sé si mi contexto está lleno?

Los síntomas son: el modelo 'olvida' instrucciones del inicio de la sesión, da respuestas inconsistentes con lo que dijo antes, o directamente da error de 'context length exceeded'. En Cursor puedes ver el uso de tokens en la barra inferior.

¿Qué es el 'lost in the middle' problem?

Los modelos de IA prestan más atención al inicio y al final del contexto que al medio. Si metes 100KB de código en el medio del chat y luego haces una pregunta, el modelo puede ignorar partes del código. La solución es poner la información más relevante cerca de la pregunta.

¿Los MCP servers consumen context window?

Sí. Cada llamada a un MCP server añade el resultado al contexto. Si haces muchas consultas a base de datos o lees archivos grandes, el contexto se llena rápido. Filtra los resultados al mínimo necesario antes de pasarlos al modelo.

Context Window de la IA: Cómo Aprovecharlo al Máximo en Proyectos Grandes

Llevas una hora trabajando con el agente en un módulo complejo. Las primeras respuestas eran perfectas — entendía la arquitectura, el estilo de código, las convenciones del proyecto. Ahora está generando código inconsistente, olvidando cosas que le dijiste al principio, repitiendo preguntas que ya respondiste.

El context window se llenó. Y tú no lo viste venir.

El context window es el recurso más crítico y menos gestionado del trabajo con IA. Esta guía te explica cómo funciona y cómo aprovecharlo en proyectos reales.

Qué es el context window y por qué importa

El context window es la “memoria de trabajo” del modelo — todo lo que puede ver a la vez. Incluye:

El historial de mensajes de la conversación
El código que has pegado o adjuntado
Los archivos que el agente ha leído
Las respuestas que el modelo ha generado
Los resultados de herramientas (MCP, ejecución de código, etc.)

Cuando el contexto se llena, el modelo debe decidir qué olvidar. Generalmente olvida el inicio de la conversación — justo donde estaban tus instrucciones de arquitectura, el contexto inicial del proyecto y las convenciones que estableciste.

Tamaños de contexto en 2026

Modelo	Context window	En palabras aprox.
Claude Sonnet 4.5	200K tokens	~150.000 palabras
Claude Opus 4	200K tokens	~150.000 palabras
GPT-4.1	128K tokens	~96.000 palabras
GPT-4o	128K tokens	~96.000 palabras
Gemini 1.5 Pro	1M tokens	~750.000 palabras
Gemini 2.0 Flash	1M tokens	~750.000 palabras
Llama 3.3 70B	128K tokens	~96.000 palabras

200K tokens suena a mucho. Pero un proyecto mediano de TypeScript con 50 archivos de 200 líneas ya son ~500K tokens. Un proyecto real con 200+ archivos supera fácilmente el millón.

El problema del “Lost in the Middle”

Más contexto no siempre es mejor. Los modelos tienen un problema conocido: prestan más atención al inicio y al final del contexto que al medio.

Inicio del contexto → Alta atención ✅
...
Medio del contexto → Baja atención ⚠️
...
Final del contexto → Alta atención ✅

Esto significa que si metes 50 archivos de código en el medio de una conversación larga y luego haces una pregunta al final, el modelo puede ignorar archivos completos.

Ejemplo real:

Mensaje 1: "El proyecto usa NestJS con multi-tenancy. Cada query debe filtrar por tenantId."
[200 mensajes después, con código de 20 archivos en el medio]
Mensaje 201: "Añade un endpoint para listar campañas"

Resultado: el modelo genera el endpoint SIN filtrar por tenantId porque olvidó la instrucción del mensaje 1.

Estrategias para gestionar el context window

1. El archivo de contexto persistente

En vez de explicar el proyecto al inicio de cada sesión, mantén un archivo CONTEXT.md en el proyecto:

# CONTEXT.md — Atrapaclientes

## Arquitectura
- NestJS 11 + TypeORM
- Multi-tenancy a nivel de fila (TenantContextGuard inyecta tenantId en todas las queries)
- RBAC con 31 permisos — usar @RequirePermissions() en todos los endpoints protegidos
- PostgreSQL 17, 29 entidades

## Convenciones
- DTOs en kebab-case: create-campaign.dto.ts
- Todos los endpoints GET paginados: ?page=1&limit=10
- Respuestas de error: { error: string, statusCode: number }
- Nunca exponer IDs numéricos, siempre UUIDs

## Lo que NUNCA debe hacer la IA
- Hardcodear tenantId
- Omitir validación con class-validator en DTOs
- Usar any en TypeScript
- Crear endpoints sin guardia de auth

Al inicio de cada sesión: @CONTEXT.md Implementa [tarea]. El contexto relevante siempre está al inicio, donde el modelo tiene más atención.

2. Conversaciones cortas y específicas

En vez de una conversación larga de 50 mensajes para implementar un módulo completo, divide en conversaciones cortas:

Conversación 1: "Crea la entidad Campaign con sus relaciones"
Conversación 2: "Crea el CampaignService con los métodos CRUD"
Conversación 3: "Crea el CampaignController con los endpoints REST"
Conversación 4: "Añade tests para el CampaignService"

Cada conversación empieza limpia con contexto fresco. El agente no arrastra el ruido de las decisiones anteriores.

3. Selección de archivos, no proyectos enteros

Cuando uses @codebase o @workspace en Cursor/Copilot, el agente intenta leer todos los archivos relevantes. Esto consume contexto rápidamente.

Mejor práctica: especifica los archivos exactos que necesita:

❌ "@codebase ¿cómo funciona el módulo de auth?"
✅ "@src/modules/auth/auth.service.ts @src/modules/auth/auth.guard.ts ¿cómo funciona el módulo de auth?"

Ahorras tokens y el modelo tiene mejor señal.

4. Prompt caching para contexto repetido

Si pagas por API directa, el prompt caching de Claude te permite marcar partes del prompt como cacheables. Si el contexto base del proyecto siempre es el mismo, el caching lo mantiene sin consumir tokens en cada llamada.

# Con Anthropic SDK, el contexto del sistema se cachea automáticamente
# si tienes prompt caching habilitado en tu plan
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": system_context,
                "cache_control": {"type": "ephemeral"}  # Cacheable
            },
            {
                "type": "text",
                "text": "Implementa el endpoint de login con JWT"
            }
        ]
    }
]

5. Resúmenes como checkpoint

En sesiones largas, cuando notes que el contexto empieza a llenarse, pide un resumen antes de continuar:

"Antes de continuar, resume en bullet points:
1. Qué hemos implementado en esta sesión
2. Las decisiones de arquitectura que tomamos
3. Lo que queda pendiente"

Guarda ese resumen. En la siguiente sesión, empieza con él en vez de con todo el historial anterior.

Context window en diferentes editores

Cursor

Cursor muestra el uso de tokens en la barra inferior del chat. Cuando se acerca al límite:

La conversación se marca con un aviso
Puedes usar “New conversation” para empezar limpio manteniendo los archivos abiertos

Tip: Las .cursorrules o las instrucciones de Settings → Rules for AI siempre se inyectan al inicio del contexto. Ponlas cortas y precisas — son tokens que consumes en cada mensaje.

GitHub Copilot

Copilot gestiona el contexto automáticamente, priorizando el archivo activo y los archivos relacionados. Puedes controlar qué entra al contexto con:

#file:ruta/archivo.ts — incluir un archivo específico
#selection — solo el código seleccionado
@workspace — todo el proyecto (costoso en tokens)

Cline / Claude Dev

Muestra el uso de tokens en tiempo real. Cuando se acerca al límite, crea automáticamente un resumen de la sesión y empieza un nuevo contexto. Puedes configurar el umbral en la configuración.

Cómo estructurar proyectos grandes para la IA

La arquitectura de tu proyecto afecta directamente qué tan bien trabaja la IA contigo. Algunos patrones que funcionan bien:

Módulos pequeños y cohesivos

Un módulo de 5 archivos de 100 líneas es mejor que un archivo de 500 líneas. El agente puede leer el módulo completo sin saturar el contexto.

✅ Buena estructura para IA:
/modules/auth/
  auth.module.ts      (30 líneas)
  auth.service.ts     (150 líneas)
  auth.controller.ts  (80 líneas)
  auth.guard.ts       (60 líneas)
  dto/
    login.dto.ts      (20 líneas)
    register.dto.ts   (25 líneas)

❌ Mala estructura para IA:
/auth.ts              (500 líneas con todo mezclado)

Nombres descriptivos

Los nombres de archivos y funciones son parte del contexto implícito. getUsersByTenantWithActiveSubscription le da más información al modelo que getUsers2.

Comentarios de arquitectura, no de implementación

// ✅ Útil para la IA (arquitectura)
// TenantContextGuard se ejecuta antes que este guard.
// req.user.tenantId está garantizado en este punto.

// ❌ Inútil para la IA (obvio)
// Obtiene el usuario por ID
async getUserById(id: string) {

El patrón de “contexto mínimo viable”

Cuando trabajo en una tarea específica, construyo el contexto mínimo que la IA necesita:

1. Instrucciones de arquitectura (del CONTEXT.md)
2. El archivo que estoy modificando
3. Los archivos que el archivo importa
4. El tipo/interfaz de los datos que maneja
5. La descripción de la tarea

Nada más.

No meto 20 archivos “por si acaso”. Más contexto no relevante = más ruido = peor respuesta.

Si el agente necesita más contexto, me lo pedirá. O puedo usar MCP servers para que consulte lo que necesita sin que yo tenga que pegarlo manualmente.

Síntomas de que el contexto está degradado

Reconocer cuándo el contexto está fallando te ahorra mucho tiempo:

Síntoma	Causa probable
El agente “olvida” convenciones del proyecto	Instrucciones iniciales desplazadas por el historial
Código inconsistente con lo que hizo antes	Lost in the middle — no ve el código anterior
Respuestas genéricas sin contexto del proyecto	Contexto demasiado lleno, modelo generalizando
El agente pregunta cosas que ya respondiste	Historial de conversación demasiado largo
Cambios que contradicen decisiones previas	Decisiones en el medio del contexto ignoradas

Cuando veas estos síntomas: nueva conversación con contexto fresco.

Gestión del contexto con agentes autónomos

Los agentes autónomos tienen un reto adicional: necesitan mantener contexto entre múltiples pasos de ejecución. Las estrategias para esto:

Memoria externa

Guardar el estado del agente en un archivo o base de datos, no en el contexto del chat:

// El agente guarda su "memoria" en un archivo
const memory = {
  task: "implementar módulo de auth",
  completedSteps: ["entity", "service"],
  pendingSteps: ["controller", "tests"],
  decisions: {
    "hash algorithm": "argon2",
    "token expiry": "7 days"
  }
};
fs.writeFileSync("agent-memory.json", JSON.stringify(memory));

Resúmenes progresivos

Cada N pasos, el agente hace un resumen de lo completado y lo sustituye por el historial detallado. Comprime el contexto sin perder información relevante.

Contexto por tarea, no por proyecto

En vez de tener un contexto global del proyecto, el agente carga solo el contexto relevante para la tarea actual. Similar al patrón RAG que cuento en crear un chatbot con RAG.

Calculando el coste del contexto

Si pagas por API (no por suscripción de editor), el tamaño del contexto afecta directamente al coste. La calculadora de precios de IA te ayuda a estimar, pero aquí están los precios orientativos para 2026:

Modelo	Input (por 1M tokens)	Output (por 1M tokens)
Claude Sonnet 4.5	$3	$15
Claude Opus 4	$15	$75
GPT-4.1	$2	$8
Gemini 1.5 Pro	$1.25	$5

Una sesión de trabajo de 2 horas con contexto largo (50K tokens de input promedio por mensaje) puede costar entre $1 y $10 dependiendo del modelo. Con prompt caching activo, el coste se reduce un 90% en el contexto repetido.

Conclusión

El context window no es solo una limitación técnica — es una restricción que moldea cómo deberías estructurar tu trabajo con IA.

Las prácticas clave:

CONTEXT.md con la arquitectura del proyecto, siempre al inicio
Conversaciones cortas por tarea, no maratones de 3 horas
Archivos específicos, no @codebase a ciegas
Nueva conversación cuando los síntomas de degradación aparecen
Módulos pequeños — benefician tanto a humanos como a IAs

Un buen manejo del contexto es lo que separa el vibe coding que funciona del que destroza proyectos. No es sobre cuánto contexto metes — es sobre qué contexto es relevante.