¿Qué es vLLM y por qué debería usarlo?

vLLM es una biblioteca de inferencia y servicio de LLM de alto rendimiento desarrollada por UC Berkeley que utiliza PagedAttention para una gestión eficiente de la memoria. Ofrece un rendimiento 14-24 veces superior al de HuggingFace Transformers estándar, lo que la hace ideal para implementaciones en producción que requieren el máximo rendimiento.

¿Cómo se compara vLLM con Ollama para el alojamiento local de LLM?

vLLM destaca en escenarios de producción de alto rendimiento gracias a su superior capacidad de agrupamiento (batching) y soporte multi-GPU, mientras que Ollama ofrece una configuración más sencilla y una mejor experiencia de usuario para despliegues de un solo usuario. vLLM es ideal para servicios de API que gestionan múltiples solicitudes concurrentes, mientras que Ollama es adecuado para desarrollo local y experimentación.

¿Puedo usar vLLM con Docker?

Sí, vLLM proporciona imágenes de Docker oficiales que simplifican el despliegue. Puede ejecutar vLLM en contenedores con soporte de GPU utilizando el NVIDIA Container Toolkit. El despliegue con Docker es la opción recomendada para entornos de producción y clústeres de Kubernetes.

¿vLLM soporta el formato de la API de OpenAI?

Sí, vLLM incluye un servidor de API compatible con OpenAI de serie. Esto le permite utilizar vLLM como un reemplazo directo para la API de OpenAI en aplicaciones existentes sin necesidad de modificar el código, lo que hace que la migración sea transparente.

¿Qué hardware requiere vLLM?

vLLM requiere GPUs NVIDIA con soporte CUDA (capacidad de cómputo 7.0 o superior). Se necesitan al menos 16 GB de VRAM para modelos de 7B, 24 GB o más para modelos de 13B y 40 GB o más para modelos de 30B o superiores. No se admite la inferencia solo con CPU; vLLM está optimizado específicamente para la aceleración por GPU.

¿Cómo instalo vLLM?

Instale vLLM mediante pip con «pip install vllm» para sistemas GPU con CUDA 11.8+. Para otras versiones de CUDA, utilice las ruedas específicas del repositorio de vLLM. Los usuarios de Docker pueden obtener la imagen oficial con «docker pull vllm/vllm-openai:latest».

¿Qué es PagedAttention en vLLM?

PagedAttention es la técnica de optimización de memoria de vLLM, inspirada en la paginación de memoria virtual de los sistemas operativos. Reduce el desperdicio de memoria por fragmentación en un factor de 4, lo que permite tamaños de lote más grandes y un mayor throughput. Esta innovación es clave para las ventajas de rendimiento de vLLM.

¿Puede vLLM manejar múltiples modelos simultáneamente?

vLLM se centra en el despliegue eficiente de un único modelo con el máximo rendimiento. Para el despliegue de múltiples modelos, se deben implementar varias instancias de vLLM o utilizar herramientas de orquestación. Esta decisión de diseño permite el superior rendimiento de vLLM en despliegues de tráfico intenso con un solo modelo.

¿Dónde puedo comparar vLLM con Ollama y otras opciones de alojamiento de LLM?

Nuestro resumen sobre el alojamiento de LLM compara vLLM con Ollama, Docker Model Runner, LocalAI y proveedores de la nube, incluidos los compromisos en términos de coste, rendimiento e infraestructura.

¿Cuándo debería elegir vLLM sobre las APIs de LLM en la nube?

La guía de alojamiento de LLM explica cuándo utilizar vLLM (alto rendimiento y control autoadministrado) en comparación con las API en la nube, y cómo se comparan en términos de costo y complejidad operativa.

Inicio rápido de vLLM: Servicio de LLM de alto rendimiento - en 2026

Inferencia rápida de LLM con la API de OpenAI

Índice

vLLM es un motor de inferencia y servicio de alto rendimiento y eficiente en memoria para Modelos de Lenguaje Grande (LLMs) desarrollado por el Sky Computing Lab de la UC Berkeley.

