vLLM: Inferencia de alto rendimiento para servidores

Qué cubre este artículo

• Qué es vLLM y cuándo usarlo en lugar de Ollama o llama.cpp.
• Cómo PagedAttention y Continuous Batching mejoran el rendimiento.
• Instalación paso a paso e inicio de un servidor vLLM.
• Llamadas a la API compatible con OpenAI con ejemplos prácticos.
• Optimización de rendimiento, requisitos de hardware y trampas comunes.

Introducción: vLLM explicado

¿Ejecutas un LLM local y necesitas ofrecerlo a varios usuarios simultáneamente? Rápidamente descubrirás las limitaciones de herramientas diseñadas para solicitudes individuales. vLLM llena exactamente este vacío. Es un motor de inferencia diseñado específicamente para alto rendimiento y baja latencia en hardware de servidor.

vLLM fue presentado en 2023 por investigadores de UC Berkeley y rápidamente se convirtió en el estándar para desplegar LLMs en producción. La idea central: utilizar la costosa VRAM de la GPU de la manera más eficiente posible, permitiendo procesar muchas solicitudes en paralelo.

¿Por qué necesito vLLM?

Imagina que ejecutas un chatbot interno para un equipo de 50 personas. Cada empleado hace preguntas, a menudo simultáneamente. Con una solución simple como Ollama, las solicitudes se procesan una tras otra. Con 10 usuarios concurrentes, los últimos esperan minutos su respuesta.

vLLM resuelve este problema. Procesa docenas de solicitudes en paralelo en una GPU, sin que cada una tenga que reservar el caché KV completo. El resultado: mayor rendimiento, tiempos de espera más cortos, usuarios más satisfechos.

Escenarios típicos para vLLM:

• Chatbot de producción para equipos o clientes.
• Backend API para múltiples aplicaciones simultáneamente.
• Procesamiento por lotes de grandes volúmenes de texto.
• Distribución de carga entre múltiples GPUs con Tensor Parallelism.

Si solo experimentas localmente con un modelo, llama.cpp u Ollama son mejores opciones. vLLM muestra su potencial bajo carga.

vLLM en pocas palabras

vLLM es una biblioteca Python y motor de inferencia que ejecuta grandes modelos de lenguaje en GPUs. Proporciona una API compatible con OpenAI, permitiéndote seguir usando clientes y bibliotecas existentes sin cambios. El enfoque está en la eficiencia: más tokens por segundo con el mismo presupuesto de hardware.

¿Para quién es vLLM?

vLLM está dirigido a desarrolladores y operadores que ponen LLMs en producción. Si tienes una GPU en un servidor y necesitas servir múltiples usuarios o aplicaciones, vLLM es la opción correcta. Para principiantes que solo experimentan localmente, es excesivo y más complejo de configurar que Ollama.

Requisitos principales:

• Una GPU NVIDIA o AMD con suficiente VRAM.
• Linux como sistema operativo, Windows solo mediante WSL2.
• Conocimientos básicos de Python y línea de comandos.
• Comprensión de memoria de GPU y cuantización.

Términos importantes en torno a vLLM

Término	Explicación
vLLM	Motor de inferencia para alto rendimiento en GPUs
PagedAttention	Gestión de memoria para el caché KV, similar a memoria virtual en el sistema operativo
Continuous Batching	Las solicitudes se inyectan dinámicamente en lotes en ejecución, sin esperar a que se complete todo el lote
Throughput	Número de tokens procesados por segundo en todas las solicitudes
Latency	Tiempo hasta que llegan los primeros tokens de una solicitud individual
OpenAI API	Interfaz HTTP compatible que corresponde a los puntos finales de OpenAI
Tensor Parallelism	División de un modelo entre múltiples GPUs
Cuantización	Reducción de la precisión de pesos para ahorrar VRAM
KV-Cache	Búfer para claves y valores durante la generación de texto
QPS	Queries Per Second, medida del número de solicitudes procesadas por segundo

Qué hace especial a vLLM

PagedAttention para memoria eficiente

El caché KV es el mayor consumidor de memoria en la inferencia. Sin optimización, vLLM reserva para cada solicitud un bloque de memoria contiguo dimensionado para la longitud de secuencia máxima posible. Esto genera un desperdicio enorme porque la mayoría de solicitudes son mucho más cortas.

