Módulo 8: Tu Primer Diseño de Sistema AI
4. Trade-Offs de Diseño: Costo vs Latencia vs Calidad
Descripción
Realidad: No existe diseño "perfecto". Siempre hay trade-offs (compromises).
3 dimensiones principales:
- Costo: ¿Cuánto $ por request?
- Latencia: ¿Cuánto tarda en responder?
- Calidad: ¿Qué tan buena es la respuesta?
El "trilema": No puedes maximizar las 3 simultáneamente.
- Máxima calidad (GPT-4) → alto costo, alta latencia.
- Mínimo costo (GPT-3.5) → menor calidad.
- Mínima latencia (cache) → respuestas estáticas (menor calidad personalizada).
En esta cápsula vas a entender trade-offs comunes y cómo tomar decisiones.
Dimensión 1: Costo
Qué Impacta el Costo
Factores:
- Modelo: GPT-4 ($0.03/1K input) vs GPT-3.5 ($0.0005/1K input) → 60× diferencia.
- Volumen: 1K requests/mes vs 1M requests/mes.
- Longitud de prompts: Prompts largos (1K tokens) vs cortos (100 tokens).
- Longitud de respuestas: max_tokens=100 vs max_tokens=1000.
- Patrón: Chatbot simple (1 call) vs RAG (embeddings + LLM call) vs Agents (múltiples calls).
Trade-Off: GPT-4 vs GPT-3.5
Ejemplo: Chatbot de FAQ
| Aspecto | GPT-4 | GPT-3.5 |
|---|---|---|
| Calidad | Muy alta (reasoning superior) | Alta (suficiente para FAQ) |
| Costo/request | $0.006 (200 input, 200 output) | $0.0002 (30× más barato) |
| Costo/mes (10K requests) | $60 | $2 |
Decisión:
- Si FAQ simple (respuestas directas) → GPT-3.5 (suficiente).
- Si FAQ complejo (reasoning) → GPT-4.
Trade-Off: Cloud API vs Self-Hosted
Ejemplo: 1M requests/mes
| Aspecto | Cloud (GPT-4 API) | Self-Hosted (Llama 3 70B) |
|---|---|---|
| Costo | $6,000/mes (variable) | $1,500/mes GPU (fijo) |
| Calidad | Muy alta (GPT-4) | Alta (Llama 3 70B ~80% de GPT-4) |
| Setup | 5 minutos | 1-3 días |
Decisión:
- Si volumen bajo (<100K requests/mes) → Cloud API (más barato).
- Si volumen alto (>1M requests/mes) → Self-hosted (4× más barato).
Dimensión 2: Latencia
Qué Impacta la Latencia
Factores:
- LLM: API call (200-500ms) vs self-hosted local (50-200ms).
- Patrón: Chatbot simple (1 call, <1s) vs RAG (embed + search + LLM, 1-3s) vs Agents (múltiples calls, 3-10s).
- max_tokens: 100 tokens (rápido) vs 1000 tokens (lento).
- Cache: Hit (instant) vs Miss (API call).
- Network: US-based API call desde LATAM (300ms) vs US (100ms).
Trade-Off: Calidad vs Latencia
Ejemplo: RAG System
| Aspecto | RAG con GPT-4 | Chatbot simple con GPT-3.5 |
|---|---|---|
| Latencia | 2-3s (embed + search + LLM) | <1s (solo LLM) |
| Calidad | Muy alta (info específica de docs) | Media (info general) |
Decisión:
- Si usuario tolera 2-3s y necesita info específica → RAG.
- Si usuario necesita respuesta instant (<1s) y FAQ general → Chatbot simple.
Trade-Off: GPT-4 vs Cache
Ejemplo: FAQ repetitivo
| Aspecto | GPT-4 (cada request) | Cache (respuesta pre-generada) |
|---|---|---|
| Latencia | 500ms (API call) | <50ms (Redis lookup) |
| Calidad | Personalizada (contexto usuario) | Estática (misma respuesta siempre) |
| Costo | $0.006/request | $0 (gratis después de primera generación) |
Decisión:
- Si pregunta frecuente ("¿Qué es AI?") y respuesta no cambia → Cache.
- Si pregunta personalizada ("¿Cómo puedo mejorar mi código?") → GPT-4.
Dimensión 3: Calidad
Qué Impacta la Calidad
Factores:
- Modelo: GPT-4 (mejor reasoning) vs GPT-3.5 (suficiente para simple).
- Prompt engineering: System prompt claro vs vago.
- RAG: Con docs (info específica) vs sin docs (info general).
- Fine-tuning: Modelo adaptado a caso específico vs modelo base.
- Temperature: Baja (determinista) vs alta (creativa pero inconsistente).
Trade-Off: Calidad vs Costo
Ejemplo: Clasificador de Tickets
| Aspecto | GPT-4 | GPT-3.5 |
|---|---|---|
| Accuracy | 95% | 90% |
| Costo/request | $0.002 | $0.00005 (40× más barato) |
| Costo/mes (100K tickets) | $200 | $5 |
Decisión:
- Si accuracy crítica (ej. clasificación médica) → GPT-4.
- Si accuracy 90% aceptable (ej. tickets de soporte) → GPT-3.5 (40× más barato).
Trade-Off: Calidad vs Latencia (Agents)
Ejemplo: Agent vs RAG
| Aspecto | Agent (multi-tool) | RAG (single retrieval) |
|---|---|---|
| Calidad | Muy alta (reasoning multi-step) | Alta (single-step retrieval) |
| Latencia | 5-10s (múltiples calls) | 2-3s (1 call) |
| Costo | Alto (múltiples LLM calls) | Medio (1 LLM call) |
Decisión:
- Si tarea compleja (multi-step reasoning) → Agent (usuario tolera 10s).
- Si tarea simple (Q&A) → RAG (2-3s suficiente).
El Trilema: No Puedes Tener Todo
Visualización:
Calidad Alta
/\
/ \
/ \
/ \
/ \
Costo Bajo ---- Latencia Baja
Realidad:
- Alta calidad + Baja latencia → Alto costo (GPT-4, sin cache).
- Alta calidad + Bajo costo → Alta latencia (self-hosted Llama 3, no optimizado).
- Baja latencia + Bajo costo → Menor calidad (cache de respuestas estáticas).
Estrategias de Optimización
1. Multi-Model Strategy
Problema: Usar GPT-4 para todo (caro).
Solución:
- GPT-3.5 para tareas simples (80% de requests) → $2/10K.
- GPT-4 para tareas complejas (20% de requests) → $12/10K.
- Total: $14/10K (vs $60/10K con GPT-4 puro → ahorro 75%).
2. Cache Inteligente
Problema: FAQ repetitivos gastan tokens.
Solución:
- Primera vez: GPT-4 genera respuesta → guarda en cache (Redis).
- Segunda vez (misma pregunta): Retorna desde cache (instant, gratis).
- Ahorro: 90% de costo en preguntas frecuentes.
3. Prompt Optimization
Problema: Prompts largos (1K tokens) gastan $.
Solución:
- Prompt conciso (200 tokens) → ahorro 80%.
- Few-shot examples (solo 2-3, no 10).
4. Batch Processing
Problema: 1M requests individuales (overhead alto).
Solución:
- Batch 100 requests en 1 call (ej. clasificación).
- Ahorro: 50% de costo (menos overhead).
Casos de Uso Reales
Caso 1: Startup MVP (Presupuesto Limitado)
Requisitos:
- Chatbot de FAQ.
- Presupuesto: $50/mes.
- Volumen: 5K requests/mes.
Decisión:
- Modelo: GPT-3.5-turbo (suficiente para FAQ).
- Cache: Redis para preguntas frecuentes (70% de requests).
- Costo: $10/mes (OpenAI) + $10/mes (hosting) = $20/mes.
Trade-off aceptado: Calidad ligeramente inferior a GPT-4 (pero 20× más barato).
Caso 2: Empresa (Alto Volumen, Calidad Crítica)
Requisitos:
- Q&A sobre documentación técnica.
- Volumen: 500K requests/mes.
- Accuracy crítica (>95%).
Decisión:
- Patrón: RAG (docs externos).
- Modelo: GPT-4 (accuracy >95%).
- Vector DB: Pinecone (cloud, escalable).
- Cache: Redis para queries frecuentes (30% de requests).
- Costo: $3K/mes (OpenAI) + $200/mes (Pinecone) + $100/mes (hosting) = $3.3K/mes.
Trade-off aceptado: Alto costo (pero accuracy crítica para negocio).
Caso 3: Startup con Datos Sensibles
Requisitos:
- Chatbot interno (datos confidenciales).
- Volumen: 50K requests/mes.
- HIPAA compliance (datos no pueden salir de infra).
Decisión:
- Self-hosted: Llama 3 (70B) en servidores propios.
- Vector DB: Chroma (local).
- Costo: $1,500/mes (GPU) + $200/mes (hosting) = $1.7K/mes.
Trade-off aceptado: Costo fijo alto (pero privacidad garantizada).
Por Qué Importa para un AI Engineer
1. Decisiones informadas
Product Manager: "¿Por qué no usamos GPT-4 para todo?"
AI Engineer (sin entender trade-offs): "Ok, usamos GPT-4."
AI Engineer (con entender trade-offs): "GPT-4 cuesta $60/10K requests. GPT-3.5 cuesta $2/10K. Para FAQ simple, GPT-3.5 suficiente. Ahorro: 30×. Recomiendo multi-model strategy."
2. Optimización continua
Monitoring: "80% de costo va a GPT-4 en preguntas simples."
Acción: Migrar preguntas simples a GPT-3.5 → ahorro 70%.
Resumen
3 dimensiones:
- Costo: GPT-4 (caro) vs GPT-3.5 (30× más barato).
- Latencia: Chatbot simple (<1s) vs RAG (2-3s) vs Agents (5-10s).
- Calidad: GPT-4 (alta) vs GPT-3.5 (suficiente para simple).
El trilema: No puedes maximizar las 3 simultáneamente.
Estrategias de optimización:
- Multi-model strategy (GPT-3.5 para simple, GPT-4 para complejo).
- Cache inteligente (FAQ frecuentes → Redis).
- Prompt optimization (prompts concisos).
- Batch processing (múltiples requests en 1 call).
Decisiones basadas en:
- Presupuesto (¿cuánto puedes gastar?).
- Volumen (¿1K o 1M requests/mes?).
- Accuracy requerida (¿90% o 95%?).
- Latencia tolerada (¿<1s o 5s ok?).
Próximo paso: Cápsula 05: Caso de Estudio — Diseño completo de Q&A system (paso a paso).