Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Devstral lokaal hosten

Les 13 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Waarom Devstral lokaal hosten?
  2. Aanbevolen modellen
  3. Hardwarevereisten
  4. Implementatie met vLLM
  5. De lokale server gebruiken
  6. Alternatieve frameworks
  7. Vibe verbinden met de lokale server
  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 API, maar Devstral Small 2 blijft bestaan, naast Mistral Small 4, als een van de twee aanbevolen open modellen voor lokaal gebruik. Onderbouwing ontbrekende kostenschattingen zijn verwijderd en het verbinden van Vibe met een lokale server volgt nu de officiële config.toml-syntax. Bron: Using offline models.

Waarom Devstral lokaal hosten?

Devstral Small 2 wordt uitgebracht met open weights onder de Apache 2.0-licentie (Devstral 2, zijn grote broer met 123 miljard parameters, gebruikt een aangepaste MIT-licentie). Hoewel het op 31 maart 2026 uit de Mistral API is verwijderd, is het niet verdwenen: u kunt het op uw eigen servers implementeren zonder ook maar één regel code naar een externe API te sturen, en de Vibe-documentatie beveelt het nog steeds aan voor dit doel.

De motivaties overlappen elkaar vaak. Privacy staat voorop: uw code verlaat nooit uw infrastructuur, wat een einde maakt aan discussies over de gebruiksvoorwaarden van een provider. Daarna volgt latentie, aangezien er geen netwerkroundtrip naar de Mistral API tussen uw toetsaanslagen en de suggestie staat. De kostenstructuur verandert: u betaalt een vaste prijs voor een GPU in plaats van een op gebruik gebaseerde facturatie, wat voordelig wordt zodra een heel team de model de hele dag door bevraagt. Tot slot is er compliance, vereist door bepaalde regelgeving en sectoren zoals banken of defensie, en beschikbaarheid, aangezien geen enkele dienst van derden uw werk kan onderbreken.

Aanbevolen modellen

De Vibe-documentatie beveelt twee open modellen aan voor lokaal gebruik:

  • Devstral Small 2 (mistralai/Devstral-Small-2-24B-Instruct-2512 op Hugging Face): 24 miljard parameters, dense, getraind voor agentische taken en coderen, met de lichtste hardware-footprint;
  • Mistral Small 4: 119 miljard parameters in een mixture-of-experts-architectuur, waarvan 6,5 miljard actief, een hybride redeneer- en codeermodel met een context van 256.000 tokens, onder de Apache 2.0-licentie.

Hardwarevereisten

Voor degelijke prestaties bij lange contexten beveelt de documentatie een FP8-implementatie aan met een context van ongeveer 128.000 tokens:

ConfiguratieHardwarePrecisieContext
AanbevolenH100 of A100 GPUFP8~128.000 tokens
OntwikkelwerkstationRTX 4090 of elke GPU met 24 GB VRAM4-bit~32.000 tokens
Geen GPUCPU-offload, met voldoende RAM—— aanzienlijk langzamer

Deze cijfers gelden voor Devstral Small 2. Mistral Small 4 vereist veel meer videogeheugen om zijn weights te laden: reken op ten minste één 80 GB H100 in FP8, en meer voor lange contexten. Pas vervolgens de precisie en contextlengte aan uw hardware aan.

Implementatie met vLLM

vLLM is het inferentieframework dat door de Vibe-documentatie wordt aanbevolen voor het bedienen van Devstral. Installatie vereist slechts één commando.

pip install vllm

De server start vervolgens in één regel, met de twee opties die het model bruikbaar maken in agent-modus.

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

Drie varianten dekken de meeste reële situaties: het model splitsen over meerdere GPU’s, de precisie verlagen wanneer VRAM krap is, of de context inkorten om dezelfde reden.

# Multi-GPU (als u 2+ GPU's heeft)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --tensor-parallel-size 2 \
  --port 8080

# Verlaagde precisie (voor GPU's met minder VRAM)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --dtype float16 \
  --port 8080

# Verlaagde context (om VRAM te besparen)
vllm serve mistralai/Devstral-Small-2-24B-Instruct-2512 \
  --tool-call-parser mistral \
  --enable-auto-tool-choice \
  --max-model-len 32768 \
  --port 8080

