5. Cost Modeling para AI Deployment

Descripción

En esta cápsula vas a aprender a estimar costes reales de deployment para AI workloads. No como ejercicio teórico — con calculadoras funcionales, números de proveedores actuales, y modelos que puedes adaptar a tu caso. Al terminar, podrás estimar cuánto cuesta tu sistema AI en cualquier estrategia de deployment antes de desplegar.

Contexto: "¿Cuánto va a costar?" es la pregunta que más paraliza decisiones de deployment. Si no sabes estimar, eliges por miedo ("AWS es caro") o por ignorancia ("Lambda es gratis"). Esta cápsula te da herramientas para decidir con datos.

Por Qué el Cost Modeling Es Diferente para AI

El coste oculto: API calls a LLMs

En una app web tradicional, el coste principal es infraestructura: servidores, bases de datos, CDN. En una app AI, el coste principal suele ser las llamadas a APIs de LLMs. Y ese coste se multiplica por cada request de usuario.

# Desglose de coste por request en una app AI típica
cost_per_request = {
    "infrastructure": 0.00002,  # Lambda o fracción de VPS
    "llm_api_call": 0.003,     # GPT-4o-mini, ~500 tokens input + 500 output
    "embedding": 0.0001,       # text-embedding-3-small
    "storage": 0.000001,       # S3 storage por request
}

total_per_request = sum(cost_per_request.values())
# = $0.003121 por request

monthly_requests = 100_000
monthly_cost = total_per_request * monthly_requests
# = $312.10/mes

# De esos $312, $300 son LLM API calls
# La infra es $2/mes — el 0.6% del total

Insight: Para la mayoría de apps AI, el coste de infraestructura (Lambda, VPS, Render) es irrelevante comparado con el coste de LLM APIs. Optimizar infra cuando tu factura de OpenAI es 50x más grande es optimizar lo equivocado.

Cuándo la infraestructura SÍ domina

La excepción es cuando usas modelos locales (no APIs externas): embeddings en memoria, modelos open-source en GPU. Ahí el coste de infra (GPU instances, RAM) domina.

Coste dominante según arquitectura:

API-based (OpenAI, Anthropic):
  LLM APIs: 90-95% del coste total
  Infra:     5-10%
  → Optimiza PROMPTS, no infra

Self-hosted models (Llama, Mistral):
  GPU compute: 70-85% del coste total
  Infra:       15-30%
  → Optimiza GPU utilization e infra

Hybrid (embeddings locales + LLM API):
  LLM APIs: 50-70%
  GPU/RAM:  20-30%
  Infra:    10-20%
  → Optimiza ambos

Modelo de Costes: Fixed vs Variable

Fixed costs (costes fijos)

Pagas lo mismo independientemente del tráfico:

fixed_costs_examples = {
    "vps_digitalocean_4gb": 24,      # $/mes
    "vps_digitalocean_8gb": 48,      # $/mes
    "railway_pro_plan": 5,           # $/mes base
    "render_starter": 7,             # $/mes
    "domain_name": 1,                # $/mes (approx)
    "ssl_certificate": 0,            # Free con Let's Encrypt
    "monitoring_uptimerobot": 0,     # Free tier
}

total_fixed = sum(fixed_costs_examples.values())
# = $85/mes (con VPS 8GB)

Variable costs (costes variables)

Escalan con el uso:

