Cuándo la inferencia local de LLM supera a las APIs en la nube: privacidad, latencia y factura fija
La inferencia local de modelos de lenguaje supera a las APIs comerciales siempre que una organización procesa más de 150 millones de tokens mensuales, exige residencia estricta de datos bajo GDPR o necesita un Time to First Token (TTFT) determinista inferior a 100 ms. En lugar de pagar tarifas variables por token, el alquiler de servidores GPU bare-metal fija el gasto en una cuota mensual predecible.
Servicios como GPT-4o o Claude 3.5 Sonnet imponen tres fricciones operativas para plataformas SaaS y fintech: límites de peticiones (RPM/TPM), retención de datos por terceros y actualizaciones silenciosas de pesos que rompen validadores JSON. Desplegar modelos abiertos como Llama 3.3 70B, Qwen 2.5 32B o Mistral Small 24B dentro de una VPC privada elimina por completo la dependencia externa.
No obstante, por debajo de 30 millones de tokens al mes, una GPU dedicada permanece inactiva más del 90% del tiempo y resulta menos rentable que el pago por uso en la nube.
Fórmula de cálculo de VRAM para pesos, cuantización (FP16, INT8, AWQ) y KV-Cache
La memoria de vídeo (VRAM) constituye el principal cuello de botella en producción, ya que los pesos de la red y la caché dinámica Key-Value (KV-Cache) deben residir simultáneamente en la GPU. Superar la VRAM física obliga a descargar capas a la RAM por PCIe, reduciendo la velocidad entre 10 y 20 veces.
Los ingenieros dimensionan los nodos mediante esta fórmula:
VRAM Total (GB) = (Parámetros_B × Bytes_por_Peso) + (Tokens_Contexto × Usuarios_Simultáneos × Factor_KV) + 2.5 GB CUDA
- FP16 / BF16 (2 bytes por parámetro): Precisión completa base. Un modelo 70B ocupa 140 GB solo en pesos estáticos, exigiendo dos GPUs A100 80GB o H100 80GB.
- INT8 / FP8 (1 byte por parámetro): Reduce a la mitad la memoria requerida sin degradación perceptible en arquitecturas Hopper (H100) y Ada Lovelace (L40S).
- AWQ / GPTQ 4-bit (0,5 bytes por parámetro): Comprime los pesos un 75% (aprox. 0,55 GB por cada mil millones de parámetros), permitiendo alojar un modelo 70B en una sola L40S 48GB o dos RTX 4090.
El KV-Cache crece linealmente con el contexto y la concurrencia: atender 32 peticiones simultáneas con ventana de 8.192 tokens en un modelo 32B consume entre 10 y 14 GB adicionales de VRAM.
| Tamaño del modelo | Precisión / Formato | Pesos en VRAM | KV-Cache (16 sesiones, 8k ctx) | Configuración GPU recomendada | Alquiler mensual est. (2026) |
|---|---|---|---|---|---|
| 8B (Llama 3.1 / Qwen 2.5) | FP16 (16-bit) | 16,0 GB | 4,2 GB | 1x RTX 4090 (24 GB) | $180 – $240 |
| 8B (Llama 3.1 / Qwen 2.5) | AWQ (4-bit) | 5,5 GB | 4,2 GB | 1x L4 (24 GB) o RTX 4000 Ada | $140 – $190 |
| 32B (Qwen 2.5 / DeepSeek R1 Distill) | AWQ (4-bit) | 19,5 GB | 8,5 GB | 1x NVIDIA L40S (48 GB) | $450 – $560 |
| 70B (Llama 3.3 / Qwen 2.5) | AWQ (4-bit) | 39,0 GB | 12,0 GB | 2x RTX 4090 (48 GB) o 1x A100 80GB | $420 – $950 |
| 70B (Llama 3.3) | FP8 (8-bit) | 70,0 GB | 14,0 GB | 2x L40S (96 GB) o 1x H100 80GB | $980 – $1.450 |
| 405B (Llama 3.1) | FP8 (8-bit) | 405,0 GB | 48,0 GB | 8x H100 80GB (nodo NVLink) | $9.500 – $12.000 |
Benchmarks de motores de inferencia en producción: vLLM, TensorRT-LLM, SGLang y Ollama
La elección del motor de inferencia impacta más que actualizar la tarjeta gráfica: vLLM y SGLang ofrecen entre 3 y 4,5 veces mayor rendimiento concurrente que Ollama sobre el mismo hardware. Los motores tradicionales reservan bloques contiguos para el contexto máximo, desperdiciando hasta un 60% de VRAM.
Los servidores productivos emplean PagedAttention (paginación virtual del KV-Cache) y Continuous Batching (inserción dinámica de peticiones en ciclos activos de GPU). SGLang añade RadixAttention para reutilizar prompts de sistema compartidos sin recomputar.
| Motor de inferencia | Rendimiento (32B AWQ en L40S, 16 pet.) | Mediana TTFT (ms) | Continuous Batching | PagedAttention / RadixCache | Caso de uso óptimo |
|---|---|---|---|---|---|
| vLLM (v0.6+) | 480 – 540 tok/s | 65 ms | Sí (nativo) | PagedAttention + Prefix Caching | APIs multiusuario compatibles con OpenAI |
| SGLang | 530 – 610 tok/s | 52 ms | Sí (nativo) | RadixAttention (reutilización directa) | Agentes RAG con prompts de sistema largos |
| TensorRT-LLM | 590 – 660 tok/s | 45 ms | Sí (In-flight) | Paged KV-Cache | Máxima velocidad en clústeres H100 / FP8 |
| Ollama (llama.cpp) | 110 – 145 tok/s | 180 ms | Limitado | Asignación estática KV | Estaciones locales y uso monousuario |
Punto de equilibrio financiero: cuántos millones de tokens diarios amortizan una GPU dedicada
Un servidor GPU alquilado por $490 al mes alcanza su punto de equilibrio frente a APIs comerciales de gama media en unos 6,5 millones de tokens diarios (195 millones mensuales). Por encima de este volumen, el coste marginal por token tiende a cero.
Analicemos un caso real de TCO en 2026 para un SaaS B2B de clasificación documental y soporte automatizado (80% tokens de entrada, 20% de salida):
- Línea base API Cloud (GPT-4o / Claude 3.5 Sonnet): A $2,50 por 1M de entrada y $10,00 por 1M de salida, el promedio ponderado es $4,00 por 1M de tokens. Con 15M diarios (450M/mes), la factura asciende a $1.800/mes.
- Servidor GPU propio (1x NVIDIA L40S 48GB): Alquiler fijo de $490/mes ejecutando Qwen 2.5 32B AWQ con vLLM. A 500 tokens/s sostenidos procesa más de 43M diarios, por lo que 450M/mes usan solo el 34% de capacidad.
- Coste unitario real: $490 / 450M tokens = $1,09 por 1M de tokens (ahorro del 72,7%, equivalente a $1.310/mes o $15.720 anuales).
Añadiendo 4 horas mensuales de mantenimiento DevOps ($300/mes), el coste total sube a $790/mes y sitúa el umbral en 197,5M tokens/mes (~6,6M/día). Comprueba tu ratio exacto en la calculadora de economía unitaria IA.
Arquitectura híbrida LLM Router y errores frecuentes de despliegue
Implementar un enrutador semántico (LLM Router) que envíe el 80% de las consultas rutinarias a un modelo local 8B–32B y escale solo el razonamiento complejo a APIs en la nube reduce la factura total entre un 70% y un 78% sin perder calidad. Pasarelas como LiteLLM Proxy evalúan la complejidad en menos de 5 ms.
Al migrar hacia GPUs propias, los equipos suelen cometer cuatro errores costosos:
- Subestimar el cuello de botella PCIe: Dividir un modelo 70B entre dos RTX 4090 sin NVLink introduce entre un 15% y un 25% de latencia por sincronización de tensores.
- Exceder la longitud de contexto configurada: Fijar
--max-model-len 32768cuando el promedio es 2.000 tokens reserva KV-Cache innecesario y provoca colas bajo picos de tráfico. - Dejar el puerto 8000 sin autenticación: Exponer el servicio sin proxy inverso ni tokens Bearer facilita el secuestro inmediato de cómputo.
- Operar producción en VPS virtualizados compartidos: La contención en PCIe y CPU steal time degradan la latencia; consulta nuestra comparativa entre servidor dedicado y VPS.
Lista de verificación técnica para desplegar vLLM seguro en Docker con monitorización
Un nodo vLLM en producción requiere aislamiento de contenedores, controladores fijados y telemetría antes de recibir tráfico real:
- Fijar controladores y Container Toolkit: Instala el driver NVIDIA 550+ y
nvidia-container-toolkiten Ubuntu 24.04 LTS, verificando la GPU connvidia-smidentro del contenedor. - Descargar pesos localmente: Guarda el modelo cuantizado AWQ/FP8 en volumen NVMe local fijando el hash de commit de Hugging Face para evitar fallos de red al reiniciar.
- Ajustar parámetros de memoria vLLM: Lanza la imagen
vllm/vllm-openaicon--gpu-memory-utilization 0.90,--enable-prefix-cachingy un--max-model-lenrealista. - Proteger con Reverse Proxy y TLS 1.3: Vincula vLLM a
127.0.0.1:8000detrás de Nginx, Caddy o LiteLLM con límite de peticiones y claves API. - Conectar Prometheus y Grafana: Recolecta métricas desde
/metricscon alertas cuandovllm:gpu_cache_usage_percsupere el 85%. - Configurar respaldo automático en la nube: Programa un failover en la capa de agentes de IA de soporte y ventas si el TTFT supera 1.500 ms.