Kort antwoord: - Mistral Small 4 is een gehost, gesloten model. De gewichten zijn niet publiek, dus je kunt het niet volledig offline/lokaal draaien. Je kunt het wel lokaal aanroepen via de Mistral API. - Wil je echt lokaal/offline draaien, gebruik dan een open‑weights alternatief uit de Mistral‑familie (bijv. Mistral‑7B‑Instruct v0.3, Mixtral 8x7B/8x22B, Mistral‑Nemo, Ministral‑3B/8B). Optie A — Lokaal aanroepen via de Mistral API (niet offline): 1) Installeer SDK - Python: pip install mistralai 2) Stel je API‑sleutel in - macOS/Linux: export MISTRAL_API_KEY=... - Windows (Powershell): setx MISTRAL_API_KEY "...” 3) Roep het model aan - Modelnaam: mistral-small-latest (Small 4 achter deze alias) - Voorbeeld (Python, schets): from mistralai import Mistral; client = Mistral(api_key=...); client.chat.complete(model="mistral-small-latest", messages=[{"role":"user","content":"..."}]) Optie B — Volledig lokaal (open gewichten) met vergelijkbare Mistral‑modellen: 1) Snel en eenvoudig: Ollama - Installeer Ollama - Trek een model: - Mistral‑7B‑Instruct: ollama pull mistral - Mixtral 8x7B‑Instruct: ollama pull mixtral - Start inferentie: - ollama run mistral - of met prompt: ollama run mistral "Schrijf een samenvatting..." - Opmerking: Ollama gebruikt geoptimaliseerde quantized builds; draait op CPU of GPU. 2) Prestaties/serving: vLLM (OpenAI‑compatible server) - Installatie: pip install vllm - Start server (voorbeeld Mistral‑7B‑Instruct v0.3): - python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-Instruct-v0.3 --dtype float16 - Gebruik via OpenAI‑compatibele clients (endpoint: http://localhost:8000/v1, modelnaam gelijk aan je geladen model). 3) Productiegericht: Text Generation Inference (Hugging Face TGI) - Start met Docker: - docker run --gpus all -p 8080:80 -e MODEL_ID=mistralai/Mistral-7B-Instruct-v0.3 ghcr.io/huggingface/text-generation-inference:latest - Aanroepen: - curl -X POST http://localhost:8080/generate -d '{"inputs":"Hallo","parameters":{"max_new_tokens":128}}' -H "Content-Type: application/json" 4) Lichtgewicht/CPU‑vriendelijk: llama.cpp (GGUF) - Download een GGUF‑quant van het gewenste open model (bijv. Mistral‑7B‑Instruct Q4_K_M) - Run: - ./main -m ./models/mistral-7b-instruct.Q4_K_M.gguf -p "Schrijf een korte samenvatting..." Hardwareindicaties (ruw, afhankelijk van quantisatie en contextlengte): - Mistral‑7B: - FP16 op GPU: ~12–16 GB VRAM - 4‑bit quant (GGUF/GPTQ/AWQ): 4–8 GB VRAM of 8–16 GB RAM op CPU - Mixtral 8x7B: - Meer geheugen (24–48 GB VRAM); quantisatie of CPU mogelijk maar trager Fijnslijpen/fine‑tuning (alleen open gewichten): - Gebruik LoRA/QLoRA (PEFT) op open Mistral‑modellen; houd contextlengte en dtype/quantisatie in de gaten. Belangrijk: - Wil je specifiek Mistral Small 4 on‑prem/offline draaien, dan is dat alleen mogelijk via een zakelijke on‑prem/BYOC‑licentie bij Mistral. Zonder die licentie zijn de gewichten niet beschikbaar. - Voor vergelijkbare latency/kosten lokaal kun je vaak met Mistral‑7B‑Instruct of Ministral‑8B beginnen en later opschalen naar Mixtral als je meer capaciteit nodig hebt.

