Cost Analysis: Economics de Embeddings

Descripción de la cápsula

MTEB y latencia son importantes, pero el costo determina viabilidad. OpenAI cobra por token, self-hosting requiere GPU/CPU. ¿Cuándo cada opción hace sentido económicamente? ¿Cuál es el break-even point?

En esta cápsula aprenderás a calcular TCO (Total Cost of Ownership) de embeddings (API vs self-hosted), break-even analysis, costos ocultos (bandwidth, storage), y optimizaciones de costo. También construirás una calculadora de costos para tomar decisiones informadas.

Al final, podrás justificar elecciones de modelo con análisis de costo riguroso.

Modelos de costo

API-based (OpenAI, Cohere):

Costo = (Tokens procesados / 1,000,000) × Precio_por_1M_tokens

# Ejemplo OpenAI:
# 10M tokens × $0.020/1M = $0.20

Características:

• ✅ Costo variable (pagas por uso)
• ✅ Zero infraestructura
• ❌ Escala linealmente (más queries = más costo)

Self-hosted (SBERT, BGE):

Costo = GPU_rental + Storage + Bandwidth + Maintenance

# Ejemplo:
# GPU (NVIDIA T4): $200/mes
# Storage (1TB SSD): $10/mes
# Bandwidth: $5/mes
# Total: $215/mes (fijo)

Características:

• ✅ Costo fijo (no importa # queries)
• ❌ Requiere infraestructura
• ❌ Mantenimiento (DevOps)

OpenAI Pricing (2026)

Modelos y costos:

Assumptions: *50 tokens promedio por texto.

Calcular costo:

def calculate_openai_cost(n_queries, tokens_per_query, model="3-small"):
    """
    Calcular costo mensual de OpenAI embeddings
    
    Args:
        n_queries: Queries por mes
        tokens_per_query: Tokens promedio por query
        model: "3-small" o "3-large"
    
    Returns:
        Costo mensual (USD)
    """
    pricing = {
        "3-small": 0.020,
        "3-large": 0.130
    }
    
    total_tokens = n_queries * tokens_per_query
    cost = (total_tokens / 1_000_000) * pricing[model]
    
    return cost

# Ejemplo: RAG system
# 100K queries/mes, 50 tokens/query
cost = calculate_openai_cost(100_000, 50, "3-small")
print(f"Costo mensual: ${cost:.2f}")  # $0.10

Self-Hosting Pricing

Opciones de infraestructura:

1. Cloud GPU (AWS, GCP, Azure):

# NVIDIA T4 (16GB):
# AWS: $0.526/hora = $379/mes (24/7)
# GCP: $0.35/hora = $252/mes (24/7)

# NVIDIA A10G (24GB):
# AWS: $1.01/hora = $727/mes (24/7)

# Spot instances (interrumpible):
# T4: ~$0.15/hora = $108/mes (70% savings)

2. Dedicated servers (Hetzner, OVH):

# GPU server:
# Hetzner: $150-$300/mes (GPU incluida)
# OVH: $200-$400/mes

# Pros: Más barato que cloud
# Cons: Menos flexible (no auto-scaling)

3. Local hardware (on-premise):

# NVIDIA RTX 3090 (24GB):
# Compra: $1,500 (one-time)
# Amortizado: $1,500 / 36 meses = $42/mes
# Electricidad: $20/mes
# Total: ~$62/mes

# Pros: Cheapest long-term
# Cons: Upfront cost, no redundancy

Calcular TCO self-hosted:

def calculate_selfhosted_tco(
    gpu_cost_monthly=200,
    storage_gb=100,
    bandwidth_gb=500,
    maintenance_hours=5,
    devops_hourly=50
):
    """
    Calcular TCO mensual de self-hosting
    
    Returns:
        Costo mensual (USD)
    """
    # Infrastructure
    gpu_cost = gpu_cost_monthly
    storage_cost = storage_gb * 0.10  # $0.10/GB/mes
    bandwidth_cost = bandwidth_gb * 0.01  # $0.01/GB
    
    # Maintenance
    maintenance_cost = maintenance_hours * devops_hourly
    
    # Total
    total = gpu_cost + storage_cost + bandwidth_cost + maintenance_cost
    
    return {
        'gpu': gpu_cost,
        'storage': storage_cost,
        'bandwidth': bandwidth_cost,
        'maintenance': maintenance_cost,
        'total': total
    }

# Ejemplo
tco = calculate_selfhosted_tco()
print(f"TCO mensual: ${tco['total']:.2f}")

Output:

TCO mensual: $465.00
- GPU: $200
- Storage: $10
- Bandwidth: $5
- Maintenance: $250 (5 hrs × $50/hr)

Break-Even Analysis

Fórmula:

Break-even point (queries/mes) = TCO_selfhosted / Costo_por_query_API

# Ejemplo:
# TCO self-hosted: $465/mes
# OpenAI 3-small: $0.000001 por query (50 tokens)

break_even = 465 / 0.000001
# = 465M queries/mes

print(f"Break-even: {break_even/1_000_000:.0f}M queries/mes")

Break-even table:

Conclusion: Break-even ~500M queries/mes (con maintenance incluido).

Sin mantenimiento:

# Si NO cuentas mantenimiento (DevOps in-house):
# TCO self-hosted: $215/mes (solo infra)

break_even = 215 / 0.000001
# = 215M queries/mes

Break-even baja a 215M queries/mes.

Hidden Costs

OpenAI (API):

# ✅ Obvios:
# - Costo por token ($0.020/1M)

# ❌ Ocultos:
# - Retry logic (re-llamadas duplican costo)
# - Testing/development (cada test cuesta)
# - Scaling (costo escala linealmente)

Self-Hosted:

# ✅ Obvios:
# - GPU rental ($200/mes)
# - Storage ($10/mes)

# ❌ Ocultos:
# - DevOps time ($250/mes si 5 hrs/mes)
# - Downtime (SLA? backup GPU?)
# - Monitoring/logging (Grafana, Prometheus)
# - Updates (nuevos modelos, dependencies)
# - Security (patches, firewalls)

Total ocultos: +$300-$500/mes

Cost Optimizations

OpenAI:

1. Caching agresivo

# Cache embeddings ya generados
# Re-uso = $0 costo

# Ejemplo:
# 1M queries, 80% cache hit rate
# Real queries a API: 200K
# Ahorro: 80%

2. Dimensiones reducidas

# 1536 dims → 512 dims
# Mismo costo por query, pero:
# - 3x menos storage
# - 3x más rápido búsqueda

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="...",
    dimensions=512  # Reduce
)

