Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Déployer Devstral en local avec vLLM

Ceacht 13 as 14 Nuashonraithe 2 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Préparer le déploiement
  2. Ce que ton matériel permet
  3. Installer vLLM
  4. Démarrer le serveur
  5. Adapter la commande à ta machine
  6. Connecter Vibe et vérifier
  7. Les trois problèmes que tu rencontreras
  8. Príomhphointí

Leçon mise à jour le 2 novembre 2026 sur la base de la page Using offline models de la documentation Vibe. Devstral a été retiré de l’API Mistral, mais ses poids restent publiés : Devstral Small 2 et Mistral Small 4 sont les deux modèles ouverts recommandés pour un usage local. Vibe n’inclut pas de modèle local : tu le connectes à un serveur compatible OpenAI via un préréglage dans config.toml, puis tu bascules en utilisant /model. Source : Using offline models.

Préparer le déploiement

Déployer Devstral en local signifie exécuter un serveur d’inférence sur ta machine qui expose une API compatible OpenAI. Vibe s’y connecte alors exactement comme s’il parlait au cloud Mistral. Cette compatibilité d’interface rend la transition transparente ; tes outils n’ont aucune raison de savoir d’où viennent les réponses. Le framework recommandé pour ce rôle est vLLM, un moteur d’inférence haute performance développé par la communauté open source.

Ce que ton matériel permet

Avant d’installer quoi que ce soit, vérifie ton GPU. Il détermine la précision utilisable et, par conséquent, la taille de la fenêtre de contexte dont tu disposeras.

Configuration GPU VRAM Précision Contexte
Recommandé NVIDIA H100 / A100 80 Go FP8 ~128K jetons
Alternative RTX 4090 / RTX 6000 24–48 Go 4 bits (quantifié) ~32K jetons
CPU uniquement Pas de GPU 64+ Go RAM - Lent (non recommandé)

Note importante : La configuration CPU uniquement est fonctionnelle mais extrêmement lente pour un modèle de 24B. Elle convient uniquement aux tests, pas à un usage quotidien. En d’autres termes, elle te permet de vérifier que la chaîne fonctionne, mais pas que tu peux travailler avec.

Installer vLLM

Le prérequis logiciel est minimal : Python 3.10 ou supérieur, suivi d’un pip install.

# Python 3.10+ requis
python3 --version

# Installer vLLM
pip install vllm

Ensuite, vérifie que les pilotes NVIDIA et CUDA sont installés et opérationnels. Cette commande est le meilleur test de bout en bout : si elle affiche ton GPU et une version CUDA, la couche de bas niveau est saine, et toute erreur ultérieure viendra d’ailleurs.

nvidia-smi
# Doit afficher ton GPU et la version CUDA

Démarrer le serveur

La commande de démarrage tient en quatre arguments, dont deux sont essentiels pour travailler avec Vibe.

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

Décomposons les indicateurs :

  • mistralai/Devstral-Small-2-24B-Instruct-2512 : Le modèle Hugging Face à charger
  • --tool-call-parser mistral : Active l’analyse des appels d’outils au format Mistral
  • --enable-auto-tool-choice : Permet au modèle de choisir automatiquement ses outils
  • --port 8080 : Le port d’écoute du serveur

Les deux indicateurs liés aux outils méritent attention. Sans eux, le serveur répondrait à tes questions, mais le modèle ne pourrait plus lire un fichier ni exécuter une commande. Vibe deviendrait un simple chatbot, ce qui n’est pas l’objectif.

Adapter la commande à ta machine

Si tu possèdes plusieurs GPU, le parallélisme tensoriel répartit le modèle sur toutes les cartes. La VRAM combinée permet alors une fenêtre de contexte plus large.

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

Sur une configuration plus modeste, tu dois réduire la précision. Un H100 ou A100 gère le FP8 ; un RTX 4090 utilisera la quantification 4 bits avec AWQ, au prix d’une légère perte de qualité largement compensée par le fait que le modèle tient enfin en mémoire.

# FP8 sur 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 sur RTX 4090
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --quantization awq \
  --port 8080

Le dernier levier lorsque la VRAM reste insuffisante est de réduire la longueur maximale du contexte. Le cache d’attention consomme de la mémoire proportionnellement au contexte, et descendre à 16 384 jetons libère souvent ce qui manquait pour démarrer.

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

Connecter Vibe et vérifier

Le serveur tourne ; il faut maintenant dire à Vibe de l’utiliser. Vibe n’inclut pas de modèle local : déclare un fournisseur et un préréglage de modèle dans 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"

Garde active_model au-dessus du premier tableau [[...]], sinon TOML l’attachera à ce tableau. Définis max_context_length dans le préréglage pour indiquer le contexte de ton serveur, qui doit également renvoyer l’utilisation en jetons dans les réponses en streaming (stream_options.include_usage). Variante plus courte : Vibe fournit un fournisseur prédéfini, llamacpp, qui pointe vers http://127.0.0.1:8080/v1 sans clé ; dans ce cas, écris provider = "llamacpp" dans le préréglage, sans bloc [[providers]]. Dans une session, /model permet de basculer entre le modèle local et les modèles hébergés.

Teste la chaîne à deux niveaux : d’abord l’API brute, qui confirme que le modèle est chargé, puis une requête réelle dans Vibe pour valider que les appels d’outils fonctionnent.

# Test direct de l'API
curl http://localhost:8080/v1/models

# Test dans Vibe (l'agent ask demande avant chaque outil)
vibe --agent ask
> List files in the current directory

Pour un usage quotidien, redémarrer manuellement la commande devient vite fastidieux. Un service systemd démarre le serveur au boot et le redémarre en cas de plantage.

# Créer un service 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

Les trois problèmes que tu rencontreras

Une erreur CUDA out of memory signifie que le modèle ne tient pas : réduis --max-model-len ou passe à la quantification 4 bits. La lenteur au tout premier lancement est normale et n’est pas un symptôme : le démarrage initial télécharge et charge le modèle, environ 14 Go, et les lancements suivants bénéficient du cache. Enfin, si Vibe ne trouve pas le serveur local, vérifie simplement que le port 8080 est à l’écoute avant d’aller plus loin.

curl http://localhost:8080/health

Príomhphointí

  • vLLM est le framework recommandé pour servir Devstral en local
  • Les indicateurs --tool-call-parser mistral et --enable-auto-tool-choice sont obligatoires
  • Un H100/A100 offre le FP8 et un contexte de 128K ; un RTX 4090 offre le 4 bits et 32K
  • Réduis --max-model-len si la VRAM est insuffisante
  • Connecte Vibe via un fournisseur et un préréglage de modèle dans config.toml (ou le fournisseur prédéfini llamacpp), puis utilise /model
  • Exécute vLLM en tant que service systemd pour un usage quotidien