def variable_costs(monthly_requests: int) -> dict:
    """Calcula costes variables para AI app."""
    
    # LLM API (GPT-4o-mini: $0.15/1M input, $0.60/1M output tokens)
    avg_input_tokens = 500
    avg_output_tokens = 300
    llm_cost = monthly_requests * (
        (avg_input_tokens / 1_000_000 * 0.15) + 
        (avg_output_tokens / 1_000_000 * 0.60)
    )
    
    # Lambda (si serverless)
    lambda_cost = monthly_requests * 0.0000169  # 512MB, 2s
    
    # S3 (almacenamiento + requests)
    s3_storage = 0.023  # $/GB/mes, asumiendo 1GB
    s3_requests = monthly_requests * 0.0000004  # GET requests
    
    # Embeddings (si RAG)
    embedding_cost = monthly_requests * 0.0001  # text-embedding-3-small
    
    return {
        "llm_api": round(llm_cost, 2),
        "lambda": round(lambda_cost, 2),
        "s3": round(s3_storage + s3_requests, 2),
        "embeddings": round(embedding_cost, 2),
        "total": round(llm_cost + lambda_cost + s3_storage + s3_requests + embedding_cost, 2)
    }

# Ejemplo: 100K requests/mes
costs = variable_costs(100_000)
# {'llm_api': 25.50, 'lambda': 1.69, 's3': 0.06, 'embeddings': 10.0, 'total': 37.25}

Calculadora de Costes por Estrategia

Parámetros del escenario

# Define tu escenario
scenario = {
    "name": "App RAG para equipo interno",
    "monthly_requests": 50_000,
    "avg_duration_seconds": 3,
    "memory_mb": 512,
    "storage_gb": 5,
    "avg_input_tokens": 800,   # RAG context + prompt
    "avg_output_tokens": 400,
    "uses_embeddings": True,
    "team_size": 1,
    "ops_hourly_rate": 50,  # $/hr para calcular tiempo de ops
}

Coste por estrategia

def calculate_all_strategies(s: dict) -> dict:
    """Calcula coste mensual para cada estrategia."""
    
    # Coste de LLM (común a todas las estrategias)
    llm_monthly = s["monthly_requests"] * (
        (s["avg_input_tokens"] / 1_000_000 * 0.15) +
        (s["avg_output_tokens"] / 1_000_000 * 0.60)
    )
    embedding_monthly = s["monthly_requests"] * 0.0001 if s["uses_embeddings"] else 0
    api_costs = llm_monthly + embedding_monthly
    
    strategies = {}
    
    # LOCAL (VPS)
    vps_price = 24 if s["memory_mb"] <= 4096 else 48
    ops_hours_local = 3  # hrs/mes mantenimiento
    strategies["local"] = {
        "infra": vps_price,
        "ops": ops_hours_local * s["ops_hourly_rate"],
        "api_costs": api_costs,
        "total": vps_price + (ops_hours_local * s["ops_hourly_rate"]) + api_costs
    }
    
    # SERVERLESS (Lambda)
    gb_seconds = s["monthly_requests"] * s["avg_duration_seconds"] * (s["memory_mb"] / 1024)
    lambda_compute = gb_seconds * 0.0000166667
    lambda_requests = s["monthly_requests"] * 0.0000002
    ops_hours_lambda = 1
    strategies["serverless"] = {
        "infra": round(lambda_compute + lambda_requests, 2),
        "ops": ops_hours_lambda * s["ops_hourly_rate"],
        "api_costs": api_costs,
        "total": round(lambda_compute + lambda_requests + (ops_hours_lambda * s["ops_hourly_rate"]) + api_costs, 2)
    }
    
    # MANAGED (Railway)
    railway_base = 5
    railway_usage = s["monthly_requests"] * 0.00005  # estimación
    ops_hours_managed = 0.5
    strategies["managed"] = {
        "infra": round(railway_base + railway_usage, 2),
        "ops": ops_hours_managed * s["ops_hourly_rate"],
        "api_costs": api_costs,
        "total": round(railway_base + railway_usage + (ops_hours_managed * s["ops_hourly_rate"]) + api_costs, 2)
    }
    
    # SELF-HOSTED (EC2)
    ec2_price = 30  # t3.medium on-demand
    ops_hours_selfhosted = 8
    strategies["self_hosted"] = {
        "infra": ec2_price,
        "ops": ops_hours_selfhosted * s["ops_hourly_rate"],
        "api_costs": api_costs,
        "total": round(ec2_price + (ops_hours_selfhosted * s["ops_hourly_rate"]) + api_costs, 2)
    }
    
    return strategies

