"Córrelo en local" es el equivalente tech de "siembra tu propia comida". A veces te ahorra una fortuna. La mayoría de las veces cuesta más, requiere más trabajo y da peores resultados. Pero lo sigues escuchando — en Twitter, en Reddit, de ese amigo que se armó un servidor casero. Así que dejemos las opiniones calientes y veamos números reales. 🔍
La pregunta real no es ¿debería hostear en local? Sino ¿a qué volumen el self-hosting se vuelve más barato? — y ¿los tradeoffs realmente importan para lo que estás construyendo?
Qué estamos comparando
Cloud AI significa que pagas por uso. Cada vez que tu app envía texto a Claude, GPT o Gemini, pagas por los tokens — bloques de palabras que la IA procesa, aproximadamente ¾ de una palabra en inglés. Piénsalo como un taxímetro: viajes cortos son baratos, los largos se acumulan.
IA self-hosted significa que corres un LLM open-source (large language model — el cerebro detrás de herramientas como ChatGPT) en tu propio hardware. Pagas por la máquina y la electricidad, pero cada request después de eso es gratis. Piénsalo como comprar un carro: caro al inicio, pero sin costo por viaje.
Estos son los precios actuales de cloud a marzo 2026, por millón de tokens:
| Proveedor | Modelo | Costo Input / Output |
|---|---|---|
| Anthropic | Haiku 4.5 | $1 / $5 |
| Anthropic | Sonnet 4.6 | $3 / $15 |
| Anthropic | Opus 4.6 | $5 / $25 |
| OpenAI | GPT-4o mini | $0.15 / $0.60 |
| OpenAI | GPT-4o | $2.50 / $10 |
| Gemini Flash | Tier gratuito (15 req/min) | |
| Gemini Pro | $1.25 / $5 |
Y los contendientes self-hosted: Ollama corriendo modelos open-source como Llama 3.1, Mistral o DeepSeek en tu propia máquina o un servidor GPU rentado.
El tradeoff fundamental: cloud cobra por uso, self-hosted cobra por tiempo. Con poco uso, cloud gana porque solo pagas lo que consumes. Con mucho uso, self-hosted gana porque el costo del hardware es fijo. Necesitamos encontrar el punto de cruce. 💰
Las cuentas que nadie te muestra
Costos de cloud a escala
Usando Claude Haiku 4.5 como base (el modelo cloud de calidad más barato), asumiendo un split típico de 30% input / 70% output en tokens:
| Tokens diarios | Costo mensual | Costo anual |
|---|---|---|
| 10K | $0.90 | $10.80 |
| 100K | $9 | $108 |
| 500K | $45 | $540 |
| 1M | $90 | $1,080 |
| 5M | $450 | $5,400 |
| 10M | $900 | $10,800 |
Costos de self-hosting
Opción A — hardware que ya tienes:
Si ya tienes una máquina con GPU (tarjeta gráfica que acelera las operaciones matemáticas de la IA), el único costo extra es la electricidad:
| Hardware | Modelos que puede correr | Electricidad mensual |
|---|---|---|
| 16 GB RAM, sin GPU | Modelos 7B (lento) | ~$10 |
| RTX 3090 24GB | Modelos 13B (rápido) | ~$20 |
| RTX 4090 24GB | Modelos 13B-30B (rápido) | ~$25 |
| M2/M3 Mac 32GB+ | 7B-13B (buena velocidad) | ~$5 |
"7B" y "13B" se refieren a billones de parámetros — el tamaño del modelo. Modelos más grandes son más inteligentes pero necesitan más memoria.
Opción B — rentar un servidor GPU:
| Proveedor | GPU | Costo mensual |
|---|---|---|
| Hetzner (solo CPU) | Ninguna | ~$50 |
| Vast.ai | RTX 3090 | ~$150 |
| Vast.ai | RTX 4090 | ~$250 |
| Lambda | A10G | ~$350 |
| RunPod | A100 40GB | ~$800 |
Opción C — armar un servidor casero:
| Build | Costo inicial | Mensual (en 3 años) |
|---|---|---|
| RTX 3090 usada + PC básica | ~$1,200 | ~$33 + electricidad |
| RTX 4090 + PC decente | ~$2,500 | ~$70 + electricidad |
| 2× RTX 4090 | ~$4,500 | ~$125 + electricidad |
| Mac Studio M3 Ultra 192GB | ~$6,000 | ~$167 + electricidad |
Dónde se cruzan las líneas
Cloud Haiku vs. 7B local en hardware existente:
El costo de self-hosting es ~$15/mes en electricidad. Cloud Haiku cruza ese punto en aproximadamente 5 millones de tokens al mes. Por debajo de eso — y la mayoría de los founders independientes están muy por debajo — cloud es más barato.
Cloud Haiku vs. GPU rentado (RTX 3090 a $150/mes):
Necesitas procesar 50 millones de tokens al mes antes de que el servidor rentado empate. Eso son 1.7 millones de tokens diarios — una carga de producción seria.
Para la mayoría de indie builders y equipos pequeños, la API en cloud cuesta menos que self-hosting en hardware dedicado. Punto.
La brecha de calidad
El costo es solo la mitad de la historia. Así rinden los modelos en la práctica:
| Capacidad | Cloud (Claude/GPT) | Self-hosted (7B-13B) |
|---|---|---|
| Calidad de razonamiento | Excelente | Moderada |
| Generación de código | Excelente | Buena para tareas simples |
| Ventana de contexto | 200K-1M tokens | 4K-32K típicamente |
| Velocidad | 50-100+ tok/seg | 20-40 (GPU), 5-10 (CPU) |
| Uso de herramientas | Nativo, confiable | Posible, menos confiable |
La ventana de contexto — cuánto texto puede "ver" la IA a la vez, como su memoria de trabajo — es la brecha más grande. Los modelos cloud manejan codebases enteros. Los modelos locales ven unas pocas páginas a la vez.
Llama 3.1 70B es genuinamente impresionante y competitivo en tareas generales. Pero necesita hardware GPU serio, y todavía no hay equivalente local a Opus o al GPT de gama alta para razonamiento complejo. La brecha se achicó. No se cerró.
Cuándo el self-hosting realmente tiene sentido
1. Privacidad y soberanía de datos
Si tus datos no pueden salir de tu red — historiales médicos, documentos legales, datos financieros, sistemas gubernamentales — el self-hosting no es opcional. Ningún término de servicio de API reemplaza "los datos nunca salieron de nuestro edificio".
# Ollama lo convierte en un setup de 2 minutos
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Resumir este expediente médico..."
}'
Sin request a la red. Sin logging de terceros. Cumplimiento total.
2. Entornos offline
Dispositivos edge, redes air-gapped, sitios remotos sin internet. Sin conexión no hay API — local es la única opción.
3. Tareas simples de alto volumen
Embeddings — huellas numéricas del texto usadas para búsqueda — clasificación y resúmenes de texto corto. Tareas donde un modelo pequeño es suficiente y el volumen es masivo: ⚡
import ollama
def classify_document(text: str) -> str:
response = ollama.chat(model='llama3.1:8b', messages=[
{'role': 'user', 'content': f'Clasificar: factura, contrato, recibo, carta, otro.\n\n{text[:500]}'}
])
return response['message']['content']
# 100K documentos/día:
# Costo cloud: ~$30/día
# Self-hosted: ~$0.50/día electricidad
# Ahorro mensual: ~$900
4. Apps sensibles a la latencia
Las llamadas a API agregan 100-500ms de delay por red. La inferencia local — el proceso del modelo generando una respuesta — arranca al instante:
Cloud: 150-500ms red + 500-2000ms inferencia = 650-2500ms
Local: 0ms red + 200-1000ms inferencia = 200-1000ms
Para autocompletado, traducción en vivo o herramientas interactivas, esa diferencia se nota.
5. Desarrollo y experimentación
Probar 50 variaciones de prompt en local cuesta $0. El mismo experimento en la API de Claude te sale $5-20. No es enorme, pero se acumula durante R&D intensivo.
El setup práctico (10 minutos)
Si decidiste que el self-hosting encaja en tu caso de uso:
Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama serve
ollama pull llama3.1:8b # 4.7 GB, propósito general
ollama pull codellama:13b # 7.4 GB, tareas de código
ollama pull nomic-embed-text # 274 MB, para embeddings
Usarlo como reemplazo directo
Ollama habla el mismo lenguaje que la API de OpenAI. La mayoría del código funciona sin cambios — solo cambia la URL:
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="not-needed"
)
response = client.chat.completions.create(
model="llama3.1:8b",
messages=[{"role": "user", "content": "Explica MCP en 3 oraciones"}]
)
print(response.choices[0].message.content)
Desarrolla contra modelos locales, despliega con cloud — o al revés. Mismo código, diferente URL.
Benchmarks de rendimiento
| Hardware | Tokens/seg | Respuesta de 500 tokens |
|---|---|---|
| M2 MacBook Pro 16GB | ~35 | ~14 segundos |
| RTX 3060 12GB | ~40 | ~12 segundos |
| RTX 4090 24GB | ~80 | ~6 segundos |
| Solo CPU (16 cores) | ~8 | ~60 segundos |
La inferencia solo con CPU es dolorosa para cualquier cosa interactiva. ¿Sin GPU ni Apple Silicon? Quédate con cloud.
La jugada híbrida (esta es la buena) 🚀
El setup más inteligente no es 100% cloud ni 100% self-hosted. Es rutear cada tarea al lugar correcto:
def get_ai_client(task_type: str):
if task_type in ["embedding", "classification", "simple_summary"]:
# Local — rápido, gratis, la calidad es suficiente
return OpenAI(base_url="http://localhost:11434/v1", api_key="x")
elif task_type in ["code_generation", "complex_analysis", "tool_use"]:
# Cloud — mejor calidad, vale la pena el costo
return anthropic.Anthropic()
else:
return OpenAI(base_url="http://localhost:11434/v1", api_key="x")
Corre en local: embeddings, clasificación, borradores, dev/testing. Corre en cloud: razonamiento complejo, generación de código, uso de herramientas, cualquier cosa de cara al cliente.
Ejemplo real de costos para un setup híbrido:
| Tarea | Volumen | Dónde | Costo mensual |
|---|---|---|---|
| Embeddings | 50K/día | Local | $0 |
| Clasificación | 10K/día | Local | $0 |
| Code review | 30/día | Cloud (Haiku) | $2 |
| Generación de contenido | 50/día | Cloud (Sonnet) | $15 |
| Análisis complejo | 10/día | Cloud (Sonnet) | $5 |
| Total | $22/mes |
Puro cloud para la misma carga de trabajo: ~$180/mes. El híbrido ahorra 88%.
Guía rápida de decisión
¿Procesas más de 5M tokens diarios? → Self-host las tareas de volumen, cloud para las de calidad.
¿Requisitos estrictos de privacidad de datos? → Self-host, no negociable.
¿Ya tienes hardware con GPU? → Híbrido: local para lo simple, cloud para lo complejo.
¿Ninguno de los anteriores? → Solo cloud. Es lo más barato y te da los mejores modelos.
Para la mayoría de los founders independientes a marzo 2026: arranca con cloud. Claude Haiku a $1/$5 por millón de tokens es tan barato que hostear en local para ahorrar es como sembrar tu propio trigo para ahorrarte el pan. El hardware cuesta más que años de uso de API a los volúmenes típicos de un founder. 💰
La excepción: tienes requisitos de privacidad o ya tienes un GPU. Entonces instala Ollama, corre Llama 3.1 para tareas en bulk, y llama a Claude para los problemas difíciles. Ese híbrido recorta costos 80%+ manteniendo la calidad donde importa. Todo lo demás es over-engineering. 🦝