Con su algoritmo revolucionario PagedAttention, vLLM logra un rendimiento 14-24 veces mayor que los métodos de servicio tradicionales, convirtiéndolo en la opción preferida para implementaciones de LLM en producción. Para ver cómo vLLM se posiciona entre Ollama, Docker Model Runner, LocalAI y proveedores en la nube, incluyendo compensaciones de costo e infraestructura, consulte LLM Hosting: Infraestructura Local, Autoalojada y en la Nube Comparada.

¿Qué es vLLM?

vLLM (LLM virtual) es una biblioteca de código abierto para inferencia y servicio rápido de LLM que se ha convertido rápidamente en el estándar de la industria para implementaciones en producción. Lanzado en 2023, introdujo PagedAttention, una técnica de gestión de memoria innovadora que mejora drásticamente la eficiencia del servicio.

Características Principales

Rendimiento de Alto Rendimiento: vLLM ofrece un rendimiento 14-24 veces mayor en comparación con HuggingFace Transformers utilizando el mismo hardware. Esta ganancia masiva de rendimiento proviene del procesamiento por lotes continuo, kernels CUDA optimizados y el algoritmo PagedAttention que elimina la fragmentación de memoria.

Compatibilidad con la API de OpenAI: vLLM incluye un servidor API integrado que es totalmente compatible con el formato de OpenAI. Esto permite una migración perfecta de OpenAI a infraestructura autoalojada sin cambiar el código de la aplicación. Simplemente apunte su cliente API al extremo de vLLM y funcionará de manera transparente.

Algoritmo PagedAttention: La innovación central detrás del rendimiento de vLLM es PagedAttention, que aplica el concepto de paginación de memoria virtual a los mecanismos de atención. En lugar de asignar bloques de memoria contiguos para las cachés KV (lo que conduce a fragmentación), PagedAttention divide la memoria en bloques de tamaño fijo que se pueden asignar bajo demanda. Esto reduce el desperdicio de memoria hasta en 4 veces y permite tamaños de lote mucho más grandes.

Procesamiento por Lotes Continuo: A diferencia del procesamiento por lotes estático donde se espera a que todas las secuencias se completen, vLLM utiliza procesamiento por lotes continuo (rotativo). Tan pronto como una secuencia termina, se puede agregar una nueva al lote. Esto maximiza la utilización de la GPU y minimiza la latencia para las solicitudes entrantes.

Soporte Multi-GPU: vLLM soporta paralelismo de tensor y paralelismo de pipeline para distribuir modelos grandes entre múltiples GPUs. Puede servir eficientemente modelos que no caben en la memoria de una sola GPU, soportando configuraciones de 2 a 8+ GPUs.

Amplio Soporte de Modelos: Compatible con arquitecturas de modelos populares incluyendo LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma, y muchos otros. Soporta tanto modelos ajustados por instrucciones como modelos base desde HuggingFace Hub.

Cuándo Usar vLLM

vLLM destaca en escenarios específicos donde sus fortalezas brillan:

Servicios API de Producción: Cuando necesita servir un LLM a muchos usuarios concurrentes vía API, el alto rendimiento y el eficiente procesamiento por lotes de vLLM lo convierten en la mejor opción. Las empresas que ejecutan chatbots, asistentes de código o servicios de generación de contenido se benefician de su capacidad para manejar cientos de solicitudes por segundo.

Cargas de Trabajo de Alta Concurrencia: Si su aplicación tiene muchos usuarios simultáneos haciendo solicitudes, el procesamiento por lotes continuo y PagedAttention de vLLM permiten servir a más usuarios con el mismo hardware en comparación con las alternativas.

Optimización de Costos: Cuando los costos de GPU son una preocupación, el superior rendimiento de vLLM significa que puede servir el mismo tráfico con menos GPUs, reduciendo directamente los costos de infraestructura. La eficiencia de memoria 4x de PagedAttention también permite usar instancias de GPU más pequeñas y baratas.