results = calculate_all_strategies(scenario)

Output esperado para 50K req/mes:

LOCAL:       Infra $24    + Ops $150  + APIs $17.00  = $191.00
SERVERLESS:  Infra $1.25  + Ops $50   + APIs $17.00  = $68.25
MANAGED:     Infra $7.50  + Ops $25   + APIs $17.00  = $49.50
SELF-HOSTED: Infra $30    + Ops $400  + APIs $17.00  = $447.00

Ganador en coste total: MANAGED ($49.50)
Ganador en coste de infra: SERVERLESS ($1.25)

Nota: El coste de LLM APIs ($17/mes) es constante.
La diferencia está en infra + ops.

El Factor Ops: El Coste Invisible

Tiempo de operación por estrategia

Horas/mes de operación (estimación para 1 developer):

LOCAL (VPS + Docker):
├── Monitoring y health checks:     0.5 hrs
├── Updates (OS, Docker, deps):     1.0 hrs
├── Debugging incidencias:          1.0 hrs
├── Backups y recovery testing:     0.5 hrs
└── Total:                          3.0 hrs/mes

SERVERLESS (Lambda):
├── CloudWatch review:              0.5 hrs
├── Debugging cold starts/timeouts: 0.5 hrs
└── Total:                          1.0 hrs/mes

MANAGED (Railway/Render):
├── Dashboard review:               0.25 hrs
├── Env vars y config updates:      0.25 hrs
└── Total:                          0.5 hrs/mes

SELF-HOSTED (EC2 + todo):
├── Patching y security:            2.0 hrs
├── Monitoring y alertas:           1.5 hrs
├── Scaling y capacity planning:    1.0 hrs
├── Networking y firewall:          0.5 hrs
├── Backup y DR:                    1.0 hrs
├── Debugging:                      2.0 hrs
└── Total:                          8.0 hrs/mes

Si tu tiempo vale $50/hr

LOCAL:       3 hrs × $50 =  $150/mes en ops
SERVERLESS:  1 hr  × $50 =   $50/mes en ops
MANAGED:     0.5hr × $50 =   $25/mes en ops
SELF-HOSTED: 8 hrs × $50 =  $400/mes en ops

Insight: Para un developer solo, el coste de ops en self-hosted ($400/mes) supera por mucho el coste de infra ($30/mes). El coste real de self-hosted no es EC2 — es tu tiempo.

Escenarios de Coste: MVP vs Growth vs Scale

MVP (1K requests/día)

Monthly: 30K requests

            Infra    Ops     APIs    TOTAL
LOCAL:      $24      $150    $5      $179
SERVERLESS: $0.50    $50     $5      $55.50
MANAGED:    $0       $25     $5      $30 ← Free tier
SELF-HOST:  $30      $400    $5      $435

Ganador: Managed (free tier de Railway/Render)

Growth (30K requests/día)

Monthly: 900K requests

            Infra    Ops     APIs    TOTAL
LOCAL:      $24      $150    $153    $327
SERVERLESS: $15      $75     $153    $243
MANAGED:    $50      $25     $153    $228
SELF-HOST:  $30      $400    $153    $583

Ganador: Managed (todavía, pero se acerca a serverless)

Scale (300K requests/día)

Monthly: 9M requests

            Infra    Ops     APIs     TOTAL
LOCAL:      $48      $200    $1,530   $1,778
SERVERLESS: $150     $100    $1,530   $1,780
MANAGED:    $200     $50     $1,530   $1,780
SELF-HOST:  $60      $600    $1,530   $2,190

Insight a escala: Cuando las API calls dominan ($1,530/mes), la diferencia de infra entre estrategias ($48-$200) es marginal. A escala, optimiza tus prompts y tokens, no tu infra.

