Ir al contenido principal
Español— Elegir un idioma
Menú

Tokens, contexto y ventana de conversación

Lección 7 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Tokens, contexto y ventana de conversación
  2. ¿Qué es un token?
  3. La ventana de contexto
  4. Tres palancas de optimización
  5. El contexto se acumula en la conversación
  6. Puntos clave

Tokens, contexto y ventana de conversación

El token es la unidad que manipula el modelo y la que registra tu factura. Mientras este concepto siga siendo difuso, tus costes también lo estarán y, tarde o temprano, te toparás con un error de límite de contexto sin saber por qué. Esta lección aclara ambas cuestiones.

¿Qué es un token?

Un token no es una palabra. Es un fragmento de texto que el modelo trata como una unidad indivisible. En francés, un token representa de media unas 0,7 palabras. La biblioteca tiktoken te permite ver exactamente cómo se divide el texto: observa cómo «allez-vous» se rompe en dos tokens, mientras que «aujourd’hui», que aparece con más frecuencia en el corpus de entrenamiento, cabe en uno solo. Este detalle explica por qué un texto en francés consume más tokens que un texto en inglés de longitud comparable.

from openai import OpenAI
client = OpenAI()

# Para estimar tokens, usa la biblioteca tiktoken
import tiktoken

# cl200k_base se usa aquí como ejemplo: cada generación de modelo tiene su propio codificador.
# Comprueba el codificador del modelo que llamas antes de confiar en el recuento.
enc = tiktoken.get_encoding("cl200k_base")

texte = "Bonjour, comment allez-vous aujourd'hui ?"
tokens = enc.encode(texte)
print(f"Text: {texte}")
print(f"Number of tokens: {len(tokens)}")
print(f"Tokens: {tokens}")
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")

# Result:
# Text: Bonjour, comment allez-vous aujourd'hui ?
# Number of tokens: 9
# Tokens: [38025, 11, 4068, 67590, 5072, 76439, 30, ...]
# Decoded: ['Bonjour', ',', ' comment', ' allez', '-vous', " aujourd'hui", ' ?']

Verifica siempre qué codificador corresponde al modelo que llamas. Un recuento realizado con el codificador incorrecto sigue siendo una aproximación útil, pero no coincidirá exactamente con tu factura.

La ventana de contexto

Cada modelo tiene una ventana de contexto máxima, y la trampa para los principiantes es que incluye tanto la entrada como la salida. No es un presupuesto de entrada: es un presupuesto total. Si tu prompt ocupa 190.000 tokens de una ventana de 200.000, solo quedan 10.000 tokens para la respuesta. El modelo se cortará a mitad de frase sin más avisos.

# Generación anterior, como referencia:
# GPT-5.4: 1.000.000 tokens de contexto
# GPT-5.3: 200.000 tokens de contexto
# gpt-5.6-sol  : 200.000 tokens de contexto
# gpt-5.6-terra : 200.000 tokens de contexto

# Ejemplo: si tu entrada son 190.000 tokens en una ventana de 200.000,
# solo quedan 10.000 tokens para la respuesta

response = client.responses.create(
    model="gpt-5.6-terra",
    input="A very long text...",
    max_output_tokens=10000  # Límite explícito
)

Después del hecho, puedes leer el recuento exacto en response.usage, que distingue entre tokens de entrada, tokens de salida y el total:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain tokens in three sentences."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total: {usage.total_tokens}")

# Result:
# Input tokens: 12
# Output tokens: 58
# Total: 70

Tres palancas de optimización

La primera palanca es la concisión del prompt. Las fórmulas de cortesía y las precauciones retóricas no mejoran la respuesta y cuestan tokens hasta el último: la primera versión de abajo usa treinta y cinco tokens para un resultado idéntico al de la segunda, que usa diez. A la escala de un servicio que gestiona un millón de peticiones, la diferencia deja de ser anecdótica.

# MALO — prompt verboso (35 tokens)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Could you please give me a list "
          "of three fruits that are red in color, if that "
          "does not bother you of course?"
)

# BUENO — prompt conciso (10 tokens)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="List 3 red fruits."
)

La segunda palanca apunta a la salida, que cuesta varias veces más que la entrada. Combina la instrucción en el prompt con un techo técnico: la primera enmarca la redacción, la segunda garantiza que tu presupuesto se mantenga incluso si el modelo ignora la instrucción.

# Sin límite — el modelo puede generar muchos tokens
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis."
)

# Con límite — control de costes
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis in 2 sentences maximum.",
    max_output_tokens=100
)

La tercera palanca es estimar el coste antes de la llamada, algo que se vuelve esencial en cuanto procesas documentos de tamaño variable. Así podrás rechazar o dividir una petición demasiado pesada en lugar de descubrirla en tu factura.

import tiktoken

def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
    """Estima el coste de una llamada a la API."""
    enc = tiktoken.get_encoding("cl200k_base")
    input_tokens = len(enc.encode(text))

    # Precios aproximados por millón de tokens (comprueba los precios actuales)
    prices = {
        "gpt-5.6-sol": {"input": 5.0, "output": 30.0},
        "gpt-5.6-terra": {"input": 2.0, "output": 12.0},
        "gpt-5.6-luna": {"input": 0.20, "output": 1.20},
    }

    input_cost = (input_tokens / 1_000_000) * prices[model]["input"]

    return {
        "input_tokens": input_tokens,
        "input_cost_usd": round(input_cost, 6),
        "model": model
    }

print(estimate_cost("Explain relativity in 3 sentences."))
# Result: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}

El contexto se acumula en la conversación

Cuando encadenas intercambios usando previous_response_id, cada turno reinicia desde la totalidad de los turnos anteriores. Los tokens de entrada, por tanto, siguen creciendo: un diálogo que empieza en 50 tokens pesa 150 en el segundo turno y mucho más en el décimo. Esta es la causa más frecuente de que las facturas se disparen sin que aumente el tráfico, y monitorizar response.usage.input_tokens es tu señal de alarma.

# Turno 1: 50 tokens
r1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello, I am a Python developer."
)

# Turno 2: 50 + 100 = 150 tokens (contexto acumulativo)
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Which web frameworks do you recommend?",
    previous_response_id=r1.id
)

# Turno 10: ¡los tokens se acumulan!
# Monitoriza response.usage.input_tokens para evitar sorpresas
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")

Para conversaciones largas, la solución consiste en truncar activamente el historial: elimina los mensajes más antiguos hasta bajar de un límite elegido, manteniendo el primero, que suele llevar el contexto fundacional del intercambio.

def conversation_with_limit(messages: list, token_limit: int = 50000):
    """Mantiene la conversación bajo un límite de tokens."""
    enc = tiktoken.get_encoding("cl200k_base")

    total = sum(len(enc.encode(m["content"])) for m in messages)

    # Elimina los mensajes más antiguos si es necesario
    while total > token_limit and len(messages) > 2:
        removed = messages.pop(1)  # Mantiene el primer mensaje (contexto)
        total -= len(enc.encode(removed["content"]))

    return messages

Puntos clave

  • Un token equivale a unas 0,7 palabras en francés
  • La ventana de contexto incluye la entrada Y la salida
  • Las ventanas varían según el modelo: en la generación anterior, 1M de tokens para GPT-5.4 y 200K para GPT-5.3, o3-pro y o4-mini
  • Usa tiktoken para contar tokens antes de la llamada
  • Monitoriza response.usage para controlar tus costes
  • Gestiona activamente el contexto en conversaciones largas