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

Recuento y presupuestación de tokens

Lección 12 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. Comprensión de los tokens
  2. Recuento con tiktoken
  3. Presupuestación antes de llamar
  4. Estimación de costes antes de gastar
  5. Puntos clave

Comprensión de los tokens

Los tokens son la unidad fundamental de medida para los LLM. Cada llamada a la API se factura en tokens, y cada modelo rechaza las solicitudes que superan su ventana de contexto. Dominar el recuento de tokens te permite hacer tres cosas que la aproximación no puede: predecir costes antes de incurrir en ellos, optimizar tus indicaciones basándote en números concretos en lugar de intuiciones, y respetar los límites de contexto sin descubrir un desbordamiento solo cuando la API lanza un error.

Recuento con tiktoken

La biblioteca tiktoken aplica exactamente la misma tokenización que el modelo. Instancias un codificador para el modelo objetivo y luego cuentas la longitud de la secuencia codificada.

import tiktoken

# Codificador para modelos GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Cuenta el número de tokens en un texto."""
    return len(encoder.encode(text))

# Ejemplos
print(count_tokens("Hello"))           # ~1-2 tokens
print(count_tokens("Hello world"))     # ~3-4 tokens
print(count_tokens("Development"))     # ~2-3 tokens (los acentos cuestan más)

El tercer ejemplo merece una pausa. “Development” cuesta más de lo que sugiere su longitud en caracteres porque los caracteres acentuados se tokenizan con menos eficiencia. En la práctica, un corpus en francés consume más tokens que uno equivalente en inglés: si estimaste tu presupuesto usando indicaciones en inglés y luego lo desplegaste en francés, tu factura real superará tu previsión.

Una llamada a la API conlleva más que texto plano: cada mensaje incluye un rol, a veces un nombre, y la API añade tokens estructurales. La siguiente función incorpora esta sobrecarga para proporcionar un total realista.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Cuenta los tokens en una conversación (mensajes + sobrecarga)."""
    total = 0
    for message in messages:
        total += 4  # Sobrecarga por mensaje (rol, etc.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Tokens de fin
    return total

conversation = [
    {"role": "system", "content": "Eres un asistente técnico."},
    {"role": "user", "content": "Explica los microservicios."},
    {"role": "assistant", "content": "Los microservicios son una arquitectura..."},
]

print(f"Total de tokens: {count_conversation_tokens(conversation)}")

En una conversación de tres mensajes, la sobrecarga es insignificante. En un historial de doscientos mensajes cortos, típico de un chat de soporte, se acumula hasta casi mil tokens que no habías tenido en cuenta.

Presupuestación antes de llamar

La ventana de contexto no es un presupuesto de entrada: es un presupuesto compartido entre lo que envías y lo que el modelo genera. Si llenas la ventana hasta el tope con tu indicación, la respuesta se truncará. La estructura BudgetTokens hace explícita esta asignación reservando una parte para la salida por adelantado.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Gestiona el presupuesto de tokens para una llamada."""
    context_limit: int       # Ventana del modelo
    system_tokens: int = 0   # Indicación del sistema
    history_tokens: int = 0  # Historial de conversación
    user_tokens: int = 0     # Mensaje actual
    output_reserve: int = 2000 # Reservado para la respuesta

    @property
    def available_tokens(self) -> int:
        used = (
            self.system_tokens
            + self.history_tokens
            + self.user_tokens
        )
        return self.context_limit - used - self.output_reserve

    @property
    def is_over(self) -> bool:
        return self.available_tokens < 0

    def report(self) -> str:
        return (
            f"Contexto: {self.context_limit} | "
            f"Sistema: {self.system_tokens} | "
            f"Historial: {self.history_tokens} | "
            f"Usuario: {self.user_tokens} | "
            f"Reserva de salida: {self.output_reserve} | "
            f"Disponible: {self.available_tokens}"
        )

# Ejemplo con una ventana de contexto de 128K tokens
budget = BudgetTokens(
    context_limit=128_000,
    system_tokens=count_tokens(system_prompt),
    history_tokens=count_conversation_tokens(history),
    user_tokens=count_tokens(user_message),
)

