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

Optimización de costes a escala

Lección 10 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. El coste como restricción de ingeniería
  2. Saber a dónde va el dinero
  3. Cuatro palancas de reducción
  4. Recibir avisos antes de la factura
  5. Puntos clave

El coste como restricción de ingeniería

Un prompt mal optimizado que cuesta 0,002 $ por llamada es insignificante durante el desarrollo. Con un millón de llamadas, el coste asciende a 2.000 $, y seguirás pagando esa cantidad cada mes hasta que alguien lo reescriba. Este cambio de escala convierte el coste en una restricción de ingeniería: no se resuelve negociando un contrato, sino modificando el código.

La visibilidad es el prerrequisito para cualquier optimización. Una factura mensual te indica cuánto has gastado, no dónde. Por eso esta lección comienza con la instrumentación antes de abordar las palancas de reducción.

Saber a dónde va el dinero

Cuatro elementos determinan el coste de una llamada y no se comportan de la misma manera. Los tokens de entrada, que agregan el prompt del sistema, el historial de la conversación y el mensaje del usuario, crecen con la duración de la sesión. Los tokens de salida (la respuesta generada) se facturan significativamente más caros que los de entrada. Los tokens de entrada en caché reciben un descuento de aproximadamente el 50 % sobre la tarifa de entrada, por lo que su seguimiento es esencial para entender cualquier factura. Por último, el modelo en sí: GPT-5.6 Luna es mucho más barato que GPT-5.6 Sol, y este factor domina a todos los demás.