Mistral Small 4 is een recent uitgebrachte multimodale AI‑model van Mistral AI (maart 2026) dat inference, reasoning, coding en multimodale mogelijkheden in één architectuur verenigt. Het biedt een 256K contextvenster, een Mixture‑of‑Experts‑ontwerp (MoE) (~119B totale parameters, ~6,5B actief per token) en levert snellere inferentie (tot 40% latentiereductie), terwijl het in benchmarks beter presteert dan vergelijkbare open modellen zoals GPT‑OSS 120B.

Om het lokaal te draaien, heb je GPU’s met veel geheugen (≥48GB VRAM aanbevolen) of gekwantiseerde implementaties nodig, plus frameworks zoals Transformers, vLLM of Ollama.

Wat is Mistral Small 4?

Eén model voor meerdere taken

Mistral Small 4 is het best te begrijpen als een “alleskunner”: het combineert de sterke punten van Mistrals eerdere instructie-, redenerings- en codefamilies in één model. In de eigen release‑terminologie is Small 4 het eerste Mistral‑model dat de mogelijkheden van Magistral voor reasoning, Pixtral voor multimodale taken en Devstral voor agent‑gestuurd coderen verenigt. Het accepteert tekst- en beeldinvoer, geeft tekst als output, en is bedoeld voor chat, coderen, agent‑workflows, documentbegrip, onderzoek en visuele analyse.

Waarom deze release ertoe doet

De praktische betekenis is dat Mistral Small 4 de overhead van modelwisselingen vermindert. In plaats van één prompt naar een snel instructiemodel te routeren, een tweede naar een redeneermodel en een derde naar een vision‑model, kun je één endpoint gebruiken en de instelling reasoning_effort naar behoefte aanpassen. Mistral zegt expliciet dat reasoning_effort="none" snelle, lichte antwoorden geeft die vergelijkbaar zijn met Small 3.2‑achtige chat, terwijl reasoning_effort="high" diepere, uitgebreidere redeneringen produceert zoals in de eerdere Magistral‑modellen.

Prestatiebenchmarks van Mistral Small 4

Belangrijkste prestatiehoogtepunten

👉 Dit maakt het ideaal voor AI‑systemen op productieniveau.

Architectuur (belangrijk technisch inzicht)

• Modeltype: Mixture‑of‑Experts (MoE)
• Totaal aantal parameters: ~119B
• Actieve parameters per token: ~6,5B
• Experts: ~128 (4 actief per forward pass)

👉 Deze architectuur biedt intelligentie van grote modellen tegen de kosten van kleine modellen, waardoor het idealer is voor lokale deployment dan dichte modellen.

Implementatievereisten als je Mistral Small 4 wilt inzetten

Officiële minimale en aanbevolen infrastructuur

Mistral is hier opvallend expliciet. Minimale infrastructuur is 4x NVIDIA HGX H100, 2x NVIDIA HGX H200 of 1x NVIDIA DGX B200. De aanbevolen setup voor optimale prestaties is 4x HGX H100, 4x HGX H200 of 2x DGX B200. Dat is een sterk signaal dat het volledig officiële pad gericht is op machines op datacenter‑niveau in plaats van een enkele consument‑GPU.

Wat dat in de praktijk betekent

Mistral Small 4 heeft open gewichten en is efficiënt voor zijn omvang, maar het is nog steeds een 119B‑MoE‑systeem met een contextvenster van 256k. In echte implementaties betekent die combinatie dat de geheugendruk snel oploopt naarmate de contextlengte toeneemt, en dat duurzame prestaties meestal afhangen van multi‑GPU‑tensor‑parallelisme en efficiënte serving‑software. Daarom wordt vLLM aanbevolen als primaire self‑deployment‑engine en om OpenAI‑compatibele serving‑patronen aan te bieden in plaats van single‑machine “het werkt gewoon”-defaults.