Implementaciones en Kubernetes: El diseño sin estado y la arquitectura amigable con contenedores de vLLM lo hacen ideal para clústeres de Kubernetes. Su rendimiento consistente bajo carga y la gestión de recursos sencilla se integran bien con infraestructura nativa en la nube.

Cuándo NO Usar vLLM: Para desarrollo local, experimentación o escenarios de usuario único, herramientas como Ollama o llama.cpp proporcionan una mejor experiencia de usuario con una configuración más simple. La complejidad de vLLM se justifica cuando necesita sus ventajas de rendimiento para cargas de trabajo de producción.

Cómo Instalar vLLM

Prerrequisitos

Antes de instalar vLLM, asegúrese de que su sistema cumpla con estos requisitos:

GPU: GPU NVIDIA con capacidad de cómputo 7.0+ (V100, T4, A10, A100, H100, serie RTX 20/30/40)
CUDA: Versión 11.8 o superior
Python: 3.8 a 3.11
VRAM: Mínimo 16GB para modelos de 7B, 24GB+ para 13B, 40GB+ para modelos más grandes
Controlador: Controlador NVIDIA 450.80.02 o más reciente

Instalación vía pip

El método de instalación más simple es usando pip. Esto funciona en sistemas con CUDA 11.8 o superior:

# Crear un entorno virtual (recomendado)
python3 -m venv vllm-env
source vllm-env/bin/activate

# Instalar vLLM
pip install vllm

# Verificar instalación
python -c "import vllm; print(vllm.__version__)"

Para sistemas con diferentes versiones de CUDA, instale la rueda apropiada:

# Para CUDA 12.1
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# Para CUDA 11.8
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Instalación con Docker

Docker proporciona el método de implementación más fiable, especialmente para producción:

# Descargar la imagen oficial de vLLM
docker pull vllm/vllm-openai:latest

# Ejecutar vLLM con soporte GPU
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

La bandera --ipc=host es importante para configuraciones multi-GPU ya que habilita la comunicación interproceso adecuada.

Construir desde el Código Fuente

Para las últimas características o modificaciones personalizadas, construya desde el código fuente:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

Guía de Inicio Rápido de vLLM

Ejecutando su Primer Modelo

Inicie vLLM con un modelo usando la interfaz de línea de comandos:

# Descargar y servir Mistral-7B con API compatible con OpenAI
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM descargará automáticamente el modelo desde HuggingFace Hub (si no está en caché) e iniciará el servidor. Verá una salida indicando que el servidor está listo:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

Hacer Solicitudes API

Una vez que el servidor esté en ejecución, puede hacer solicitudes usando el cliente Python de OpenAI o curl:

Usando curl:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Explique qué es vLLM en una oración:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

Usando el Cliente Python de OpenAI:

from openai import OpenAI

# Apuntar a su servidor vLLM
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM no requiere autenticación por defecto
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Explique qué es vLLM en una oración:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

API de Completiones de Chat:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "¿Qué es PagedAttention?"}
    ],
    max_tokens=200
)

print(response.choices[0].message.content)

Configuración Avanzada

vLLM ofrece numerosos parámetros para optimizar el rendimiento:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # Usar 95% de la memoria GPU
    --max-model-len 8192 \            # Longitud máxima de secuencia
    --tensor-parallel-size 2 \        # Usar 2 GPUs con paralelismo de tensor
    --dtype float16 \                 # Usar precisión FP16
    --max-num-seqs 256                # Tamaño máximo de lote

Parámetros Clave Explicados:

--gpu-memory-utilization: Cuánta memoria GPU usar (0.90 = 90%). Valores más altos permiten lotes más grandes pero dejan menos margen para picos de memoria.
--max-model-len: Longitud máxima de contexto. Reducir esto ahorra memoria para lotes más grandes.
--tensor-parallel-size: Número de GPUs para dividir el modelo.
--dtype: Tipo de datos para pesos (float16, bfloat16 o float32). FP16 suele ser óptimo.
--max-num-seqs: Número máximo de secuencias a procesar en un lote.

vLLM vs Ollama