PagedAttention lo resuelve dividiendo el caché KV en bloques pequeños (pages), similar a cómo un sistema operativo gestiona memoria virtual. Una solicitud solo ocupa tantos pages como realmente necesita. Cuando la secuencia crece, se asignan nuevos pages. Esto reduce el desperdicio de memoria a menos del 4 por ciento.

Continuous Batching para alto rendimiento

El batching clásico espera a que terminen todas las solicitudes de un lote antes de iniciar el siguiente. Una solicitud larga bloquea todas las cortas en el mismo lote. Continuous Batching añade nuevas solicitudes dinámicamente en cada paso y elimina las completadas inmediatamente. La GPU se mantiene continuamente ocupada.

Ambas técnicas juntas permiten a vLLM multiplicar significativamente el rendimiento comparado con inferencia ingenua. Las mediciones frecuentemente muestran de 2 a 4 veces mayor rendimiento frente a HuggingFace Transformers con el mismo modelo y hardware.

Instalación

vLLM requiere una GPU NVIDIA compatible con CUDA o una GPU AMD compatible con ROCm. Encontrarás detalles sobre la decisión de hardware en el artículo sobre CPU vs GPU.

Requisitos:

• Linux (Ubuntu 20.04 o más reciente recomendado)
• GPU NVIDIA con Compute Capability 7.0 o superior
• CUDA 12.1 o más reciente
• Python 3.9 a 3.12

Instalación mediante pip:

pip install vllm

Para GPUs AMD usa el índice adicional:

pip install vllm --extra-index-url https://download.pytorch.org/whl/rocm6.2

Después de la instalación, verifica que vLLM reconoce la GPU:

python -c "import vllm; print(vllm.__version__)"

Iniciar el servidor

vLLM incluye un servidor integrado que proporciona una API compatible con OpenAI. El inicio se realiza mediante un módulo Python:

python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 8000 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192

Argumentos importantes:

Argumento	Significado
--model	Nombre del modelo en HuggingFace o ruta local
--host	Interfaz de red, 0.0.0.0 para acceso externo
--port	Puerto del servidor, estándar 8000
--gpu-memory-utilization	Proporción de VRAM que vLLM puede usar, estándar 0.9
--max-model-len	Longitud máxima de contexto en tokens
--tensor-parallel-size	Número de GPUs para Tensor Parallelism
--quantization	Método de cuantización, p. ej. awq o gptq

El primer inicio carga el modelo en VRAM e inicializa el caché KV. Esto tarda entre segundos y minutos dependiendo del tamaño del modelo.

Usar la API

Una vez que el servidor está en ejecución, lo consultas como la API de OpenAI. Una solicitud de chat simple con curl:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer token-abc123" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Erkläre PagedAttention in drei Sätzen."}
    ],
    "temperature": 0.7
  }'

La respuesta sigue el formato conocido de OpenAI:

{
  "id": "chat-abc123",
  "object": "chat.completion",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "PagedAttention teilt den KV-Cache in kleine Blöcke auf..."
      }
    }
  ]
}

También se soporta el punto final de completions:

curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "prompt": "Die Hauptstadt von Frankreich ist",
    "max_tokens": 5
  }'

Listar modelos:

curl http://localhost:8000/v1/models

En Python usas la biblioteca oficial openai con una URL base personalizada:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "Was ist Continuous Batching?"}]
)
print(response.choices[0].message.content)

Optimización de rendimiento

Tensor Parallelism

Cuando un modelo no cabe en una única GPU, puedes distribuirlo entre varias. Establece --tensor-parallel-size con el número de GPUs disponibles:

python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-70B-Instruct \
  --tensor-parallel-size 4 \
  --gpu-memory-utilization 0.9

Las GPUs deben estar bien conectadas mediante NVLink o PCIe, de lo contrario la comunicación se convierte en un cuello de botella. Más detalles sobre la importancia de la velocidad de conexión en el artículo sobre Speicherbandbreite.

GPU Memory Utilization

El parámetro --gpu-memory-utilization controla cuánta memoria VRAM puede reservar vLLM. El valor por defecto 0.9 significa el 90 por ciento. En un servidor con 24 GB de VRAM, esto equivale a aproximadamente 21,6 GB para pesos del modelo y KV-Cache.

Reduce este valor si otros procesos necesitan VRAM. Auméntalo solo si vLLM es la única aplicación usando la GPU.

Max Model Length

--max-model-len limita el número máximo de tokens por solicitud. Un valor mayor permite contextos más largos, pero reserva más memoria para el KV-Cache. Elige el valor más pequeño que tu caso de uso necesite.