Aanbevolen setup (professioneel)

Waarom hardware ertoe doet

Omdat:

• 119B‑parametermodel (zelfs MoE)
• Groot contextvenster (256K tokens)
• Multimodale verwerking

👉 Zonder optimalisatie is het te zwaar voor consument‑GPU’s.

Mistral Small 4 lokaal draaien (stap‑voor‑stap)

Stap 1) Haal de gewichten op en accepteer de toegangsvoorwaarden

vLLM haalt standaard gewichten op via Hugging Face, dus je hebt een Hugging Face‑toegangstoken met READ‑rechten nodig en je moet de voorwaarden op de modelkaart accepteren. Voor een praktische lokale setup bereid je een Linux‑machine voor met NVIDIA‑drivers, CUDA‑compatibele runtime‑ondersteuning, Python, en voldoende GPU‑geheugen voor het geselecteerde checkpoint. Als je de artifacts al op je eigen opslag hebt, kun je de Hugging Face‑setup overslaan en vLLM in plaats daarvan naar het lokale pad laten verwijzen.

Stap 2) Gebruik de officieel aanbevolen server‑stack

Raadt self‑deployment via vLLM aan, dat wordt beschreven als een sterk geoptimaliseerd serving‑framework dat een OpenAI‑compatibele API kan aanbieden. In de self‑deployment‑documentatie worden ook TensorRT‑LLM en TGI genoemd als alternatieven, maar vLLM is het aanbevolen pad voor deze modelfamilie.

Stap 3) Trek de door Mistral aanbevolen Docker‑image binnen of installeer vLLM handmatig

Mistral Small 4 raadt aan een aangepaste Docker‑image te gebruiken met de benodigde fixes voor tool‑calling en reasoning‑parsing, of handmatig een gepatchte vLLM‑build te installeren. De kaart levert een aangepaste image en vermeldt dat Mistral samenwerkt met het vLLM‑team om de wijzigingen upstream te brengen.

docker pull mistralllm/vllm-ms4:latestdocker run -it mistralllm/vllm-ms4:latest

Stap 4) Serve het model

Het door Mistral aanbevolen servercommando is:

vllm serve mistralai/Mistral-Small-4-119B-2603-NVFP4 \  --max-model-len 262144 \  --tensor-parallel-size 2 \  --attention-backend TRITON_MLA \  --tool-call-parser mistral \  --enable-auto-tool-choice \  --reasoning-parser mistral \  --max_num_batched_tokens 16384 \  --max_num_seqs 128 \  --gpu_memory_utilization 0.8

Dat commando is de belangrijkste praktische aanwijzing in het hele lokale verhaal: het laat zien dat het model bedoeld is om te draaien met een serieuze GPU‑backend, een lang contextvenster, en met Mistral‑specifieke tool‑ en reasoning‑parsers ingeschakeld.

Stap 5) Verbind je applicatie met de lokale endpoint

Omdat vLLM een OpenAI‑compatibele REST‑API aanbiedt, kun je meestal bestaande OpenAI‑SDK‑code naar http://localhost:8000/v1 verwijzen en het grootste deel van je applicatielogica ongewijzigd laten. Het voorbeeld van Mistral gebruikt base_url="http://localhost:8000/v1" en een lege API‑sleutel, wat een veelvoorkomend patroon is voor lokale ontwikkeling.

from openai import OpenAIclient = OpenAI(api_key="EMPTY", base_url="http://localhost:8000/v1")resp = client.chat.completions.create(    model="mistralai/Mistral-Small-4-119B-2603-NVFP4",    messages=[{"role": "user", "content": "Summarize the document in five bullets."}],    temperature=0.7,    reasoning_effort="none",)print(resp.choices[0].message.content)

Stap 6) Afstemmen op snelheid of kwaliteit

