Ir al contenido principal
Español— Elegir un idioma
Menú

Despliegue local de Devstral con vLLM

Lección 13 de 14 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Preparación del despliegue
  2. Lo que tu hardware permite
  3. Instalación de vLLM
  4. Inicio del servidor
  5. Adaptación del comando a tu máquina
  6. Conexión con Vibe y verificación
  7. Los tres problemas que encontrarás
  8. Puntos clave

Lección actualizada el 2 de noviembre de 2026 basándose en la página Using offline models de la documentación de Vibe. Devstral se ha eliminado de la API de Mistral, pero sus pesos siguen publicados: Devstral Small 2 y Mistral Small 4 son los dos modelos abiertos recomendados para uso local. Vibe no incluye un modelo local: debes conectarlo a un servidor compatible con OpenAI mediante una configuración predefinida en config.toml y cambiar entre ellos usando /model. Fuente: Using offline models.

Preparación del despliegue

Desplegar Devstral localmente implica ejecutar un servidor de inferencia en tu máquina que exponga una API compatible con OpenAI. Vibe se conecta a él exactamente igual que si estuviera hablando con la nube de Mistral. Esta compatibilidad de interfaz hace que el cambio sea transparente; tus herramientas no tienen por qué saber de dónde provienen las respuestas. El marco de trabajo recomendado para esta función es vLLM, un motor de inferencia de alto rendimiento desarrollado por la comunidad de código abierto.

Lo que tu hardware permite

Antes de instalar nada, comprueba tu GPU. Esta determina la precisión utilizable y, en consecuencia, el tamaño de la ventana de contexto del que dispondrás.

Configuración GPU VRAM Precisión Contexto
Recomendada NVIDIA H100 / A100 80 GB FP8 ~128K tokens
Alternativa RTX 4090 / RTX 6000 24–48 GB 4 bits (cuantizado) ~32K tokens
Solo CPU Sin GPU 64+ GB RAM - Lento (no recomendado)

Nota importante: La configuración solo con CPU es funcional, pero extremadamente lenta para un modelo de 24B. Solo sirve para pruebas, no para el uso diario. Dicho de otro modo, te permite verificar que la cadena funciona, pero no que puedas trabajar con ella.

Instalación de vLLM

El requisito de software es mínimo: Python 3.10 o superior, seguido de una instalación mediante pip.

# Se requiere Python 3.10+
python3 --version

# Instalar vLLM
pip install vllm

A continuación, verifica que los controladores de NVIDIA y CUDA estén instalados y operativos. Este comando es la mejor prueba integral: si muestra tu GPU y una versión de CUDA, la capa de bajo nivel está sana y cualquier error posterior provendrá de otro lugar.

nvidia-smi
# Debe mostrar tu GPU y la versión de CUDA

Inicio del servidor

El comando de arranque cabe en cuatro argumentos, dos de los cuales son esenciales para trabajar con Vibe.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --port 8080

Desglosemos las opciones:

  • mistralai/Devstral-Small-2-24B-Instruct-2512: El modelo de Hugging Face que se va a cargar.
  • --tool-call-parser mistral: Habilita el análisis de llamadas a herramientas en formato Mistral.
  • --enable-auto-tool-choice: Permite que el modelo elija sus herramientas automáticamente.
  • --port 8080: El puerto de escucha del servidor.

Las dos opciones relacionadas con las herramientas merecen atención. Sin ellas, el servidor respondería a tus preguntas, pero el modelo ya no podría leer un archivo ni ejecutar un comando. Vibe se convertiría en un simple chatbot, lo cual no es el objetivo.

Adaptación del comando a tu máquina

Si tienes varias GPU, el paralelismo de tensores distribuye el modelo entre todas las tarjetas. La VRAM combinada permite entonces una ventana de contexto más amplia.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --tensor-parallel-size 2 \
  --port 8080