vLLM está diseñado para servicio de producción de alto rendimiento y multiusuario con procesamiento por lotes continuo, PagedAttention y soporte multi-GPU. Ollama optimiza para configuración local rápida, conveniencia de usuario único y gestión de modelos simple.

Para una guía de decisión detallada que cubra señales de migración, pasos de planificación, configuración de Docker Compose y una lista de verificación práctica, consulte Ollama a vLLM: Cuándo Migrar su Servidor LLM Local.

vLLM vs Docker Model Runner

Docker introdució recientemente Model Runner (anteriormente GenAI Stack) como su solución oficial para despliegue de modelos de IA local. ¿Cómo se compara con vLLM?

Filosofía de Arquitectura

Docker Model Runner pretende ser el “Docker para IA”: una forma simple y estandarizada de ejecutar modelos de IA localmente con la misma facilidad que ejecutar contenedores. Abstrae la complejidad y proporciona una interfaz consistente entre diferentes modelos y frameworks.

vLLM es un motor de inferencia especializado enfocado únicamente en el servicio de LLM con máximo rendimiento. Es una herramienta de nivel inferior que se contenedoriza con Docker, en lugar de una plataforma completa.

Configuración y Inicio

La instalación de Docker Model Runner es directa para usuarios de Docker:

docker model pull llama3:8b
docker model run llama3:8b

Esta similitud con el flujo de trabajo de imágenes de Docker lo hace instantáneamente familiar para los desarrolladores que ya usan contenedores.

vLLM requiere más configuración inicial (Python, CUDA, dependencias) o el uso de imágenes Docker preconstruidas:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <nombre-modelo>

Características de Rendimiento

vLLM ofrece un rendimiento superior para escenarios multiusuario debido a PagedAttention y el procesamiento por lotes continuo. Para servicios API de producción que manejan cientos de solicitudes por segundo, las optimizaciones de vLLM proporcionan un rendimiento 2-5 veces mejor que los enfoques de servicio genéricos.

Docker Model Runner se enfoca en la facilidad de uso en lugar del rendimiento máximo. Es adecuado para desarrollo local, pruebas y cargas de trabajo moderadas, pero no implementa las optimizaciones avanzadas que hacen que vLLM destaque a escala.

Soporte de Modelos

Docker Model Runner proporciona una biblioteca de modelos curada con acceso de un comando a modelos populares. Soporta múltiples frameworks (no solo LLMs) incluyendo Stable Diffusion, Whisper y otros modelos de IA, haciéndolo más versátil para diferentes cargas de trabajo de IA.

vLLM se especializa en inferencia de LLM con soporte profundo para modelos de lenguaje basados en transformadores. Soporta cualquier LLM compatible con HuggingFace pero no se extiende a otros tipos de modelos de IA como generación de imágenes o reconocimiento de voz.

Despliegue en Producción

vLLM ha sido probado en producción en empresas como Anthropic, Replicate y muchas otras que sirven billones de tokens diariamente. Sus características de rendimiento y estabilidad bajo carga pesada lo convierten en el estándar de facto para el servicio de LLM en producción.

Docker Model Runner es más nuevo y se posiciona más para escenarios de desarrollo y pruebas locales. Aunque podría servir tráfico de producción, carece del historial probado y las optimizaciones de rendimiento que requieren las implementaciones de producción.

Ecosistema de Integración

vLLM se integra con herramientas de infraestructura de producción: operadores de Kubernetes, métricas de Prometheus, Ray para servicio distribuido y extensa compatibilidad con la API de OpenAI para aplicaciones existentes.

Docker Model Runner se integra naturalmente con el ecosistema de Docker y Docker Desktop. Para equipos ya estandarizados en Docker, esta integración proporciona una experiencia cohesiva pero menos características especializadas de servicio de LLM.

Cuándo Usar Cada Uno

Use vLLM para:

Servicios API de LLM de producción
Despliegues de alto rendimiento y multiusuario
Despliegues en la nube sensibles al costo que necesitan máxima eficiencia
Entornos Kubernetes y nativos en la nube
Cuando necesita escalabilidad y rendimiento probados