Als je het model lokaal test, wordt reasoning_effort="high" aangeraden voor complexe prompts en temperature=0.7 in die modus, terwijl lagere temperaturen geschikter zijn wanneer reasoning uit staat. Dezelfde kaart biedt ook het FP8‑checkpoint voor de beste nauwkeurigheid en het NVFP4‑checkpoint voor doorvoer en lager geheugengebruik; de juiste configuratie hangt dus af van of je optimaliseert voor kwaliteit, snelheid of hardwarefootprint.

Stap 7: Optioneel – draaien via Ollama (vereenvoudigd)

ollama run mistral-small-4

👉 Het best voor:

• Lokale ontwikkeling
• Snelle setup

Mistral Small 4 vs GPT‑OSS vs Qwen 3.5 (volledige vergelijking)

Mistral Small 4: extreem efficiënte MoE

• 119B totale parameters
• ~6,5B actief per token
• 128 experts (4 actief)
• Multimodaal (tekst + beeld)

👉 Kernidee: zeer grote capaciteit maar weinig rekenwerk per token

Dit levert:

• Hoge prestaties
• Lage latentie
• Lagere kosten per inferentie

GPT‑OSS: praktische MoE voor deployment

• 120B‑versie: ~117B totaal / 5,1B actief
• 20B‑versie: ~21B totaal / 3,6B actief
• Alleen tekst

👉 Kernidee: krachtige modellen op minimale hardware laten passen

• Kan op één H100‑GPU draaien
• Sterke tool‑ondersteuning / gestructureerde outputondersteuning

Qwen 3.5: schaalbare hoge capaciteiten

• Tot 122B parameters
• Hoger aantal actieve parameters (~20B+)
• Multimodaal + sterke meertaligheid

👉 Kernidee: capaciteit maximaliseren, ook als de rekenkosten stijgen

Prestatiebenchmark‑vergelijking

Met reasoning ingeschakeld evenaart of overtreft Small 4 GPT‑OSS 120B op LCR, LiveCodeBench en AIME 2025, terwijl het kortere outputs genereert. Mistral noemt één voorbeeld waarin Small 4 0.72 scoort op AA LCR met slechts 1.6K tekens, terwijl vergelijkbare Qwen‑resultaten 5.8K–6.1K tekens nodig hadden, en zegt dat Small 4 beter presteert dan GPT‑OSS 120B op LiveCodeBench terwijl het 20% minder output produceert.

Welke is de beste lokale keuze?

Mijn oordeel: Mistral Small 4 is de beste “single‑model”-keuze als je een gebalanceerde lokale of private deployment wilt met sterke algemene chat, coderen, agent‑werk en multimodale ondersteuning. GPT‑OSS is de duidelijkste keuze als je een vrij beschikbaar OpenAI‑model wilt met zeer expliciete instructies voor lokaal serven, met name de kleinere 20B‑versie. Qwen3.5 is de breedste familie, en het is de optie als je het meest hecht aan meertalige dekking, meerdere maatklassen en flexibele lokale serve‑opties.

Als je toegang wilt tot deze toonaangevende open‑sourcemodellen via API’s en niet van leverancier wilt wisselen, raad ik CometAPI aan; het biedt GPT-oss-120B en Qwen 3.5 plus API enz.

Met andere woorden, je kunt Small 4 als gehost model gebruiken, of de gewichten ophalen en zelf hosten op je eigen infrastructuur.

Conclusie

Small 4 is een zeer sterke keuze wanneer je een open‑gewichten, multimodaal, redeneervermogend model nodig hebt dat zelf gehost kan worden, fijn‑afgesteld kan worden en geïntegreerd kan worden in bestaande OpenAI‑achtige applicatiestacks. Het is vooral aantrekkelijk voor teams die waarde hechten aan deploy‑controle, data‑residentie en lagere marginale tokenkosten, terwijl ze toch een modern, algemeen inzetbaar model willen.

Klaar om toegang te krijgen tot Mistral Small 4? Kom dan naar CometAPI!