Ventanas de contexto

Límites de contexto y estrategias de gestión

Cuando trabajamos con modelos de lenguaje, nos enfrentamos a una limitación fundamental: la ventana de contexto. Esta ventana determina cuánta información puede procesar el modelo en una sola petición, incluyendo tanto el prompt que enviamos como la respuesta que genera.

Los límites de contexto varían significativamente entre modelos. Por ejemplo, gpt-4.1 maneja hasta 1 millón de tokens, mientras que o3 está limitado a 200,000 tokens. Estos números pueden parecer enormes, pero en conversaciones largas o al procesar documentos extensos, alcanzar estos límites es más común de lo que podríamos pensar.

Comprensión de tokens y conteo

Antes de implementar estrategias de gestión, necesitamos entender cómo contar tokens de manera precisa. OpenAI proporciona herramientas específicas para esta tarea:

import tiktoken
from openai import OpenAI

client = OpenAI()

def contar_tokens(texto, modelo="gpt-4.1"):
    """Cuenta los tokens de un texto para un modelo específico"""
    encoding = tiktoken.encoding_for_model(modelo)
    return len(encoding.encode(texto))

# Ejemplo de uso
conversacion = [
    {"role": "user", "content": "¿Cuál es la capital de Francia?"},
    {"role": "assistant", "content": "La capital de Francia es París."},
    {"role": "user", "content": "¿Y cuál es su población aproximada?"}
]

total_tokens = 0
for mensaje in conversacion:
    tokens = contar_tokens(mensaje["content"])
    total_tokens += tokens
    print(f"Mensaje: {tokens} tokens")

print(f"Total de la conversación: {total_tokens} tokens")

Esta función nos permite monitorizar el uso de tokens en tiempo real y tomar decisiones informadas sobre cuándo aplicar estrategias de gestión.

Estrategias de truncamiento

Cuando una conversación se acerca al límite de contexto, podemos aplicar diferentes estrategias de truncamiento. La más directa es eliminar mensajes antiguos:

def truncar_conversacion(mensajes, limite_tokens=800000, modelo="gpt-4.1"):
    """Trunca una conversación manteniendo los mensajes más recientes"""
    mensajes_truncados = []
    tokens_actuales = 0
    
    # Procesamos desde el final hacia el principio
    for mensaje in reversed(mensajes):
        tokens_mensaje = contar_tokens(mensaje["content"], modelo)
        
        if tokens_actuales + tokens_mensaje <= limite_tokens:
            mensajes_truncados.insert(0, mensaje)
            tokens_actuales += tokens_mensaje
        else:
            break
    
    return mensajes_truncados, tokens_actuales

# Ejemplo de uso
conversacion_larga = [
    {"role": "system", "content": "Eres un asistente útil."},
    {"role": "user", "content": "Explícame la historia de Roma."},
    {"role": "assistant", "content": "Roma fue fundada según la leyenda..."},
    # ... muchos más mensajes
]

conversacion_optimizada, tokens_usados = truncar_conversacion(conversacion_larga)
print(f"Conversación reducida a {len(conversacion_optimizada)} mensajes ({tokens_usados} tokens)")

Estrategias de resumen

Una alternativa más sofisticada al truncamiento es el resumen de contexto. Esta técnica condensa la información histórica manteniendo los detalles relevantes:

def resumir_contexto_antiguo(mensajes, umbral_mensajes=10):
    """Resume mensajes antiguos para reducir el uso de tokens"""
    if len(mensajes) <= umbral_mensajes:
        return mensajes
    
    # Separamos mensajes recientes de antiguos
    mensajes_antiguos = mensajes[1:-umbral_mensajes]  # Excluimos system y recientes
    mensajes_recientes = mensajes[-umbral_mensajes:]
    mensaje_sistema = mensajes[0] if mensajes[0]["role"] == "system" else None
    
    # Creamos un resumen de los mensajes antiguos
    contexto_para_resumir = "\n".join([
        f"{msg['role']}: {msg['content']}" for msg in mensajes_antiguos
    ])
    
    response = client.responses.create(
        model="gpt-4.1-mini",  # Usamos un modelo más económico para resumir
        input=f"""Resume la siguiente conversación manteniendo los puntos clave y decisiones importantes:

{contexto_para_resumir}

Resumen:"""
    )
    
    # Construimos la nueva conversación
    conversacion_resumida = []
    if mensaje_sistema:
        conversacion_resumida.append(mensaje_sistema)
    
    conversacion_resumida.append({
        "role": "system", 
        "content": f"Contexto previo resumido: {response.output_text}"
    })
    
    conversacion_resumida.extend(mensajes_recientes)
    
    return conversacion_resumida

Gestión dinámica de ventana

Para aplicaciones en producción, necesitamos una gestión dinámica que combine múltiples estrategias según la situación:

class GestorVentanaContexto:
    def __init__(self, modelo="gpt-4.1", limite_seguridad=0.8):
        self.modelo = modelo
        self.limite_maximo = self._obtener_limite_modelo(modelo)
        self.limite_seguridad = int(self.limite_maximo * limite_seguridad)
    
    def _obtener_limite_modelo(self, modelo):
        """Retorna el límite de tokens para cada modelo"""
        limites = {
            "gpt-4.1": 1000000,
            "gpt-4.1-mini": 128000,
            "o3": 200000,
            "o4-mini": 128000
        }
        return limites.get(modelo, 128000)
    
    def gestionar_conversacion(self, mensajes):
        """Aplica la estrategia más apropiada según el uso actual"""
        tokens_actuales = sum(contar_tokens(msg["content"], self.modelo) 
                            for msg in mensajes)
        
        if tokens_actuales <= self.limite_seguridad:
            return mensajes, "sin_cambios"
        
        elif tokens_actuales <= self.limite_maximo * 0.95:
            # Truncamiento ligero
            return truncar_conversacion(mensajes, self.limite_seguridad, self.modelo)[0], "truncado"
        
        else:
            # Resumen necesario
            return resumir_contexto_antiguo(mensajes), "resumido"

# Uso del gestor
gestor = GestorVentanaContexto("gpt-4.1")
conversacion_optimizada, estrategia = gestor.gestionar_conversacion(conversacion_larga)
print(f"Estrategia aplicada: {estrategia}")

Consideraciones para conversaciones especializadas

En algunos casos, necesitamos preservar información específica independientemente del límite de contexto. Por ejemplo, en conversaciones técnicas donde ciertos datos son críticos:

def preservar_informacion_critica(mensajes, palabras_clave=None):
    """Identifica y preserva mensajes con información crítica"""
    if not palabras_clave:
        palabras_clave = ["error", "configuración", "credenciales", "importante"]
    
    mensajes_criticos = []
    mensajes_normales = []
    
    for mensaje in mensajes:
        es_critico = any(palabra in mensaje["content"].lower() 
                        for palabra in palabras_clave)
        
        if es_critico:
            mensajes_criticos.append(mensaje)
        else:
            mensajes_normales.append(mensaje)
    
    return mensajes_criticos, mensajes_normales

La gestión efectiva de ventanas de contexto requiere un equilibrio entre preservar información relevante y mantener la eficiencia. En aplicaciones complejas, estas estrategias se combinan con técnicas como RAG (Retrieval-Augmented Generation) para acceder a información externa sin consumir tokens de contexto, tema que exploraremos en lecciones posteriores.