Quantisierung

La cuantización reduce significativamente el tamaño del modelo y el consumo de VRAM. vLLM soporta AWQ, GPTQ y otros métodos:

python -m vllm.entrypoints.openai.api_server \
  --model TheBloke/Llama-3.1-8B-Instruct-AWQ \
  --quantization awq

Un modelo de 8B en FP16 requiere alrededor de 16 GB de VRAM. Con cuantización AWQ, la necesidad cae a unos 6 GB, lo que permite su uso en GPUs más pequeñas.

vLLM vs. Ollama vs. llama.cpp

Característica	vLLM	Ollama	llama.cpp
Caso de uso principal	Producción, Multi-usuario	Experimentos locales	Inferencia eficiente en recursos
Rendimiento (Multi-usuario)	Muy alto	Medio	Bajo a medio
Facilidad de instalación	Media	Muy fácil	Fácil
Soporte de GPU	NVIDIA, AMD	NVIDIA, AMD, Mac	NVIDIA, AMD, CPU
Continuous Batching	Sí	Limitado	No
OpenAI API	Sí, nativo	Sí, mediante compatibilidad	Mediante servidor externo
Inferencia en CPU	No	Sí	Sí
Ideal para	Servidores, equipos	Usuarios individuales	Hardware de bajo rendimiento

La decisión depende de tu caso de uso. Para un servidor productivo con muchos usuarios, vLLM es la mejor opción. Para pruebas locales rápidas, Ollama. Para sistemas solo CPU, llama.cpp. Más información sobre la comparación de enfoques en el artículo LLM lokal betreiben.

Ejemplo: servidor vLLM para un equipo

Una configuración práctica para un pequeño equipo con una GPU NVIDIA de 24 GB de VRAM.

Paso 1: crear un entorno virtual.

python -m venv vllm-env
source vllm-env/bin/activate
pip install vllm

Paso 2: elegir un modelo cuantizado que quepa en tu VRAM. Para 24 GB, un modelo de 8B en AWQ es adecuado.

Paso 3: iniciar el servidor con valores por defecto razonables.

python -m vllm.entrypoints.openai.api_server \
  --model casperhansen/llama-3-8b-instruct-awq \
  --quantization awq \
  --host 0.0.0.0 \
  --port 8000 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 4096 \
  --api-key token-team-2026

Paso 4: configurar el servidor como servicio systemd para que se inicie automáticamente después del reinicio.

# /etc/systemd/system/vllm.service
[Unit]
Description=vLLM Server
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu
ExecStart=/home/ubuntu/vllm-env/bin/python -m vllm.entrypoints.openai.api_server --model casperhansen/llama-3-8b-instruct-awq --quantization awq --host 0.0.0.0 --port 8000 --gpu-memory-utilization 0.85 --max-model-len 4096 --api-key token-team-2026
Restart=on-failure

[Install]
WantedBy=multi-user.target

Activar e iniciar:

sudo systemctl daemon-reload
sudo systemctl enable vllm
sudo systemctl start vllm

Paso 5: distribuir el endpoint de API en tu equipo. Cada uno utiliza la URL base http://server-ip:8000/v1 con la clave API proporcionada.

Errores comunes con vLLM

1. VRAM insuficiente. Un modelo de 70B en FP16 requiere más de 140 GB de VRAM. Antes de iniciar, verifica que el modelo quepa en la memoria disponible y utiliza cuantización si es necesario.

2. Versión de CUDA incorrecta. vLLM requiere CUDA 12.1 o más reciente. Una instalación de CUDA desactualizada produce errores crípticos al importar. Verifica con nvcc --version.

3. Windows sin WSL2. vLLM no funciona de forma nativa en Windows. Usa WSL2 con Ubuntu, de lo contrario la instalación fallará.

4. Tensor Parallelism sin NVLink. Múltiples GPUs sin conexión rápida ralentizan drásticamente el rendimiento. Verifica la conexión con nvidia-smi nvlink -s.

5. API-key olvidada. Sin --api-key, el servidor acepta solicitudes sin autenticación. En producción, esto es un riesgo de seguridad.

6. Max Model Length demasiado alto. Un valor de 128000 reserva enormes pools de KV-Cache y deja poco espacio para los pesos del modelo. Reduce el valor al mínimo real.

7. Modelo sin formato de chat. Un modelo base sin instruction-tuning produce resultados deficientes en el endpoint de chat. Elige siempre versiones Instruct o Chat.

