Devstral Quickstart-gids: draai Mistral AI’s LLM lokaal

Het lijkt alsof er in hoog tempo nieuwe AI-modellen verschijnen, en Mistral AI heeft de spanning opgevoerd met de lancering van Devstral, een baanbrekend open-source codemodel. Devstral is een agentisch coding large language model (LLM) dat lokaal kan draaien op een RTX 4090 GPU of een Mac met 32 GB RAM, waardoor lokale deployment en on-device gebruik binnen bereik liggen. Het is snel, nauwkeurig en vrij te gebruiken. 

In deze tutorial leer je alles wat je moet weten over Devstral, inclusief de belangrijkste features en wat het uniek maakt. We leren ook hoe je Devstral lokaal draait met tools zoals de Mistral Chat CLI en hoe je de Mistral AI API integreert met OpenHands om de agentische capaciteiten van Devstral te testen.

Je kunt meer leren over andere tools van Mistral in aparte gidsen, waaronder Mistral Medium 3, Mistral OCR API en Mistral Le Chat. 

Wat is Mistral Devstral?

Devstral is een state-of-the-art agentisch model dat is ontworpen voor software-engineeringtaken. Het is ontwikkeld door Mistral AI in samenwerking met All Hands AI. Het blinkt uit in het oplossen van realistische codeeruitdagingen, zoals het verkennen van grote codebases, het bewerken van meerdere bestanden en het oplossen van issues in GitHub-repositories. 

De prestaties van Devstral op de SWE-Bench Verified-benchmark zijn ongeëvenaard, met een score van 46,8%. Daarmee staat het als #1 open-sourcemodel op deze benchmark en presteert het 6% beter dan eerdere state-of-the-art modellen.

Bron: Devstral | Mistral AI

Gebouwd op Mistral-Small-3.1 heeft Devstral een contextvenster van 128k, waardoor het grote hoeveelheden code en afhankelijkheden kan verwerken en begrijpen. In tegenstelling tot het basismodel is Devstral alleen-tekst: de vision-encoder is tijdens fine-tuning verwijderd om het te specialiseren voor codetaken. 

Dankzij naadloze samenwerking met tools zoals OpenHands kan het zelfs veel grotere modellen overtreffen, zoals Deepseek-V3-0324 (671B) en Qwen3 232B-A22B.

Belangrijkste features van Devstral

Hier zijn enkele opvallende features van Devstral die het onderscheiden van andere codemodellen.

1. Agentisch coderen

Devstral is specifiek ontworpen om uit te blinken in agentische codetaken, waardoor het een ideaal model is voor het bouwen en deployen van software-engineeringagents. Dankzij de vaardigheid om complexe, meerstaps taken binnen grote codebases op te lossen, kunnen developers realistische codeeruitdagingen effectief aanpakken.

2. Lichtgewicht ontwerp

Een van de opvallendste kenmerken van Devstral is de lichtgewicht architectuur. Met slechts 24 miljard parameters kan het draaien op een enkele Nvidia RTX 4090 GPU. Dit maakt het ideaal voor lokale deployment, on-device gebruik en privacygevoelige toepassingen.

3. Open-source 

Uitgebracht onder de Apache 2.0-licentie is Devstral vrij beschikbaar voor commercieel gebruik. Developers en organisaties kunnen het deployen, aanpassen en zelfs integreren in propriëtaire producten zonder beperkingen.

4. Uitgebreid contextvenster

Devstral beschikt over een indrukwekkend contextvenster van 128k, waardoor het enorme hoeveelheden code en instructies in één interactie kan verwerken en begrijpen. Dit is bijzonder effectief bij het werken met grote codebases en het oplossen van complexe programmeerproblemen.

5. Geavanceerde tokenizer

Devstral gebruikt een Tekken-tokenizer met een vocabulaire van 131k, waardoor het code- en tekstinput nauwkeurig en efficiënt kan verwerken. Deze tokenizer versterkt het vermogen van het model om accurate, contextbewuste antwoorden te genereren die zijn toegesneden op software-engineeringtaken.

Aan de slag met Devstral

Devstral is gratis te downloaden op platforms zoals Hugging Face, Ollama, Kaggle, Unsloth en LM Studio. Developers kunnen er ook via een API bij onder de naam devstral-small-2505 tegen concurrerende prijzen: $0,10 per miljoen inputtokens en $0,30 per miljoen outputtokens.

In deze gids behandelen we twee belangrijke workflows:

1. Devstral lokaal draaien met Mistral inference.
2. Devstral integreren met OpenHands voor het bouwen van machinelearningprojecten.

Devstral lokaal draaien

Om Devstral lokaal te draaien gebruiken we een Runpod-instantie met GPU-ondersteuning, downloaden we het model van Hugging Face en communiceren we ermee via de mistral-chat CLI-tool.

1. Richt de pod in met 100 GB opslag en een A100 SXM GPU, en start de JupyterLab-instantie.

2. Voer de volgende commando’s uit in een Jupyter Notebook om de benodigde dependencies te installeren:

%%capture
%pip install mistral_inference --upgrade
%pip install huggingface_hub

3. Gebruik de Hugging Face Hub om de modelfiles, tokenizer en parameterconfiguratie te downloaden. 

from huggingface_hub import snapshot_download
from pathlib import Path

mistral_models_path = Path.home().joinpath('mistral_models', 'Devstral')
mistral_models_path.mkdir(parents=True, exist_ok=True)

snapshot_download(repo_id="mistralai/Devstral-Small-2505", allow_patterns=["params.json", "consolidated.safetensors", "tekken.json"], local_dir=mistral_models_path)

4. Open een terminal in JupyterLab en voer het volgende commando uit om de mistral-chat CLI te starten:

