Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Devstral lokaal implementeren met vLLM

Les 13 van 14 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. De implementatie voorbereiden
  2. Wat uw hardware toelaat
  3. vLLM installeren
  4. De server starten
  5. De opdracht aanpassen aan uw machine
  6. Vibe verbinden en verifiëren
  7. De drie problemen die u zult tegenkomen
  8. Belangrijkste punten

Les bijgewerkt op 2 november 2026 op basis van de pagina Using offline models in de Vibe-documentatie. Devstral is verwijderd uit de Mistral API, maar de gewichten blijven beschikbaar: Devstral Small 2 en Mistral Small 4 zijn de twee aanbevolen open modellen voor lokaal gebruik. Vibe bundelt geen lokaal model: u verbindt het met een OpenAI-compatibele server via een preset in config.toml en schakelt vervolgens met /model. Bron: Using offline models.

De implementatie voorbereiden

Devstral lokaal implementeren betekent dat u een inferentieserver op uw machine draait die een OpenAI-compatibele API exposeert. Vibe verbindt hiermee alsof het met de Mistral-cloud communiceert. Deze compatibiliteit van de interface maakt de overstap naadloos; uw tooling hoeft niet te weten waar de antwoorden vandaan komen. Het aanbevolen framework voor deze rol is vLLM, een high-performance inferentie-engine ontwikkeld door de open-source community.

Wat uw hardware toelaat

Controleer uw GPU voordat u iets installeert. Deze bepaalt de bruikbare precisie en daarmee de grootte van het contextvenster dat u beschikbaar heeft.

Configuratie GPU VRAM Precisie Context
Aanbevolen NVIDIA H100 / A100 80 GB FP8 ~128K tokens
Alternatief RTX 4090 / RTX 6000 24–48 GB 4-bit (gequantizeerd) ~32K tokens
Alleen CPU Geen GPU 64+ GB RAM - Traag (niet aanbevolen)

Belangrijke opmerking: De configuratie met alleen CPU werkt, maar is extreem traag voor een 24B-model. Deze is alleen geschikt voor tests, niet voor dagelijks gebruik. Met andere woorden: u kunt verifiëren dat de keten werkt, maar niet dat u er daadwerkelijk mee kunt werken.

vLLM installeren

De softwarevereisten zijn minimaal: Python 3.10 of hoger, gevolgd door een pip install.

# Python 3.10+ vereist
python3 --version

# vLLM installeren
pip install vllm

Controleer vervolgens of de NVIDIA-drivers en CUDA geïnstalleerd en operationeel zijn. Deze opdracht is de beste end-to-end test: als deze uw GPU en een CUDA-versie weergeeft, is de onderliggende laag gezond en komen eventuele volgende fouten ergens anders vandaan.

nvidia-smi
# Moet uw GPU en de CUDA-versie weergeven

De server starten

De startopdracht past in vier argumenten, waarvan er twee essentieel zijn voor het werken met Vibe.

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

Laten we de flags opsplitsen:

  • mistralai/Devstral-Small-2-24B-Instruct-2512: Het Hugging Face-model om te laden
  • --tool-call-parser mistral: Schakelt parsing van tool-aanroepen in Mistral-formaat in
  • --enable-auto-tool-choice: Staat het model toe automatisch zijn tools te kiezen
  • --port 8080: De luisterpoort van de server

De twee flags gerelateerd aan tools verdienen aandacht. Zonder deze zou de server uw vragen beantwoorden, maar zou het model geen bestanden meer kunnen lezen of opdrachten kunnen uitvoeren. Vibe zou een simpele chatbot worden, wat niet de bedoeling is.

De opdracht aanpassen aan uw machine

Als u meerdere GPU’s heeft, verdeelt tensor-parallelisme het model over alle kaarten. Het gecombineerde VRAM maakt dan een breder contextvenster mogelijk.

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

Bij een bescheidener configuratie moet u de precisie verlagen. Een H100 of A100 kan FP8 aan; een RTX 4090 gebruikt 4-bit quantization met AWQ, ten koste van een licht kwaliteitsverlies dat ruimschoots wordt gecompenseerd doordat het model eindelijk in het geheugen past.

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

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

De laatste hefboom wanneer VRAM ontoereikend blijft, is het verlagen van de maximale contextlengte. De attention-cache verbruikt geheugen evenredig aan de context, en terugvallen naar 16.384 tokens maakt vaak net genoeg ruimte vrij om te starten.

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

Vibe verbinden en verifiëren

De server draait; nu moet u Vibe instrueren deze te gebruiken. Vibe bundelt geen lokaal model: declareer een provider en een model-preset in 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"

Houd active_model boven de eerste [[...]] tabel, anders koppelt TOML deze aan die tabel. Stel max_context_length in de preset in om het contextvenster van uw server aan te geven; deze moet ook het token-gebruik retourneren in streaming-antwoorden (stream_options.include_usage). Kortere variant: Vibe biedt een vooraf gedefinieerde provider, llamacpp, die wijst naar http://127.0.0.1:8080/v1 zonder sleutel; schrijf in dat geval provider = "llamacpp" in de preset, zonder een [[providers]] blok. In een sessie schakelt /model tussen het lokale model en gehoste modellen.

Test de keten op twee niveaus: eerst de ruwe API, wat bevestigt dat het model geladen is, en vervolgens een echt verzoek in Vibe om te valideren dat tool-aanroepen werken.

# Directe API-test
curl http://localhost:8080/v1/models

# Test in Vibe (de ask-agent vraagt toestemming voor elke tool)
vibe --agent ask
> List files in the current directory

Voor dagelijks gebruik wordt het handmatig herstarten van de opdracht snel vervelend. Een systemd-service start de server bij het opstarten en herstart deze bij een crash.

# Maak een systemd-service
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

De drie problemen die u zult tegenkomen

Een CUDA out of memory-fout betekent dat het model niet past: verlaag --max-model-len of schakel over naar 4-bit quantization. Traagheid bij de allereerste start is normaal en geen symptoom; de initiële start downloadt en laadt het model (ongeveer 14 GB), en volgende starts profiteren van de cache. Als Vibe de lokale server niet kan vinden, controleer dan eerst of poort 8080 luistert voordat u verder zoekt.

curl http://localhost:8080/health

Belangrijkste punten

  • vLLM is het aanbevolen framework om Devstral lokaal te serveren
  • De flags --tool-call-parser mistral en --enable-auto-tool-choice zijn verplicht
  • Een H100/A100 biedt FP8 en 128K context; een RTX 4090 biedt 4-bit en 32K
  • Verlaag --max-model-len als VRAM ontoereikend is
  • Verbind Vibe via een provider en model-preset in config.toml (of de vooraf gedefinieerde llamacpp provider) en gebruik vervolgens /model
  • Draai vLLM als een systemd-service voor dagelijks gebruik