Calculadora Interactiva: Copia y Ejecuta

Este script es una calculadora completa que puedes copiar, adaptar a tu caso, y ejecutar localmente:

# ai_cost_calculator.py — Copia este archivo y ejecútalo con tus datos

def ai_deployment_cost_report(
    name: str,
    monthly_requests: int,
    avg_input_tokens: int = 500,
    avg_output_tokens: int = 300,
    llm_model: str = "gpt-4o-mini",
    uses_embeddings: bool = False,
    memory_mb: int = 512,
    avg_duration_s: float = 2.0,
    vps_price: float = 24.0,
    ops_hourly_rate: float = 50.0,
):
    """Genera reporte de costes para tu app AI en todas las estrategias."""

    # Precios de modelos LLM ($/1M tokens, actualizar según cambios)
    llm_prices = {
        "gpt-4o":      {"input": 2.50, "output": 10.00},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "claude-sonnet":{"input": 3.00, "output": 15.00},
        "claude-haiku": {"input": 0.25, "output": 1.25},
    }

    prices = llm_prices.get(llm_model, llm_prices["gpt-4o-mini"])
    llm_monthly = monthly_requests * (
        (avg_input_tokens / 1_000_000 * prices["input"]) +
        (avg_output_tokens / 1_000_000 * prices["output"])
    )
    embed_monthly = monthly_requests * 0.0001 if uses_embeddings else 0
    api_total = llm_monthly + embed_monthly

    # Lambda compute
    gb_s = monthly_requests * avg_duration_s * (memory_mb / 1024)
    lambda_cost = gb_s * 0.0000166667 + monthly_requests * 0.0000002

    strategies = {
        "Local (VPS)":    {"infra": vps_price, "ops_hrs": 3},
        "Serverless":     {"infra": round(lambda_cost, 2), "ops_hrs": 1},
        "Managed":        {"infra": round(5 + monthly_requests * 0.00005, 2), "ops_hrs": 0.5},
        "Self-hosted":    {"infra": 30, "ops_hrs": 8},
    }

    print(f"\n{'='*60}")
    print(f"  COST REPORT: {name}")
    print(f"  {monthly_requests:,} requests/mes | Model: {llm_model}")
    print(f"{'='*60}")
    print(f"\n  API costs (all strategies): ${api_total:.2f}/mes")
    print(f"    LLM: ${llm_monthly:.2f} | Embeddings: ${embed_monthly:.2f}\n")
    print(f"  {'Strategy':<18} {'Infra':>8} {'Ops':>8} {'APIs':>8} {'TOTAL':>10}")
    print(f"  {'-'*18} {'-'*8} {'-'*8} {'-'*8} {'-'*10}")

    for strat, data in strategies.items():
        ops_cost = data["ops_hrs"] * ops_hourly_rate
        total = data["infra"] + ops_cost + api_total
        print(f"  {strat:<18} ${data['infra']:>6.2f} ${ops_cost:>6.0f} ${api_total:>6.2f} ${total:>8.2f}")

    print(f"\n  Nota: Ops = horas/mes × ${ops_hourly_rate}/hr (tu tiempo)")
    print(f"{'='*60}\n")

# === MODIFICA ESTOS VALORES CON TUS DATOS ===
ai_deployment_cost_report(
    name="Mi App RAG",
    monthly_requests=50_000,
    avg_input_tokens=800,
    avg_output_tokens=400,
    llm_model="gpt-4o-mini",
    uses_embeddings=True,
    memory_mb=512,
    avg_duration_s=2.0,
    vps_price=24.0,
    ops_hourly_rate=50.0,
)

Ejecuta python ai_cost_calculator.py y obtienes un reporte completo. Cambia los parámetros para explorar escenarios: ¿qué pasa si usas GPT-4o en lugar de mini? ¿Si dupliques el tráfico?

Optimización de Costes AI-Specific