mistral-chat $HOME/mistral_models/Devstral --instruct --max_tokens 300

5. Probeer de volgende prompt om Devstral te testen:

“Maak vanaf nul een REST API met Python.”

Het model heeft een gedetailleerde en accurate reactie gegenereerd: een stapsgewijze gids voor het bouwen van een REST API met Flask.

Creating a REST API from scratch using Python involves several steps. We'll use the Flask framework, which is lightweight and easy to get started with. Below is a step-by-step guide to creating a simple REST API.
### Step 1: Install Flask
First, you need to install Flask. You can do this using pip:

```bash
pip install Flask
```

### Step 2: Create the Flask Application

Create a new Python file, for example, `app.py`, and set up the basic structure of your Flask application.

```python
from flask import Flask, request, jsonify

app = Flask(__name__)

# Sample data
items = [
    {"id": 1, "name": "Item 1", "description": "This is item 1"},
    {"id": 2, "name": "Item 2", "description": "This is item 2"}
]

@app.route('/items', methods=['GET'])
def get_items():
    return jsonify(items)

@app.route('/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item:
        return jsonify(item)
    return jsonify({"error": "Item not found"}), 404

@app.route('/items', methods=['POST'])
def create_item():
    new_item = request.get_json()
    new_item["id"] = len(items
=====================

Devstral draaien met OpenHands

Je kunt eenvoudig toegang krijgen tot het Devstral-model via de Mistal AI API. In dit project gebruiken we de Devstral API samen met OpenHands om ons machinelearningproject vanaf de basis op te bouwen. OpenHands is een open-sourceplatform dat fungeert als je AI-software engineer voor het bouwen en afronden van je codeerproject.

1. Bezoek het Mistral AI-platform en genereer je API-sleutel.

2. Zet $5 op je account met een debit/creditcard. 

3. Voer het volgende script uit om 

• De API-sleutel als omgevingsvariabele in te stellen.
• De OpenHands Docker-image te pullen.
• Een configuratiebestand te maken.
• De OpenHands-applicatie in een Docker-container te starten.

# Store the API key securely as an environment variable (avoid hardcoding in scripts)
export MISTRAL_API_KEY=<MY_KEY>

# Pull the runtime image for OpenHands
docker pull docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik

# Create a configuration directory and settings file for OpenHands
mkdir -p ~/.openhands-state
cat << EOF > ~/.openhands-state/settings.json
{
  "language": "en",
  "agent": "CodeActAgent",
  "max_iterations": null,
  "security_analyzer": null,
  "confirmation_mode": false,
  "llm_model": "mistral/devstral-small-2505",
  "llm_api_key": "${MISTRAL_API_KEY}",
  "remote_runtime_resource_factor": null,
  "github_token": null,
  "enable_default_condenser": true
}
EOF

# Run the OpenHands application in a Docker container with enhanced settings
docker run -it --rm --pull=always \
    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik \
    -e LOG_ALL_EVENTS=true \
    -e TZ=$(cat /etc/timezone 2>/dev/null || echo "UTC") \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v ~/.openhands-state:/.openhands-state \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    --memory="4g" \
    --cpus="2" \
    docker.all-hands.dev/all-hands-ai/openhands:0.39

De webapplicatie is beschikbaar op http://0.0.0.0:3000

0.39-nikolaik: Pulling from all-hands-ai/runtime
Digest: sha256:126448737c53f7b992a4cf0a7033e06d5289019b32f24ad90f5a8bbf35ce3ac7
Status: Image is up to date for docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik
docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik
0.39: Pulling from all-hands-ai/openhands
Digest: sha256:326ddb052763475147f25fa0d6266cf247d82d36deb9ebb95834f10f08e4777d
Status: Image is up to date for docker.all-hands.dev/all-hands-ai/openhands:0.39
Starting OpenHands...
Running OpenHands as root
10:34:24 - openhands:INFO: server_config.py:50 - Using config class None
INFO:     Started server process [9]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:3000 (Press CTRL+C to quit)

Devstral testen in OpenHands

1. Klik op de knop “Launch from Scratch” om een project te starten.

2.   Je wordt doorgestuurd naar de nieuwe interface, met een chatvenster en andere tabbladen voor development-inference.

3. Gebruik de chatinterface om prompts te geven. Binnen enkele seconden begint Devstral mappen, bestanden en code voor het project aan te maken.

4. Schakel over naar het VS Code-tabblad om de gegenereerde code te bekijken, te bewerken en uit te voeren.

5. Devstral is zo goed dat het de applicatie heeft gestart, in de webapplicatie heeft getest en ook de webagent gebruikt om op de webpagina te surfen.

Zodra het project klaar is, push je het naar GitHub om het met je team te delen.

Conclusie

Devstral is goed nieuws voor de open-sourcegemeenschap. Je kunt OpenHands met Ollama of VLLM gebruiken om het model lokaal te draaien en er vervolgens via de OpenHands-interface mee te werken. Bovendien kun je Devstral integreren in je code-editor via extensies, wat het tot een zeer effectieve optie maakt.

In deze tutorial hebben we Devstral, een agentisch codemodel, verkend en de mogelijkheden getest door het lokaal te draaien en met OpenHands te gebruiken. De resultaten waren indrukwekkend. Devstral is snel, zeer nauwkeurig en blinkt uit in het aansturen van agents om complexe taken uit te voeren. Het vermogen om realistische software-engineeringuitdagingen snel en precies aan te pakken, maakt het een uitstekende keuze voor developers.

Je kunt meer leren over Agentic AI in ons blogartikel, en je kunt hands-on aan de slag met onze cursus, Designing Agentic Systems with LangChain.