if budget.is_over:
    print("Presupuesto excedido — se requiere compactación")

El método report hace algo más que ayudar en la depuración. Regístralo en una muestra de solicitudes de producción y verás inmediatamente qué componente está consumiendo tu contexto. En la mayoría de las aplicaciones, la sorpresa proviene del historial, rara vez de la indicación del sistema que todo el mundo supervisa.

A continuación, debes actuar cuando se excede el presupuesto. La función prepare_context aplica la regla más simple y robusta: mantener los mensajes más recientes y descartar los más antiguos tan pronto como se agote el presupuesto. La iteración se ejecuta en orden inverso, insertando al principio para restaurar el orden cronológico.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Prepara el contexto respetando el presupuesto de tokens."""

    system_tokens = count_tokens(system_prompt)
    message_tokens = count_tokens(message)
    history_budget = (
        model_limit - system_tokens - message_tokens - output_reserve
    )

    # Mantener los mensajes más recientes dentro del presupuesto
    kept_messages = []
    used_tokens = 0

    for msg in reversed(history):
        msg_tokens = count_tokens(msg["content"]) + 4
        if used_tokens + msg_tokens > history_budget:
            break
        kept_messages.insert(0, msg)
        used_tokens += msg_tokens

    return (
        [{"role": "system", "content": system_prompt}]
        + kept_messages
        + [{"role": "user", "content": message}]
    )

Este truncamiento es brutal: cualquier cosa que quede fuera del presupuesto se pierde. Cuando el contexto antiguo importa realmente, como un expediente de cliente seguido durante varias semanas, sustituye la eliminación pura por la estrategia de compactación tratada en la lección anterior.

Estimación de costes antes de gastar

Los errores de facturación más costosos provienen del procesamiento por lotes: ejecutas un pase sobre 10.000 documentos y descubres el importe al día siguiente. Estimar primero, en unos pocos milisegundos de cálculo local, evita este escenario.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Estima el coste de una llamada antes de ejecutarla."""
    # Tarifas por millón de tokens (julio de 2026 — verifica la tarifa oficial)
    rates = {
        "gpt-5.6-luna": {"input": 0.20, "output": 1.20},
        "gpt-5.6-terra": {"input": 2.00, "output": 12.00},
        "gpt-5.6-sol": {"input": 5.00, "output": 30.00},
    }

    rate = rates.get(model, rates["gpt-5.6-terra"])
    input_cost = (input_tokens / 1_000_000) * rate["input"]
    output_cost = (estimated_output_tokens / 1_000_000) * rate["output"]

    return {
        "model": model,
        "input_tokens": input_tokens,
        "estimated_output_tokens": estimated_output_tokens,
        "input_cost": f"${input_cost:.6f}",
        "output_cost": f"${output_cost:.6f}",
        "total_cost": f"${input_cost + output_cost:.6f}",
    }

# Antes de enviar una indicación grande
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

La tabla de tarifas está codificada en este ejemplo, con la fecha en un comentario. Trátala como datos de configuración que debes verificar regularmente frente a la cuadrícula de precios oficial: una estimación calculada con precios obsoletos es más peligrosa que no estimar en absoluto, porque inspira una falsa confianza.

Por último, conoce los límites de cada modelo para planificar tu presupuesto. Las ventanas de contexto varían de un modelo a otro dentro de la familia GPT-5.6; consulta la página oficial de modelos de OpenAI para obtener los valores actuales y configura context_limit desde tu configuración en lugar de codificarlo rígidamente en el código de llamada.

Puntos clave

  • Usa tiktoken para contar tokens antes de cada llamada, teniendo en cuenta la sobrecarga por mensaje
  • El francés consume más tokens que el inglés para contenido equivalente: ajusta tus estimaciones
  • Reserva siempre un presupuesto para los tokens de salida dentro de la ventana de contexto
  • Gestiona el contexto automáticamente descartando los mensajes más antiguos
  • Estima los costes antes de enviar solicitudes costosas, utilizando tarifas verificadas