Despliegue con vLLM
En esta página
vLLM: el motor de inferencia recomendado
vLLM es el motor de inferencia en Python más popular para LLM. Mistral AI lo recomienda para el autoalojamiento porque es fácil de usar, ofrece un buen rendimiento y proporciona una API compatible con la de OpenAI. Recorreremos su instalación y configuración, y después cubriremos sus dos modos de uso: el modo por lotes (fuera de línea) y el modo servidor. Estos modos no son mutuamente excluyentes; muchos equipos utilizan el primero para preparar datos y el segundo para dar servicio a aplicaciones.
Qué necesitas
La descarga de modelos se realiza a través de Hugging Face, lo cual requiere un token con permiso READ:
export HF_TOKEN="hf_your_token_here"
Antes de tu primera descarga, debes aceptar las condiciones de uso en la página del modelo en Hugging Face (por ejemplo: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Se trata de un paso manual y único por cuenta. Olvidarlo provoca fallos en la descarga cuyo diagnóstico puede llevar una hora, ya que los síntomas se confunden con problemas de autenticación.
Para el entorno de Python, utiliza un virtualenv dedicado para evitar conflictos de versiones con tus otros proyectos:
# Crear un entorno virtual
python -m venv vllm-env
source vllm-env/bin/activate
# Instalar vLLM (versión >= 0.6.1.post1)
pip install vllm
Por último está el hardware, que determina qué puedes servir realmente. Mistral 7B y Nemo caben en una única GPU de 24 GB, típicamente una A10G, RTX 4090 o L4. Mixtral 8x7B requiere dos GPUs de 80 GB; en la práctica, tarjetas A100-80GB. Mistral Large 2 en su versión de pesos abiertos, con sus 123 mil millones de parámetros, necesita al menos cuatro GPUs A100-80GB. En todos los casos, instala los controladores de NVIDIA y CUDA 12.x antes que vLLM.
Modo fuera de línea: procesamiento por lotes
El modo fuera de línea gestiona lotes de peticiones sin servidor HTTP. Cargas el modelo en memoria, procesas tus peticiones y recuperas los resultados. Observa los tres argumentos tokenizer_mode, load_format y config_format: volveremos sobre ellos, no son opcionales.
from vllm import LLM
from vllm.sampling_params import SamplingParams
# Cargar el modelo con las banderas de Mistral
llm = LLM(
model="mistralai/Mistral-Nemo-Instruct-2407",
tokenizer_mode="mistral",
load_format="mistral",
config_format="mistral"
)
# Parámetros de generación
sampling = SamplingParams(
max_tokens=8192,
temperature=0.3
)
# Procesar un lote de peticiones
messages_batch = [
[{"role": "user", "content": "What is PagedAttention?"}],
[{"role": "user", "content": "Explain tensor parallelism."}],
[{"role": "user", "content": "How does the KV cache work?"}],
]
results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
print(output.outputs[0].text)
Este modo destaca en el procesamiento por lotes de documentos (resumen, clasificación), la evaluación de modelos frente a puntos de referencia, la generación de datos sintéticos y los scripts de prueba o prototipado. Siempre que nadie espere una respuesta inmediata, te beneficias de omitir la capa HTTP.
Modo servidor: exposición de una API
El modo servidor lanza un punto final HTTP compatible con la API de OpenAI:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--host 0.0.0.0 \
--port 8000
El servidor expone la API en el puerto 8000. La consecuencia práctica es significativa: una aplicación escrita para la API de OpenAI cambia a tu modelo autoalojado modificando solo dos líneas, base_url y api_key. Tus bibliotecas, marcos de agentes y herramientas de prueba siguen funcionando.
from openai import OpenAI
# Conectar al servidor vLLM local
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed" # Sin autenticación por defecto
)
response = client.chat.completions.create(
model="mistralai/Mistral-Nemo-Instruct-2407",
messages=[
{"role": "system", "content": "You are a DevOps expert."},
{"role": "user", "content": "How do I monitor a vLLM server in production?"}
],
temperature=0.3,
max_tokens=1024
)
print(response.choices[0].message.content)
El comentario # Sin autenticación por defecto merece atención: un servidor vLLM lanzado de este modo no autentica a nadie. En una máquina de desarrollo es cómodo; en una máquina accesible desde la red, es una puerta abierta. Una prueba rápida por línea de comandos confirma que todo responde antes de continuar:
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "mistralai/Mistral-Nemo-Instruct-2407",
"messages": [{"role": "user", "content": "Hello, is this working?"}],
"temperature": 0.3
}'
Despliegue con Docker
Para un despliegue reproducible, la imagen oficial evita reinstalar en cada máquina:
docker run --runtime nvidia --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
--env "HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}" \
-p 8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--load_format mistral \
--config_format mistral
Tres opciones de este comando merecen explicación. --runtime nvidia --gpus all da acceso al contenedor a las GPUs NVIDIA; sin ello, el modelo intentaría ejecutarse en CPU. El montaje -v ~/.cache/huggingface:... comparte la caché de modelos con el anfitrión, ahorrándote volver a descargar decenas de gigabytes cada vez que se reinicia el contenedor. --ipc=host otorga la memoria compartida necesaria para la comunicación entre procesos entre GPUs; omitirlo provoca caídas difíciles de diagnosticar en cuanto pasas a varias tarjetas.
Las tres banderas esenciales de Mistral
| Bandera | Propósito |
|---|---|
--tokenizer_mode mistral | Usa el tokenizador nativo de Mistral (no el de HF) |
--config_format mistral | Carga la configuración en formato Mistral |
--load_format mistral | Carga los pesos en formato nativo de Mistral |
Sin estas banderas, el modelo puede ejecutarse pero con rendimiento degradado o resultados incorrectos. Esta es la trampa más común al autoalojar Mistral: nada falla, el servidor arranca, llegan respuestas; simplemente son peores de lo que deberían ser, y corres el riesgo de concluir erróneamente que el modelo decepciona.
Ajuste del rendimiento
Cuando un modelo no cabe en una sola tarjeta, el paralelismo de tensores distribuye sus capas entre varias GPUs. El valor pasado corresponde al número de tarjetas utilizadas:
vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--tensor-parallel-size 2
La segunda palanca concierne a la proporción de memoria de GPU que reserva vLLM:
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--gpu-memory-utilization 0.9
El valor por defecto (0,9) funciona en la mayoría de los casos. Redúcelo si otros procesos usan la GPU (un servicio de visión, un notebook olvidado); de lo contrario, el primer proceso toma toda la memoria y el segundo falla al arrancar.
Por último, dos llamadas bastan para verificar que un servidor está vivo, lo que las convierte en buenas sondas para tu orquestador:
# Listar modelos disponibles
curl http://localhost:8000/v1/models
# Comprobar el estado del servidor
curl http://localhost:8000/health
Puntos clave
- vLLM expone una API compatible con OpenAI; puedes usar el SDK
openaipara comunicarte - Las tres banderas
--tokenizer_mode mistral,--config_format mistral,--load_format mistralson obligatorias - El modo fuera de línea conviene al procesamiento por lotes; el modo servidor, a las aplicaciones en tiempo real
- Docker simplifica el despliegue y garantiza la reproducibilidad
- El paralelismo de tensores permite distribuir modelos grandes entre varias GPUs