Use Docker Model Runner para:

Desarrollo y pruebas locales
Ejecutar varios tipos de modelos de IA (no solo LLMs)
Equipos fuertemente invertidos en el ecosistema Docker
Experimentación rápida sin configuración de infraestructura
Fines de aprendizaje y educación

Enfoque Híbrido: Muchos equipos desarrollan con Docker Model Runner localmente por conveniencia, luego despliegan con vLLM en producción por rendimiento. Las imágenes de Docker Model Runner también pueden usarse para ejecutar contenedores vLLM, combinando ambos enfoques.

Mejores Prácticas para Despliegue en Producción

Despliegue con Docker

Cree una configuración de Docker Compose lista para producción:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

Despliegue en Kubernetes

Despliegue vLLM en Kubernetes para escala de producción:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Monitoreo y Observabilidad

vLLM expone métricas de Prometheus para monitoreo:

import requests

# Obtener métricas
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Métricas clave para monitorear:

vllm:num_requests_running - Solicitudes activas
vllm:gpu_cache_usage_perc - Utilización de caché KV
vllm:time_to_first_token - Métrica de latencia
vllm:time_per_output_token - Velocidad de generación

Ajuste de Rendimiento

Optimice la Utilización de Memoria GPU: Comience con --gpu-memory-utilization 0.90 y ajuste según el comportamiento observado. Valores más altos permiten lotes más grandes pero arriesgan errores de memoria agotada durante picos de tráfico.

Ajuste la Longitud Máxima de Secuencia: Si su caso de uso no necesita la longitud de contexto completa, reduzca --max-model-len. Esto libera memoria para lotes más grandes. Por ejemplo, si solo necesita contexto de 4K, establezca --max-model-len 4096 en lugar de usar el máximo del modelo (a menudo 8K-32K).

Elija Cuantización Apropiada: Para modelos que lo soporten, use versiones cuantizadas (8-bit, 4-bit) para reducir memoria y aumentar rendimiento:

--quantization awq  # Para modelos cuantizados AWQ
--quantization gptq # Para modelos cuantizados GPTQ

Habilite el Caché de Prefijo: Para aplicaciones con prompts repetidos (como chatbots con mensajes del sistema), habilite el caché de prefijo:

--enable-prefix-caching

Esto almacena en caché los valores KV para prefijos comunes, reduciendo el cómputo para solicitudes que comparten el mismo prefijo de prompt.

Solución de Problemas Comunes

Errores de Memoria Agotada

Síntomas: El servidor se bloquea con errores de memoria agotada de CUDA.

Soluciones:

Reduzca --gpu-memory-utilization a 0.85 o 0.80
Disminuya --max-model-len si su caso de uso lo permite
Baje --max-num-seqs para reducir el tamaño del lote
Use una versión de modelo cuantizada
Habilite el paralelismo de tensor para distribuir entre más GPUs

Bajo Rendimiento

Síntomas: El servidor maneja menos solicitudes de lo esperado.

Soluciones:

Aumente --max-num-seqs para permitir lotes más grandes
Suba --gpu-memory-utilization si tiene margen
Verifique si la CPU es el cuello de botella con htop – considere CPUs más rápidas
Verifique la utilización de GPU con nvidia-smi – debería ser 95%+
Habilite FP16 si está usando FP32: --dtype float16

Tiempo de Primer Token Lento

Síntomas: Alta latencia antes de que comience la generación.

Soluciones:

Use modelos más pequeños para aplicaciones críticas en latencia
Habilite el caché de prefijo para prompts repetidos
Reduzca --max-num-seqs para priorizar latencia sobre rendimiento
Considere la decodificación especulativa para modelos compatibles
Optimice la configuración de paralelismo de tensor

Fallos en Carga de Modelo

Síntomas: El servidor falla al iniciar, no puede cargar el modelo.

Soluciones:

Verifique que el nombre del modelo coincida exactamente con el formato de HuggingFace
Compruebe la conectividad de red a HuggingFace Hub
Asegúrese de tener espacio en disco suficiente en ~/.cache/huggingface
Para modelos restringidos, establezca la variable de entorno HF_TOKEN
Intente descargar manualmente con huggingface-cli download <modelo>

Características Avanzadas

Decodificación Especulativa

vLLM soporta decodificación especulativa, donde un modelo de borrador más pequeño propone tokens que un modelo objetivo más grande verifica. Esto puede acelerar la generación de 1.5 a 2 veces. Para una guía completa sobre métodos de decodificación especulativa — modelos de borrador, EAGLE-3, P-EAGLE y n-gram — consulte Decodificación Especulativa: Inferencia Más Rápida Sin Pérdida de Calidad.

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

Adaptadores LoRA

Sirva múltiples adaptadores LoRA sobre un modelo base sin cargar múltiples modelos completos:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./ruta/a/adapter-sql \
                   code-lora=./ruta/a/adapter-code

Luego especifique qué adaptador usar por solicitud:

response = client.completions.create(
    model="sql-lora",  # Usar el adaptador SQL
    prompt="Convierte esto a SQL: Muéstrame todos los usuarios creados este mes"
)

Servicio Multi-LoRA

El servicio multi-LoRA de vLLM permite alojar docenas de adaptadores ajustados con mínimo sobrecosto de memoria. Esto es ideal para servir variantes de modelos específicas de cliente o tarea:

# Solicitud con adaptador LoRA específico
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "Escribe consulta SQL"}],
    extra_body={"lora_name": "sql-lora"}
)

Caché de Prefijo

Habilite el caché de prefijo automático para evitar recomputar el caché KV para prefijos de prompt repetidos:

--enable-prefix-caching

Esto es particularmente efectivo para:

Chatbots con prompts del sistema fijos
Aplicaciones RAG con plantillas de contexto consistentes
Prompts de aprendizaje de pocos ejemplos repetidos entre solicitudes

El caché de prefijo puede reducir el tiempo al primer token en un 50-80% para solicitudes que comparten prefijos de prompt.

Ejemplos de Integración

Integración con LangChain

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("Explique PagedAttention en términos simples")
print(response)

Integración con LlamaIndex

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("¿Qué es vLLM?")
print(response)

Aplicación FastAPI

from fastapi import FastAPI
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

Benchmarks de Rendimiento

Los datos de rendimiento del mundo real ayudan a ilustrar las ventajas de vLLM:

Comparación de Rendimiento (Mistral-7B en GPU A100):

vLLM: ~3,500 tokens/segundo con 64 usuarios concurrentes
HuggingFace Transformers: ~250 tokens/segundo con la misma concurrencia
Ollama: ~1,200 tokens/segundo con la misma concurrencia
Resultado: vLLM proporciona una mejora de 14x sobre implementaciones básicas

Eficiencia de Memoria (LLaMA-2-13B):

Implementación estándar: 24GB VRAM, 32 secuencias concurrentes
vLLM con PagedAttention: 24GB VRAM, 128 secuencias concurrentes
Resultado: 4x más solicitudes concurrentes con la misma memoria

Latencia Bajo Carga (Mixtral-8x7B en 2xA100):

vLLM: Latencia P50 180ms, latencia P99 420ms a 100 req/s
Servicio estándar: Latencia P50 650ms, latencia P99 3,200ms a 100 req/s
Resultado: vLLM mantiene latencia consistente bajo alta carga

Estos benchmarks demuestran por qué vLLM se ha convertido en el estándar de facto para el servicio de LLM en producción donde el rendimiento importa.

Análisis de Costos

Entender las implicaciones de costo de elegir vLLM:

Escenario: Sirviendo 1M de solicitudes/día

Con Servicio Estándar:

Requerido: 8x GPUs A100 (80GB)
Costo AWS: ~$32/hora × 24 × 30 = $23,040/mes
Costo por 1M de tokens: ~$0.75

Con vLLM:

Requerido: 2x GPUs A100 (80GB)
Costo AWS: ~$8/hora × 24 × 30 = $5,760/mes
Costo por 1M de tokens: ~$0.19
Ahorro: $17,280/mes (75% de reducción)

Esta ventaja de costo crece con la escala. Las organizaciones que sirven billones de tokens mensuales ahorran cientos de miles de dólares usando el servicio optimizado de vLLM en lugar de implementaciones ingenuas.

Consideraciones de Seguridad

Autenticación

vLLM no incluye autenticación por defecto. Para producción, implemente autenticación a nivel del proxy inverso:

# Configuración de Nginx
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

O use puertas de API como Kong, Traefik o AWS API Gateway para autenticación y limitación de tasa de grado empresarial.

Aislamiento de Red

Ejecute vLLM en redes privadas, no expuesto directamente a internet:

# Ejemplo de NetworkPolicy de Kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

Limitación de Tasa

Implemente limitación de tasa para prevenir abuso:

# Ejemplo usando Redis para limitación de tasa
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    
    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # Ventana de 60 segundos
    
    if requests > 60:  # 60 solicitudes por minuto
        raise HTTPException(status_code=429, detail="Límite de tasa excedido")
    
    return await call_next(request)

Control de Acceso a Modelos

Para despliegues multi-tenant, controle qué usuarios pueden acceder a qué modelos:

ALLOWED_MODELS = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # Todos los modelos
}

def verify_model_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

Guía de Migración

De OpenAI a vLLM

Migrar de OpenAI a vLLM autoalojado es sencillo gracias a la compatibilidad de API:

Antes (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hola"}]
)

Después (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://tu-servidor-vllm.com/v1",
    api_key="tu-clave-interna"  # Si agregó autenticación
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Hola"}]
)

Solo se necesitan dos cambios: actualizar base_url y el nombre model. Todo el otro código permanece idéntico.

De Ollama a vLLM

Ollama usa un formato de API diferente. El cambio básico del lado del cliente es cambiar del extremo REST de Ollama a la API compatible con OpenAI de vLLM:

API de Ollama:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={'model': 'llama2', 'prompt': '¿Por qué el cielo es azul?'})

Equivalente vLLM:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="¿Por qué el cielo es azul?"
)

Para una guía de migración exhaustiva que cubra selección de modelos, plantillas de chat, migración escalonada y una lista de verificación práctica, consulte Ollama a vLLM: Cuándo Migrar su Servidor LLM Local.

De HuggingFace Transformers a vLLM

Migración de uso directo de Python:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Hola", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Hola", sampling_params)
result = outputs[0].outputs[0].text

La API de Python de vLLM es más simple y mucho más rápida para inferencia por lotes.

Futuro de vLLM

vLLM continúa su desarrollo rápido con características emocionantes en la hoja de ruta:

Servicio Desagregado: Separar prefill (procesamiento de prompt) y decode (generación de token) en diferentes GPUs para optimizar la utilización de recursos. Prefill está limitado por cómputo mientras que decode está limitado por memoria, por lo que ejecutarlos en hardware especializado mejora la eficiencia.

Inferencia Multi-Nodo: Distribuir modelos muy grandes (100B+ parámetros) a través de múltiples máquinas, permitiendo el servicio de modelos demasiado grandes para configuraciones de un solo nodo.

Cuantización Mejorada: Soporte para nuevos formatos de cuantización como GGUF (usado por llama.cpp) e integración mejorada de AWQ/GPTQ para mejor rendimiento con modelos cuantizados.

Mejoras en Decodificación Especulativa: Modelos de borrador más eficientes y estrategias de especulación adaptativa para lograr aceleraciones más altas sin pérdida de precisión.

Optimizaciones de Atención: FlashAttention 3, atención en anillo para contextos extremadamente largos (100K+ tokens) y otros mecanismos de atención de vanguardia.

Mejor Cobertura de Modelos: Ampliar soporte a modelos multimodales (modelos de visión-idioma), modelos de audio y arquitecturas especializadas a medida que emergen.