Reducir coste de LLM APIs (el 90% del gasto)

# Estrategia 1: Caching de responses
import hashlib
import redis

r = redis.Redis()

def cached_llm_call(prompt: str, model: str = "gpt-4o-mini") -> str:
    cache_key = hashlib.md5(f"{model}:{prompt}".encode()).hexdigest()
    cached = r.get(cache_key)
    if cached:
        return cached.decode()  # Cache hit: $0 en API
    
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    result = response.choices[0].message.content
    r.setex(cache_key, 3600, result)  # Cache 1 hora
    return result

# Si 30% de requests son repetidos, reduces 30% del coste de APIs

# Estrategia 2: Modelo correcto para la tarea
model_costs = {
    "gpt-4o":      {"input": 2.50, "output": 10.00},  # $/1M tokens
    "gpt-4o-mini": {"input": 0.15, "output": 0.60},   # 16x más barato
    "gpt-3.5":     {"input": 0.50, "output": 1.50},   # Legacy
}

# Si el 80% de tus requests no necesitan GPT-4o,
# usar gpt-4o-mini para esos ahorra 16x

# Estrategia 3: Prompt optimization (menos tokens)
prompt_v1 = """
You are a helpful AI assistant that specializes in answering 
questions about software deployment and cloud infrastructure. 
Please analyze the following question carefully and provide 
a detailed, comprehensive answer that covers all relevant aspects.

Question: What is Docker?
"""  # ~45 tokens

prompt_v2 = """Answer concisely: What is Docker?"""  # ~8 tokens

# v2 usa 82% menos tokens de input
# A 100K req/mes con GPT-4o-mini: ahorro de $0.56/mes (poco)
# A 100K req/mes con GPT-4o: ahorro de $9.25/mes (significativo)

Comparación: Cuándo Usar X vs Y

Decision matrix por presupuesto

Troubleshooting

Problema 1: "La factura de OpenAI es mayor que la de infraestructura"

Solución: Normal para apps API-based. Prioriza: (1) caching, (2) modelo correcto por tarea, (3) prompt optimization. La infra es secondary.

Problema 2: "No sé estimar el tráfico"

Solución: Empieza con la estrategia más flexible (managed o serverless), mide tráfico real durante 1-2 meses, y re-evalúa. No optimices para tráfico que no tienes.

Problema 3: "Los costes escalan más rápido de lo esperado"

Solución: Revisa (1) si hay loops de LLM calls (un bug puede multiplicar costes), (2) si el prompt es innecesariamente largo, (3) si estás cacheando responses repetidos. Un bug común en LangChain es un retry loop que llama al LLM 5 veces por error, multiplicando tu factura 5x.

Problema 4: "No sé qué modelo LLM usar para optimizar costes"

Solución: Compara precios por tarea. Para la mayoría de casos:

Tarea                          | Modelo recomendado     | Coste/100K req
-------------------------------|------------------------|---------------
Clasificación simple           | gpt-4o-mini            | ~$3
Resumen de documentos          | gpt-4o-mini            | ~$5
Razonamiento complejo          | gpt-4o                 | ~$600
Código + análisis              | claude-sonnet          | ~$900
Triage/routing de requests     | claude-haiku           | ~$8

Usa el modelo más barato que cumpla la calidad requerida. Evalúa con 50-100 requests de prueba antes de comprometerte.

Ejercicios Prácticos

Ejercicio 1: Calcula tu coste actual

Usa la calculadora de costes para estimar el coste mensual de tu app AI en las 4 estrategias. Usa números reales de tu app o los del escenario de ejemplo.

Ejercicio 2: Encuentra el breakeven

¿A cuántos requests/mes tu estrategia elegida se vuelve más cara que la alternativa? Calcula el punto de inflexión.

Railway: $7.50 fijo + overhead
Lambda: $0.0000169 × requests

Breakeven: $7.50 / $0.0000169 = ~444K requests/mes

