vLLM vs TGI (Text Generation Inference): Comparativa de Rendimiento, PagedAttention y Throughput para Producción

1. La Crisis del Servicio Tradicional de LLMs: El Desperdicio del KV Cache

Antes de la aparición de vLLM y TGI, desplegar modelos generativos utilizando servidores web tradicionales acoplados a PyTorch o la librería transformers básica de Hugging Face generaba una ineficiencia presupuestaria insostenible. En la inferencia autoregresiva, cada token generado necesita consultar los estados de atención de todos los tokens precedentes, almacenados en el KV Cache (Key-Value Cache).

En implementaciones ingenuas, los sistemas reservaban un bloque contiguo de VRAM equivalente a la longitud máxima de contexto que el modelo soportaba (por ejemplo, 4.096 o 8.192 tokens) para cada petición entrante, con independencia de que el usuario solo solicitase una respuesta de 50 tokens. Esto provocaba que entre un 60% y un 80% de la memoria GPU estuviese completamente ociosa, reservada para tokens que nunca se generarían (fragmentación interna) o esperando a solicitudes futuras (fragmentación externa).

2. La Arquitectura de vLLM y el Triunfo de PagedAttention

Diseñado por investigadores de UC Berkeley, vLLM introdujo el concepto de PagedAttention, un avance que transformó la gestión de memoria en IA de la misma manera que la paginación revolucionó los sistemas operativos en los años sesenta.

En vLLM:

1. El KV Cache no se reserva de forma continua. Se divide en pequeñas páginas lógicas de tamaño fijo (por ejemplo, páginas que almacenan 16 tokens cada una).
2. Las páginas se ubican en bloques de memoria física no contiguos en la VRAM de la GPU.
3. Una tabla de páginas gestionada a nivel de software mapea las direcciones virtuales de los tokens con los bloques físicos de memoria.
4. Cuando una petición finaliza o genera un nuevo token, solo se asigna o libera una página diminuta de memoria, reduciendo el desperdicio a menos del 4% del total de la VRAM.

Además, PagedAttention habilita una característica prodigiosa llamada Copy-on-Write para decodificación paralela. Si varias peticiones comparten un prompt idéntico (por ejemplo, un System Prompt largo o técnicas de muestreo como beam search o parallel sampling), todas las solicitudes comparten las mismas páginas de memoria de solo lectura. Solo cuando una de ellas genera un token divergente se copia esa página específica, multiplicando la capacidad de usuarios concurrentes.

3. La Arquitectura de Text Generation Inference (TGI): Robustez en Rust y C++

Desarrollado y mantenido activamente por Hugging Face, TGI (Text Generation Inference) fue concebido desde sus cimientos como una solución de ingeniería de software robusta y resiliente para alimentar los servicios de inferencia comercial de Hugging Face Hub.

A diferencia de vLLM (que combina Python para la orquestación y CUDA para los kernels), TGI implementa una arquitectura desacoplada:

• Router y Servidor Web en Rust: El frontal que recibe las conexiones HTTP/gRPC, gestiona el streaming SSE (Server-Sent Events), valida esquemas de entrada y orquesta las colas de peticiones está escrito íntegramente en Rust, garantizando cero sobrecarga de garbage collection y un consumo mínimo de CPU.
• Backend de Ejecución de Modelos en Python / C++ (FlashAttention / FlashDecoding): El motor de cómputo en GPU se comunica con el router de Rust a través de buffers de memoria compartida o gRPC de latencia ultrabaja.

4. Despliegue en Producción con Docker: Comparativa Práctica

A. Despliegue de un Servidor vLLM con Docker

vLLM ofrece una imagen oficial de Docker compatible con la API de OpenAI que puedes levantar en cuestión de segundos en cualquier servidor con GPU NVIDIA:

# Despliegue de vLLM en puerto 8000 sirviendo Meta-Llama-3-8B-Instruct
docker run --gpus all     -p 8000:8000     --ipc=host     -v ~/.cache/huggingface:/root/.cache/huggingface     vllm/vllm-openai:latest     --model meta-llama/Meta-Llama-3-8B-Instruct     --max-model-len 8192     --gpu-memory-utilization 0.95     --tensor-parallel-size 1

Una vez levantado el contenedor, puedes consumir la API con cualquier cliente de OpenAI estándar en Python, TypeScript o curl:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-no-requerido"
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    messages=[{"role": "user", "content": "¿Por qué PagedAttention es tan eficiente?"}],
    temperature=0.2
)
print(response.choices[0].message.content)

B. Despliegue de Hugging Face TGI con Docker

TGI utiliza una sintaxis muy declarativa y automatiza la descarga de pesos directamente desde Hugging Face Hub:

# Despliegue de TGI en puerto 8080 con shm extendido
docker run --gpus all     --shm-size 1g     -p 8080:80     -v $PWD/data:/data     ghcr.io/huggingface/text-generation-inference:2.4.0     --model-id mistralai/Mistral-7B-Instruct-v0.3     --max-input-tokens 4096     --max-total-tokens 8192

5. Métricas Clave de Benchmark: TTFT y TPOT en Concurrencia Real

Al evaluar servidores de inferencia, no debes fijarte únicamente en los tokens por segundo totales. Es imperativo descomponer el rendimiento en dos métricas fundamentales:

1. Time To First Token (TTFT): El tiempo transcurrido desde que la petición llega al servidor hasta que se emite el primer token. Mide la velocidad del paso de prefill (procesamiento del prompt). Si este tiempo es elevado, los usuarios perciben la aplicación como lenta y poco reactiva.
2. Time Per Output Token (TPOT) o Inter-Token Latency (ITL): El tiempo medio necesario para generar cada token subsiguiente durante la fase de decode. En streaming, una velocidad de 30-50 ms por token equivale a una lectura humana fluida.

En pruebas de carga con 64 usuarios concurrentes enviando prompts de 1.000 tokens para generar 300 tokens de salida sobre una GPU NVIDIA A100 (80GB):

• vLLM: Mantiene un throughput medio de ~1.450 tokens/segundo totales con una latencia TPOT de 42 ms por usuario.
• TGI: Mantiene un throughput de ~1.280 tokens/segundo totales con una latencia TPOT de 46 ms por usuario.

6. Artículos Relacionados para Construir tu Arquitectura de IA

Continúa explorando la infraestructura de Inteligencia Artificial en The Calata:

• Aprende a diagnosticar cuellos de botella con la guía sobre Cómo Reducir la Latencia TTFT en APIs de Streaming.
• Compara formatos de empaquetado y compresión en Cuantización GGUF vs EXL2 vs AWQ.
• Si prefieres una solución auto-alojada simplificada, revisa Despliegue de Ollama en Linux con GPU.
• Evita bloqueos en tus pipelines de desarrollo consultando Solución al Error CUDA Out of Memory en PyTorch.