El proyecto vLLM mantiene un desarrollo activo con contribuciones de UC Berkeley, Anyscale y la comunidad de código abierto más amplia. A medida que el despliegue de LLM se vuelve más crítico para los sistemas de producción, el papel de vLLM como estándar de rendimiento continúa creciendo. Para una comparación más amplia de vLLM con otra infraestructura LLM local y en la nube, consulte nuestra LLM Hosting: Infraestructura Local, Autoalojada y en la Nube Comparada.

Enlaces Útiles

Recursos Externos y Documentación

Repositorio GitHub de vLLM - Repositorio oficial de vLLM con código fuente, documentación exhaustiva, guías de instalación y discusiones activas de la comunidad. Recurso esencial para estar actualizado con las últimas características y solución de problemas.
Documentación de vLLM - Documentación oficial que cubre todos los aspectos de vLLM desde la configuración básica hasta la configuración avanzada. Incluye referencias de API, guías de ajuste de rendimiento y mejores prácticas de despliegue.
Papel de PagedAttention - Papel académico que introduce el algoritmo PagedAttention que potencia la eficiencia de vLLM. Lectura esencial para entender las innovaciones técnicas detrás de las ventajas de rendimiento de vLLM.
Blog de vLLM - Blog oficial de vLLM con anuncios de lanzamientos, benchmarks de rendimiento, análisis técnicos y estudios de caso de la comunidad desde despliegues de producción.
Hub de Modelos de HuggingFace - Repositorio exhaustivo de LLMs de código abierto que funcionan con vLLM. Busque modelos por tamaño, tarea, licencia y características de rendimiento para encontrar el modelo adecuado para su caso de uso.
Documentación de Ray Serve - Documentación del framework Ray Serve para construir despliegues de vLLM escalables y distribuidos. Ray proporciona características avanzadas como autoescalado, servicio multi-modelo y gestión de recursos para sistemas de producción.
NVIDIA TensorRT-LLM - TensorRT-LLM de NVIDIA para inferencia altamente optimizada en GPUs NVIDIA. Alternativa a vLLM con estrategias de optimización diferentes, útil para comparación y entender el panorama de optimización de inferencia.
Referencia de API de OpenAI - Documentación oficial de API de OpenAI con la que la API de vLLM es compatible. Consulte esto cuando construya aplicaciones que necesitan funcionar tanto con OpenAI como con extremos vLLM autoalojados de manera intercambiable.

¿Qué es vLLM?

Características Principales

Cuándo Usar vLLM

Cómo Instalar vLLM

Prerrequisitos

Instalación vía pip

Instalación con Docker

Construir desde el Código Fuente

Guía de Inicio Rápido de vLLM

Ejecutando su Primer Modelo

Hacer Solicitudes API

Configuración Avanzada

vLLM vs Ollama

vLLM vs Docker Model Runner

Filosofía de Arquitectura

Configuración y Inicio

Características de Rendimiento

Soporte de Modelos

Despliegue en Producción

Ecosistema de Integración

Cuándo Usar Cada Uno

Mejores Prácticas para Despliegue en Producción

Despliegue con Docker

Despliegue en Kubernetes

Monitoreo y Observabilidad

Ajuste de Rendimiento

Solución de Problemas Comunes

Errores de Memoria Agotada

Bajo Rendimiento

Tiempo de Primer Token Lento

Fallos en Carga de Modelo

Características Avanzadas

Decodificación Especulativa

Adaptadores LoRA

Servicio Multi-LoRA

Caché de Prefijo

Ejemplos de Integración

Integración con LangChain

Integración con LlamaIndex

Aplicación FastAPI

Benchmarks de Rendimiento

Análisis de Costos

Escenario: Sirviendo 1M de solicitudes/día

Consideraciones de Seguridad

Autenticación

Aislamiento de Red

Limitación de Tasa

Control de Acceso a Modelos

Guía de Migración

De OpenAI a vLLM

De Ollama a vLLM

De HuggingFace Transformers a vLLM

Futuro de vLLM

Enlaces Útiles

Artículos Relacionados en Este Sitio

Recursos Externos y Documentación

Suscribirse