8. Las descargas simultáneas bloquean el inicio. En el primer inicio, vLLM descarga el modelo de HuggingFace. Con conexiones lentas, esto puede tomar mucho tiempo. Descarga el modelo previamente con huggingface-cli e indica la ruta local.

Hardware, costos y seguridad en vLLM

Hardware

vLLM requiere obligatoriamente una GPU. Para configuraciones iniciales, una NVIDIA RTX 4090 con 24 GB de VRAM es suficiente. Para modelos más grandes, necesitas GPUs de servidor como la A100 o H100 con 40 a 80 GB de VRAM, posiblemente múltiples unidades para Tensor Parallelism.

Costos

La GPU es el mayor factor de costo. Una RTX 4090 usada cuesta alrededor de 1000 euros. Un servidor en la nube con A100 cuesta varios cientos de euros al mes. Ten en cuenta los costos de electricidad, una RTX 4090 consume alrededor de 450 vatios bajo carga. Más información sobre la selección de hardware en el artículo Was ist lokale KI?.

Seguridad

Siempre establece una clave API con --api-key. No expongas el servidor a internet sin reglas de firewall. Usa un proxy inverso como Nginx con TLS si haces accesible el endpoint fuera de tu red. Registra los accesos para detectar abusos.

Enlaces adicionales e información sobre vLLM

• vLLM GitHub Repository con documentación y ejemplos.
• vLLM Paper: Efficient Memory Management for LLM Serving with PagedAttention para los fundamentos científicos.
• HuggingFace Model Hub para encontrar modelos compatibles.
• Übersicht lokaler KI-Software en BotServ.de.

FAQ: vLLM, preguntas frecuentes

¿Qué es vLLM?

vLLM es un motor de inferencia para modelos de lenguaje grandes en GPUs. Optimiza el rendimiento y el uso de memoria mediante PagedAttention y Continuous Batching.

¿Es vLLM gratuito?

Sí, vLLM es código abierto bajo la licencia Apache-2.0 y es gratuito. Los costos surgen solo del hardware y la electricidad.

¿Puedo usar vLLM en CPU?

No, vLLM requiere una GPU con CUDA o ROCm. Para inferencia en CPU, usa llama.cpp.

¿Necesito múltiples GPUs para vLLM?

No, una GPU es suficiente para modelos que caben en su VRAM. Necesitas múltiples GPUs solo para modelos grandes o mayor rendimiento.

¿Cuál es la diferencia entre vLLM y Ollama?

vLLM está optimizado para producción y alto rendimiento, Ollama para uso local simple. Para escenarios multiusuario, vLLM es la mejor opción.

¿Soporta vLLM la API de OpenAI?

Sí, vLLM incluye un servidor que implementa nativamente los endpoints de OpenAI para chat completions y completions.

¿Qué modelos funcionan con vLLM?

Todos los modelos en formato HuggingFace que vLLM soporta. Incluyen Llama, Mistral, Qwen, Phi y muchos más. También se soportan variantes cuantizadas AWQ y GPTQ.

¿Cuánta memoria VRAM necesito para vLLM?

Al menos tanta como requieren los pesos del modelo, más espacio para el KV-Cache. Un modelo de 8B en FP16 requiere alrededor de 16 GB, con AWQ unos 6 GB. Reserva espacio para el KV-Cache.

¿Puedo usar vLLM en Windows?

Solo mediante WSL2 con Ubuntu. No hay soporte nativo de Windows.

¿Qué es PagedAttention?

PagedAttention es la gestión de memoria de vLLM para el KV-Cache. Divide el cache en pequeños bloques, similar a la memoria virtual en sistemas operativos, reduciendo significativamente el desperdicio.

¿Funciona vLLM con GPUs AMD?

Sí, vLLM soporta GPUs AMD mediante ROCm. La instalación requiere el índice ROCm adicional en pip.

¿Cómo inicio vLLM automáticamente después de reiniciar?

Configura un servicio systemd que ejecute el servidor vLLM al iniciar el sistema. Encontrarás un ejemplo en la sección de configuración del equipo.

Fuentes y lecturas complementarias

• Kwon, W. et al. (2023): Efficient Memory Management for Large Language Model Serving with PagedAttention. arXiv:2309.06180.
• vLLM Project: Documentación oficial, repositorio en GitHub.
• NVIDIA: CUDA Toolkit Documentation.
• HuggingFace: Model Hub y documentación de Transformers.