En una configuración más modesta, necesitas reducir la precisión. Una H100 o A100 maneja FP8; una RTX 4090 utilizará cuantización de 4 bits con AWQ, a costa de una ligera pérdida de calidad que se compensa ampliamente por el hecho de que el modelo finalmente cabe en memoria.

# FP8 en H100/A100
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --dtype float16 \
  --port 8080

# 4 bits en RTX 4090
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --quantization awq \
  --port 8080

La última palanca cuando la VRAM sigue siendo insuficiente es reducir la longitud máxima del contexto. La caché de atención consume memoria proporcionalmente al contexto, y bajar a 16.384 tokens suele liberar lo que faltaba para arrancar.

vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 16384 \
  --port 8080

Conexión con Vibe y verificación

El servidor está en ejecución; ahora debes indicar a Vibe que lo utilice. Vibe no incluye un modelo local: declara un proveedor y una configuración predefinida de modelo en config.toml.

# ~/.vibe/config.toml
active_model = "devstral-local"

[[providers]]
name = "local"
api_base = "http://localhost:8080/v1"
api_style = "openai"
backend = "generic"

[[models]]
name = "mistralai/Devstral-Small-2-24B-Instruct-2512"
provider = "local"
alias = "devstral-local"

Mantén active_model encima de la primera tabla [[...]]; de lo contrario, TOML la adjuntará a esa tabla. Establece max_context_length en la configuración predefinida para indicar el contexto de tu servidor, que también debe devolver el uso en tokens en las respuestas en streaming (stream_options.include_usage). Variante más corta: Vibe proporciona un proveedor predefinido, llamacpp, que apunta a http://127.0.0.1:8080/v1 sin clave; en ese caso, escribe provider = "llamacpp" en la configuración predefinida, sin un bloque [[providers]]. En una sesión, /model alterna entre el modelo local y los modelos alojados.

Prueba la cadena en dos niveles: primero la API en bruto, lo que confirma que el modelo está cargado, y luego una solicitud real en Vibe para validar que las llamadas a herramientas funcionan.

# Prueba directa de la API
curl http://localhost:8080/v1/models

# Prueba en Vibe (el agente ask solicita confirmación antes de cada herramienta)
vibe --agent ask
> List files in the current directory

Para el uso diario, reiniciar manualmente el comando rápidamente se vuelve tedioso. Un servicio de systemd inicia el servidor al arrancar y lo reinicia en caso de fallo.

# Crear un servicio de systemd
sudo tee /etc/systemd/system/vllm-devstral.service << EOF
[Unit]
Description=vLLM Devstral Server
After=network.target

[Service]
Type=simple
User=$USER
ExecStart=/usr/local/bin/vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 --tool-call-parser mistral --enable-auto-tool-choice --port 8080
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable --now vllm-devstral

Los tres problemas que encontrarás

Un error CUDA out of memory significa que el modelo no cabe: reduce --max-model-len o cambia a cuantización de 4 bits. La lentitud en el primer lanzamiento es normal y no es un síntoma: el arranque inicial descarga y carga el modelo, unos 14 GB, y los lanzamientos posteriores se benefician de la caché. Por último, si Vibe no encuentra el servidor local, simplemente comprueba que el puerto 8080 está escuchando antes de buscar más allá.

curl http://localhost:8080/health

Puntos clave

  • vLLM es el marco de trabajo recomendado para servir Devstral localmente.
  • Las opciones --tool-call-parser mistral y --enable-auto-tool-choice son obligatorias.
  • Una H100/A100 ofrece FP8 y contexto de 128K; una RTX 4090 ofrece 4 bits y 32K.
  • Reduce --max-model-len si la VRAM es insuficiente.
  • Conecta Vibe mediante un proveedor y una configuración predefinida de modelo en config.toml (o el proveedor predefinido llamacpp) y usa /model.
  • Ejecuta vLLM como un servicio de systemd para el uso diario.