Hier is wat elke vlag bestuurt:

  • --tool-call-parser mistral — schakelt parsing van tool-aanroepen in Mistral-formaat in
  • --enable-auto-tool-choice — stelt het model in staat om te beslissen wanneer het een tool moet aanroepen
  • --tensor-parallel-size — splitst het model over meerdere GPU’s
  • --dtype — bestuurt de precisie (float16, bfloat16, float32)
  • --max-model-len — beperkt de contextgrootte om VRAM te besparen

De eerste twee verdienen speciale aandacht: als u deze weglaat, krijgt u een server die perfect werkt voor conversatie, maar stilzwijgend faalt zodra een agent een tool probeert aan te roepen. Dit is de meest voorkomende oorzaak waarom een lokale implementatie als “teleurstellend” wordt beoordeeld.

De lokale server gebruiken

Zodra vLLM draait, exposeert poort 8080 een OpenAI-compatibele API. De Mistral SDK verbindt hiermee door simpelweg de server-URL te wijzigen; de sleutel is niet langer nodig.

from mistralai.client import Mistral

# Wijs naar de lokale server
client = Mistral(
    api_key="dummy",  # Lokaal geen sleutel nodig
    server_url="http://localhost:8080",
)

response = client.chat.complete(
    model="mistralai/Devstral-Small-2-24B-Instruct-2512",
    messages=[
        {"role": "user", "content": "Analyseer deze code en stel verbeteringen voor."}
    ],
)

De OpenAI SDK werkt net zo goed, waardoor u bestaande code kunt overschakelen naar lokale Devstral zonder deze opnieuw te schrijven.

from openai import OpenAI

client = OpenAI(
    api_key="dummy",
    base_url="http://localhost:8080/v1",
)

response = client.chat.completions.create(
    model="mistralai/Devstral-Small-2-24B-Instruct-2512",
    messages=[
        {"role": "user", "content": "Leg deze code uit."}
    ],
)

Alternatieve frameworks

vLLM is niet de enige weg: Devstral werkt met elk inferentieframework dat een OpenAI-compatibele API exposeert. De Vibe-documentatie noemt llama.cpp, geschikt voor setups met weinig VRAM dankzij de GGUF-gequantiseerde modellen, LM Studio, dat een grafische interface biedt zonder de commandoregel, en Ollama. Controleer de exacte modelnaam en quantisatie in elke tool voordat u resultaten vergelijkt.

Vibe verbinden met de lokale server

Vibe bundelt geen lokaal model: zodra uw server draait, declareert u een provider en een model-preset in config.toml. Voor een OpenAI-compatibele server op poort 8080:

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"

Drie voorzorgsmaatregelen uit de documentatie: houd active_model boven de eerste [[...]]-array, anders zal TOML het aan die array koppelen; stel max_context_length in de preset in om de context van uw server aan te geven; en verifieer dat de server token-gebruik retourneert in streaming-responses (stream_options.include_usage). Vibe biedt ook een vooraf gedefinieerde provider, llamacpp, die wijst naar http://127.0.0.1:8080/v1 zonder sleutel: in dat geval schrijft u gewoon provider = "llamacpp" in de preset. Het /model-commando schakelt vervolgens tussen het lokale model en gehoste modellen.

Schakel voor volledig offline gebruik ook telemetrie en update-controles uit:

enable_telemetry = false
enable_update_checks = false

Met deze instellingen en een lokale provider neemt de CLI geen contact meer op met mistral.ai. Vaardigheden, MCP-servers en connectors die externe systemen bereiken, moeten afzonderlijk worden uitgeschakeld.

Belangrijkste punten

  • Devstral is verwijderd uit de API, maar Devstral Small 2 (24B, Apache 2.0) blijft aanbevolen voor lokaal gebruik, samen met Mistral Small 4
  • vLLM is het aanbevolen framework; --tool-call-parser mistral en --enable-auto-tool-choice zijn essentieel voor een agent
  • H100 of A100 in FP8 met ~128k context; een 24 GB GPU in 4-bit met ~32k
  • De server exposeert een OpenAI-compatibele API, bruikbaar met de Mistral SDK of de OpenAI SDK
  • Vibe verbindt met de server via een preset in config.toml (of de llamacpp-provider); schakel telemetrie en updates uit voor offline gebruik