A <444K req/mes: Lambda más barato en infra
A >444K req/mes: Railway puede ser más barato (pero verificar plan limits)

Ejercicio 3: Optimización de coste LLM

Tu app hace 100K req/mes con GPT-4o (promedio 800 input + 400 output tokens). Calcula: (a) coste actual, (b) coste si migras el 80% a GPT-4o-mini, (c) coste si implementas caching con 30% hit rate.

# (a) Actual: 100% GPT-4o
current = 100_000 * ((800/1e6 * 2.50) + (400/1e6 * 10.00))
# = 100_000 * (0.002 + 0.004) = 100_000 * 0.006 = $600/mes

# (b) 80% GPT-4o-mini, 20% GPT-4o
mini = 80_000 * ((800/1e6 * 0.15) + (400/1e6 * 0.60))  # = $28.80
full = 20_000 * ((800/1e6 * 2.50) + (400/1e6 * 10.00))  # = $120
optimized = mini + full  # = $148.80/mes (75% ahorro)

# (c) Caching 30% hit rate sobre (b)
requests_after_cache = 100_000 * 0.70  # 70K requests reales
mini_cached = 56_000 * ((800/1e6 * 0.15) + (400/1e6 * 0.60))  # = $20.16
full_cached = 14_000 * ((800/1e6 * 2.50) + (400/1e6 * 10.00))  # = $84
with_cache = mini_cached + full_cached  # = $104.16/mes (83% ahorro total)

Ejercicio 4: Presenta un budget

Prepara un budget de 3 meses para tu app AI incluyendo: infra, APIs, y ops. Incluye un escenario pesimista (2x tráfico esperado).

## Budget: Mi App RAG (3 meses)

### Escenario base (50K req/mes)
| Mes | Infra (Railway) | APIs (OpenAI) | Ops (mi tiempo) | Total |
|-----|-----------------|---------------|-----------------|-------|
| 1   | $7.50           | $17.00        | $25             | $49.50|
| 2   | $7.50           | $17.00        | $25             | $49.50|
| 3   | $7.50           | $17.00        | $25             | $49.50|
| **Total** | **$22.50** | **$51.00**   | **$75**         | **$148.50**|

### Escenario pesimista (100K req/mes)
| Mes | Infra | APIs   | Ops  | Total   |
|-----|-------|--------|------|---------|
| 1   | $12   | $34    | $25  | $71     |
| 2   | $12   | $34    | $50  | $96     |
| 3   | $15   | $34    | $50  | $99     |
| **Total** | **$39** | **$102** | **$125** | **$266** |

### Mitigaciones
- Si APIs > $50/mes → implementar caching
- Si infra > $20/mes → evaluar VPS como alternativa
- Revisión mensual de costes reales vs budget

Resumen

• El coste de LLM APIs domina sobre el coste de infraestructura para la mayoría de apps AI (90%+ del total).
• Fixed costs (VPS, managed plans) son predecibles; variable costs (Lambda, APIs) escalan con tráfico.
• El coste de ops (tu tiempo) es el coste más subestimado — self-hosted puede costar $400/mes en tiempo.
• A escala, la diferencia entre estrategias de infra es marginal cuando las APIs dominan. Optimiza prompts, no infra.
• Las 3 optimizaciones más efectivas son: caching de responses, modelo correcto por tarea, y prompt optimization.
• Siempre estima antes de deployer. Usa la calculadora de esta cápsula adaptada a tus números.
• Re-evalúa mensualmente con datos reales vs estimaciones.

Recursos Adicionales

1. AWS Pricing Calculator — Estimador oficial de costes AWS
2. OpenAI Pricing — Precios actualizados de modelos OpenAI
3. Anthropic Pricing — Precios de Claude
4. Cloud Cost Handbook — Vantage — Referencia de costes por servicio cloud
5. Railway Pricing — Pricing detallado de Railway
6. Render Pricing — Pricing de Render