3. Batch processing

# Batch reduce overhead HTTP
# Menos requests = menos latencia
# (pero mismo costo por token)

Self-Hosted:

1. Spot instances (cloud)

# GPU spot instances: 70% cheaper
# T4: $0.526/hr → $0.15/hr
# Trade-off: Puede interrumpirse

2. Modelo más pequeño

# BGE-large: 1024 dims, 30ms
# BGE-small: 384 dims, 8ms
# Trade-off: -1 punto MTEB, +4x faster

3. Model quantization (FP16)

# FP32 → FP16
# - 2x menos VRAM (puedes usar GPU más barato)
# - 1.5x más rápido
# Trade-off: Minimal precision loss

Decision Framework

Elegir API (OpenAI) si:

✅ Queries/mes < 100M
✅ No tienes DevOps team
✅ Prototipado rápido
✅ Presupuesto <$500/mes

Elegir Self-Hosted si:

✅ Queries/mes > 500M
✅ Tienes DevOps in-house
✅ Latencia crítica (<20ms)
✅ Privacidad crítica (GDPR, HIPAA)
✅ Presupuesto fijo (no variable)

Ejercicios

Ejercicio 1: Calcular costo OpenAI

Tu RAG system tiene:

• 500K queries/mes
• 80 tokens promedio/query

¿Cuánto cuesta con OpenAI 3-small y 3-large?

queries_per_month = 500_000
tokens_per_query = 80

# 3-small
total_tokens = queries_per_month * tokens_per_query
cost_small = (total_tokens / 1_000_000) * 0.020
print(f"3-small: ${cost_small:.2f}/mes")  # $0.80/mes

# 3-large
cost_large = (total_tokens / 1_000_000) * 0.130
print(f"3-large: ${cost_large:.2f}/mes")  # $5.20/mes

Ejercicio 2: Break-even analysis

Calcular break-even entre OpenAI 3-small y self-hosted (TCO $400/mes):

# TCO self-hosted: $400/mes
# OpenAI 3-small: $0.020/1M tokens
# Assumptions: 50 tokens/query

# ¿A cuántos queries/mes hace sentido self-hosting?

tco_selfhosted = 400  # USD/mes
openai_cost_per_1m_tokens = 0.020
tokens_per_query = 50

# Costo por query (OpenAI)
cost_per_query = (tokens_per_query / 1_000_000) * openai_cost_per_1m_tokens
print(f"Costo por query: ${cost_per_query:.8f}")  # $0.000001

# Break-even
break_even_queries = tco_selfhosted / cost_per_query
print(f"Break-even: {break_even_queries/1_000_000:.0f}M queries/mes")

Resumen

Qué aprendiste:

• ✅ API cost: Variable, escala con uso
• ✅ Self-hosted TCO: Fijo, incluye GPU + maintenance
• ✅ Break-even: ~200-500M queries/mes (depende de assumptions)
• ✅ Hidden costs: Maintenance, downtime, testing
• ✅ Optimizations: Caching (API), spot instances (self-hosted)

Conceptos clave:

1. OpenAI → Low-to-medium volume (<100M/mes)
2. Self-hosted → High volume (>500M/mes)
3. TCO incluye costos ocultos (maintenance +$300/mes)

Recursos adicionales

1. OpenAI Pricing - Actualizado
2. AWS EC2 GPU Pricing - Comparación
3. Cloud Cost Calculator - AWS, GCP, Azure

En la siguiente cápsula

Cápsula 07: Domain-Specific y Multilingual

Aprenderás:

• Domain-specific embeddings (legal, medical)
• Multilingual embeddings (100+ idiomas)
• Cuándo fine-tune vs zero-shot
• Trade-offs

De costos a especialización.

Módulo 3 - Embeddings Deep Dive Guide Cost analysis: cuándo API, cuándo self-hosted