Hacer un seguimiento significa convertir cada objeto usage devuelto por la API en una cantidad en dólares, aplicar la tarifa correcta y aislar la parte en caché.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Tarifas por millón de tokens (julio de 2026) — cached_input es indicativo (~50 % de input),
# ajustar según la cuadrícula de precios oficial
RATES = {
    "gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
    "gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
    "gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}

@dataclass
class CostTracker:
    """Realiza un seguimiento de los costes en tiempo real."""
    calls: list[dict] = field(default_factory=list)

    def record(self, model: str, usage: dict) -> float:
        input_tokens = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        output_tokens = usage.output_tokens
        uncached_input_tokens = input_tokens - cached_tokens

        rate = RATES.get(model, RATES["gpt-5.6-terra"])
        cost = (
            (uncached_input_tokens / 1_000_000) * rate["input"]
            + (cached_tokens / 1_000_000) * rate["cached_input"]
            + (output_tokens / 1_000_000) * rate["output"]
        )

        self.calls.append({
            "model": model,
            "input_tokens": input_tokens,
            "cached_tokens": cached_tokens,
            "output_tokens": output_tokens,
            "cost": cost,
        })
        return cost

    @property
    def total_cost(self) -> float:
        return sum(a["cost"] for a in self.calls)

    def report(self) -> str:
        if not self.calls:
            return "No se han registrado llamadas."
        return (
            f"Llamadas: {len(self.calls)} | "
            f"Coste total: ${self.total_cost:.4f} | "
            f"Coste medio: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

La tabla RATES requiere atención constante: queda obsoleta en cuanto cambia la cuadrícula de precios oficial. Trátala como datos de configuración que hay que verificar, no como una constante del programa, y convierte el coste medio por llamada en una métrica que revises semanalmente.

Cuatro palancas de reducción

La primera palanca, y con diferencia la más rentable, es evitar pagar por un modelo de gama alta cuando la tarea no lo requiere. El enrutamiento explícito basado en la complejidad evita la deriva por defecto donde todo el tráfico acaba en el modelo más caro simplemente porque aparecía en el primer ejemplo copiado.

async def economic_router(prompt: str, complexity: str) -> str:
    """Enruta al modelo capaz más barato."""
    if complexity == "simple":
        model = "gpt-5.6-luna"
    elif complexity == "medium":
        model = "gpt-5.6-terra"
    else:
        model = "gpt-5.6-sol"

    response = client.responses.create(model=model, input=prompt)
    tracker.record(model, response.usage)
    return response.output_text

La segunda palanca va más allá cuando la complejidad no se conoce de antemano. En lugar de clasificar la solicitud, la cascada prueba primero el modelo más barato y escala solo si la respuesta no supera una comprobación de calidad. La comprobación utilizada aquí es deliberadamente rudimentaria (una longitud mínima y la ausencia de una admisión de ignorancia), y este es el punto que tendrás que refinar: una cascada que escala con demasiada frecuencia resulta más cara que una llamada directa al modelo adecuado.

async def model_cascade(prompt: str) -> str:
    """Prueba primero el modelo más barato."""
    models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]

    for model in models:
        response = client.responses.create(
            model=model,
            input=prompt,
            max_output_tokens=500,
        )
        tracker.record(model, response.usage)

        # Comprobar la calidad (heurística simple)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Último resultado aunque sea imperfecto

La tercera palanca se dirige a los tokens de entrada, que crecen silenciosamente en cualquier aplicación conversacional: en el vigésimo turno, estás volviendo a pagar por los diecinueve anteriores con cada mensaje. Comprimir el historial manteniendo el primer mensaje (que contiene el contexto) y el último (que contiene la pregunta), y rellenando el presupuesto restante con los intercambios más recientes, preserva la coherencia esencial a una fracción del coste.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Mantiene los mensajes más recientes dentro del presupuesto."""
    # Mantener siempre el primero (contexto) y el último (pregunta)
    if len(messages) <= 2:
        return messages

    first = messages[0]
    last = messages[-1]
    middle = messages[1:-1]

    # Estimar tokens (aproximación: 1 token ≈ 4 caracteres)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Mantener los mensajes más recientes
    result = []
    tokens_used = 0
    for msg in reversed(middle):
        msg_tokens = len(msg["content"]) // 4
        if tokens_used + msg_tokens > middle_budget:
            break
        result.insert(0, msg)
        tokens_used += msg_tokens

    return [first] + result + [last]

La cuarta palanca no requiere finura algorítmica, solo disciplina: la API Batch ofrece una reducción del 50 %, y solo necesitas identificar qué puede esperar. Deja que la propia tarea porte la urgencia desde su creación, en lugar de deducirla después; esta es la única forma de evitar que todo acabe por defecto en la cola de tiempo real.

def classify_urgency(tasks: list[dict]) -> dict:
    """Separa las tareas en tiempo real frente a por lotes."""
    real_time = []
    batch = []

    for task in tasks:
        if task.get("urgency") == "immediate":
            real_time.append(task)
        else:
            batch.append(task)

    return {
        "real_time": real_time,
        "batch": batch,
        "estimated_savings": len(batch) * 0.001,  # Ejemplo
    }

Recibir avisos antes de la factura

Todas estas optimizaciones pueden verse anuladas por un único despliegue desafortunado: un bucle de reintentos sin límites, un prompt del sistema triplicado o un modelo cambiado por error. Una alerta de costes es la red de seguridad que te avisa en horas, no a final de mes. Obsérvese el umbral intermedio al 80 %: convierte una alarma brutal en una señal temprana, dándote tiempo para actuar antes de superar el límite.

class CostAlert:
    """Activa alertas cuando los costes superan un umbral."""

    def __init__(self, daily_threshold: float = 50.0):
        self.threshold = daily_threshold
        self.tracker = CostTracker()

    def check(self) -> str | None:
        if self.tracker.total_cost > self.threshold:
            return (
                f"ALERTA: coste diario ${self.tracker.total_cost:.2f} "
                f"supera el umbral de ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"AVISO: coste al {self.tracker.total_cost / self.threshold:.0%} "
                f"del umbral diario"
            )
        return None

Puntos clave

  • Realiza un seguimiento de tus costes en tiempo real usando response.usage
  • Enruta al modelo más barato capaz de realizar la tarea
  • Usa la API Batch (-50 %) para cualquier cosa que no requiera procesamiento en tiempo real
  • Reduce los tokens de entrada comprimiendo el historial
  • Configura alertas de costes para evitar sorpresas