Introducción a vLLM: Optimizando el rendimiento de inferencia

vLLM es un motor de inferencia para LLMs diseñado para servir modelos a alta velocidad y bajo costo. Donde un deployment con Hugging Face Transformers puede generar 5-10 tokens/segundo en una GPU, vLLM puede alcanzar 50-100+ tokens/s con el mismo hardware, gracias a técnicas como PagedAttention (manejo eficiente del KV cache), batching dinámico continuo y soporte nativo para cuantización. Si necesitas servir un LLM en producción, vLLM es probablemente el primer lugar al que deberías mirar.

Tip Pro: vLLM no es un reemplazo de Ollama. Ollama es para desarrollo local; vLLM es para servir modelos en producción con múltiples usuarios concurrentes y alto throughput.

Contexto

Servir un LLM en producción tiene un problema de memoria: el KV cache (las claves y valores de atención de cada token) crece con el largo del prompt y el número de requests concurrentes. En implementaciones ingenuas, cada request reserva memoria para el peor caso, desperdiciando VRAM. vLLM resuelve esto con PagedAttention, inspirado en la paginación de memoria de los sistemas operativos: divide el KV cache en bloques fijos que se asignan bajo demanda, eliminando la fragmentación y permitiendo compartir memoria entre requests (útil en operaciones como beam search o parallel sampling).

El resultado es que vLLM puede servir 2-4x más requests que un motor tradicional con la misma GPU, con menor latencia y mayor throughput.

Nota: vLLM soporta modelos de Hugging Face, Tensorizer, y formatos propios. No entrena modelos — solo los sirve.

Configuración / setup

1. Instalación

pip install vllm

vLLM requiere Python 3.9+ y una GPU con CUDA 11.8+ o 12.1+. También soporta AMD ROCm y Apple Silicon (experimental).

Advertencia: vLLM descarga e instala sus propias versiones de torch y xformers. Si tienes versiones preinstaladas, es mejor instalarlo en un entorno virtual limpio para evitar conflictos.

2. Servir un modelo con un comando

# Sirve el modelo en http://localhost:8000
vllm serve mistralai/Mistral-7B-v0.1 \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 4096

Esto expone una API compatible con OpenAI en /v1/chat/completions y /v1/completions.

3. Hacer peticiones desde tu código

from openai import OpenAI
 
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="none"  # vLLM no requiere API key por defecto
)
 
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-v0.1",
    messages=[{"role": "user", "content": "¿Qué es vLLM?"}]
)
 
print(response.choices[0].message.content)

Sin cambiar nada más que el base_url, tu código de OpenAI apunta a tu servidor vLLM.

4. Configuración avanzada típica

vllm serve meta-llama/Llama-3.1-8B-Instruct \
  --tensor-parallel-size 2 \       # usa 2 GPUs
  --pipeline-parallel-size 1 \
  --gpu-memory-utilization 0.95 \  # usa el 95% de la VRAM disponible
  --max-num-seqs 256 \             # requests concurrentes máximas
  --max-model-len 8192 \           # contexto máximo en tokens
  --enforce-eager \                # evita graph compilation (debug)
  --kv-cache-dtype fp8             # cuantiza el KV cache (ahorra VRAM)

Tip Pro: --gpu-memory-utilization 0.95 es un buen default. Si ves OOM (out of memory), bájalo a 0.85. Si usas cuantización (AWQ o GPTQ), puedes subirlo a 0.98.

Ejemplos

Ejemplo 1: Servicio REST básico con streaming

from openai import OpenAI
 
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="none"
)
 
stream = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "Eres un asistente útil y conciso."},
        {"role": "user", "content": "Explícame qué es PagedAttention en 3 líneas"}
    ],
    temperature=0.7,
    max_tokens=512,
    stream=True
)
 
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Ejemplo 2: Cargar un modelo local cuantizado (AWQ)

vLLM soporta modelos cuantizados en formato AWQ y GPTQ, que ocupan menos VRAM sin perder mucha calidad:

# Descargar antes el modelo cuantizado
huggingface-cli download TheBloke/Llama-2-7B-Chat-AWQ

vllm serve TheBloke/Llama-2-7B-Chat-AWQ \
  --quantization awq \
  --dtype half

Con cuantización AWQ, un modelo de 7B que normalmente ocupa ~14GB en FP16 baja a ~4GB, permitiendo correrlo en GPUs con 6-8GB de VRAM.

Ejemplo 3: Usar vLLM desde Python directo (modo offline)

No necesitas el servidor REST. Puedes usar vLLM directamente desde tu script:

from vllm import LLM, SamplingParams
 
llm = LLM(
    model="mistralai/Mistral-7B-v0.1",
    tensor_parallel_size=1,
    gpu_memory_utilization=0.90
)
 
params = SamplingParams(
    temperature=0.8,
    top_p=0.95,
    max_tokens=256
)
 
outputs = llm.generate(
    ["¿Qué es el fine-tuning?",
     "Explica la diferencia entre RAG y fine-tuning"],
    params
)
 
for output in outputs:
    print(f"Prompt: {output.prompt}")
    print(f"Respuesta: {output.outputs[0].text}")
    print("---")

Ejemplo 4: Evaluar un modelo servido con vLLM

Como vLLM expone API compatible con OpenAI, puedes pasarle benchmarks directamente:

from openai import OpenAI
 
client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")
 
# Usar lm-eval-harness con vLLM como backend

lm_eval --model local-completions \
    --model_args model=default,base_url=http://localhost:8000/v1 \
    --tasks mmlu \
    --num_fewshot 5

Nota: vLLM también tiene una integración nativa con el framework de evaluación, pero el modo más simple es via API compatible con OpenAI.

Particularidades

Limitaciones importantes:

• Requiere GPU. vLLM no corre en CPU (a diferencia de Ollama/llama.cpp).
• Setup más complejo que Ollama. Necesitas CUDA, drivers y configuración de VRAM.
• No recomendado para una sola request. El overhead del servidor justifica su uso con múltiples requests concurrentes.
• Modelos nuevos: si un modelo usa una arquitectura no soportada, vLLM puede no cargarlo hasta que se añada soporte en una release reciente.

Tip Pro: Si estás empezando con vLLM, usa --enforce-eager la primera vez. Desactiva optimizaciones CUDA graph que pueden causar errores oscuros. Cuando todo funcione, quita el flag para mejor rendimiento.

Historia y evolución