La cantidad máxima de tokens que un LLM puede procesar en una sola interacción, determinando cuánta información puede considerar simultáneamente para generar respuestas.
La ventana de contexto es el límite máximo de tokens (palabras y subpalabras) que un LLM puede procesar en una sola interacción. Incluye tanto la entrada (prompt, contexto, historial de conversación) como la salida generada por el modelo. Es esencialmente la «memoria de trabajo» del modelo durante una sesión.
Un token no equivale exactamente a una palabra. En inglés, 1,000 tokens representan aproximadamente 750 palabras, mientras que en español son cerca de 600 palabras debido a las diferencias morfológicas del idioma. Esta ventana determina cuánto contexto puede mantener el modelo para generar respuestas coherentes y contextualmente relevantes.
La ventana de contexto es una restricción física del modelo, determinada por su arquitectura y entrenamiento. No puede expandirse dinámicamente — es un límite fijo que define las capacidades fundamentales del sistema.
| Año | Modelo | Ventana | Equivalente aproximado |
|---|---|---|---|
| 2022 | GPT-3.5 | 4K tokens | ~8 páginas |
| 2023 | GPT-4 | 8K–32K tokens | ~16-64 páginas |
| 2023 | Claude 2 | 100K tokens | ~200 páginas |
| 2024 | Claude 3 | 200K tokens | ~400 páginas |
| 2024 | Gemini 1.5 | 1M–2M tokens | ~2,000-4,000 páginas |
Esta evolución refleja avances en arquitecturas de atención eficiente, técnicas de entrenamiento y capacidad computacional. Los modelos más recientes pueden procesar documentos completos, bases de código extensas o conversaciones muy largas en una sola interacción.
Las pruebas de «aguja en el pajar» evalúan qué tan bien los modelos pueden recuperar información específica dentro de contextos largos. Los resultados muestran patrones consistentes:
# Ejemplo de test needle-in-haystack
def needle_in_haystack_test(model, context_length, needle_position):
# Generar contexto de distracción
haystack = generate_distractor_text(context_length - 100)
# Insertar "aguja" (información específica) en posición determinada
needle = "La clave secreta es: ALPHA-7829"
if needle_position == "start":
context = needle + "\n\n" + haystack
elif needle_position == "middle":
mid = len(haystack) // 2
context = haystack[:mid] + "\n\n" + needle + "\n\n" + haystack[mid:]
else: # end
context = haystack + "\n\n" + needle
# Preguntar por la información específica
prompt = context + "\n\n¿Cuál es la clave secreta mencionada en el texto?"
response = model.generate(prompt)
return "ALPHA-7829" in responseLa división de documentos largos requiere preservar coherencia semántica:
from langchain.text_splitter import RecursiveCharacterTextSplitter
def smart_chunking(document, max_chunk_size=1000, overlap=200):
splitter = RecursiveCharacterTextSplitter(
chunk_size=max_chunk_size,
chunk_overlap=overlap,
separators=["\n\n", "\n", ". ", " ", ""]
)
chunks = splitter.split_text(document)
# Añadir contexto de documento a cada chunk
enriched_chunks = []
for i, chunk in enumerate(chunks):
context_header = f"Documento: {document.title}\nSección {i+1}/{len(chunks)}\n\n"
enriched_chunks.append(context_header + chunk)
return enriched_chunksPara conversaciones largas o análisis de documentos extensos:
def progressive_summarization(messages, max_context_tokens=8000):
current_tokens = count_tokens(messages)
if current_tokens <= max_context_tokens:
return messages
# Resumir mensajes más antiguos, preservar los recientes
recent_messages = messages[-10:] # Últimos 10 mensajes
old_messages = messages[:-10]
summary_prompt = f"""
Resume esta conversación manteniendo:
- Decisiones técnicas importantes
- Contexto del problema
- Conclusiones alcanzadas
Conversación:
{format_messages(old_messages)}
"""
summary = llm.generate(summary_prompt)
return [{"role": "system", "content": f"Resumen de conversación previa: {summary}"}] + recent_messagesEn sistemas RAG, ordenar información por relevancia:
def prioritize_context(query, retrieved_docs, max_tokens=6000):
# Calcular relevancia semántica
relevance_scores = []
for doc in retrieved_docs:
score = calculate_semantic_similarity(query, doc.content)
relevance_scores.append((doc, score))
# Ordenar por relevancia
sorted_docs = sorted(relevance_scores, key=lambda x: x[1], reverse=True)
# Seleccionar documentos que caben en la ventana
selected_docs = []
current_tokens = 0
for doc, score in sorted_docs:
doc_tokens = count_tokens(doc.content)
if current_tokens + doc_tokens <= max_tokens:
selected_docs.append(doc)
current_tokens += doc_tokens
else:
break
return selected_docsLa atención en arquitecturas Transformer escala cuadráticamente con la longitud de secuencia (O(n²)). Esto significa que duplicar la ventana de contexto cuadruplica el cómputo requerido. Los proveedores reflejan esto en sus modelos de precios:
Técnicas como atención sparse, sliding window attention y ring attention mitigan parcialmente estos costos, pero el trade-off fundamental persiste.
La ventana de contexto es la restricción arquitectónica más importante en sistemas basados en LLMs. Define qué patrones de uso son viables: desde RAG que debe seleccionar cuidadosamente qué documentos incluir, hasta agentes que necesitan mantener estado a través de múltiples iteraciones.
Para ingenieros staff+, entender estas limitaciones es crucial para diseñar sistemas escalables. No se trata solo de «hacer que funcione», sino de optimizar para costo, latencia y precisión simultáneamente. Las decisiones sobre chunking, caching de contexto y estrategias de resumen impactan directamente la experiencia del usuario y los costos operacionales.
La gestión eficiente de contexto distingue implementaciones amateur de sistemas de producción robustos. Es la diferencia entre un prototipo que funciona con documentos pequeños y una plataforma que escala a bases de conocimiento empresariales.
Redes neuronales masivas basadas en la arquitectura Transformer, entrenadas con enormes corpus de texto para comprender y generar lenguaje natural con capacidades emergentes como razonamiento, traducción y generación de código.
Disciplina de diseñar instrucciones efectivas para modelos de lenguaje, combinando claridad, estructura y ejemplos para obtener respuestas consistentes y de alta calidad.
Patrón arquitectónico que combina la recuperación de información de fuentes externas con la generación de texto por LLMs, reduciendo alucinaciones y manteniendo el conocimiento actualizado sin reentrenar el modelo.
Técnica que almacena el cómputo interno de prefijos de prompt reutilizados entre llamadas a LLMs, reduciendo costos hasta un 90% y latencia hasta un 85% en aplicaciones con contexto repetitivo.