Devstral Quickstart Guide: Mistral AI's LLM lokal ausführen

Es scheint, als kämen neue KI-Modelle in rasantem Tempo auf den Markt, und Mistral AI hat mit der Einführung von Devstral, einem bahnbrechenden Open-Source-Kodierungsmodell, noch mehr Aufregung geschaffen. Devstral ist ein Agentic Coding Large Language Model (LLM), das lokal auf einer RTX 4090 GPU oder einem Mac mit 32 GB RAM ausgeführt werden kann. Es ist schnell, genau und offen in der Anwendung. 

In diesem Tutorial erfährst du alles, was du über Devstral wissen musst, einschließlich seiner wichtigsten Funktionen und was es einzigartig macht. Wir werden auch lernen, Devstral lokal mit Tools wie Mistral Chat CLI auszuführen und die Mistral AI API mit OpenHands zu integrieren, um die agentenbezogenen Fähigkeiten von Devstral zu testen.

Du kannst mehr über andere Tools von Mistral in separaten Leitfäden erfahren, darunter Mistral Medium 3, Mistral OCR APIund Mistral Le Chat.

Was ist Mistral Devstral?

Devstral ist ein modernes agentenbasiertes Modell, das für Softwareentwicklungsaufgaben entwickelt wurde. Sie wurde von Mistral AI in Zusammenarbeit mit All Hands AI entwickelt. Es eignet sich hervorragend für die Lösung realer Programmieraufgaben, wie z.B. das Erforschen großer Codebases, das Bearbeiten mehrerer Dateien und das Lösen von Problemen im GitHub-Repository. 

Die Leistung von Devstral im SWE-Bench Verified Benchmark ist unübertroffen: Mit einer Punktzahl von 46,8 % ist Devstral die Nummer 1 unter den Open-Source-Modellen in diesem Benchmark und übertrifft die bisherigen State-of-the-Art-Modelle um 6 %.

Quelle: Devstral | Mistral AI

Devstral basiert auf Mistral-Small-3.1 und verfügt über ein 128k-Kontextfenster, mit dem es große Mengen an Code und Abhängigkeiten verarbeiten und verstehen kann. Im Gegensatz zum Basismodell ist Devstral ein reines Textprogramm, da der Vision-Encoder während der Feinabstimmung entfernt wurde, um ihn für Codierungsaufgaben zu spezialisieren. 

Seine Fähigkeit, nahtlos mit Tools wie OpenHands ermöglicht es ihm, selbst viel größere Modelle zu übertreffen, wie zum Beispiel Deepseek-V3-0324 (671B) und Qwen3 232B-A22B.

Hauptmerkmale von Devstral

Hier sind einige bemerkenswerte Merkmale von Devstral, die es von anderen Codierungsmodellen abheben.

1. Agentische Kodierung

Devstral wurde speziell für agentenbasierte Codierungsaufgabenentwickelt und ist damit ein ideales Modell für die Entwicklung und den Einsatz von Softwareentwicklungsagenten. Seine Fähigkeit, komplexe, mehrstufige Aufgaben in großen Codebasen zu lösen, ermöglicht es Entwicklern, reale Herausforderungen im Coding effektiv zu bewältigen.

2. Leichtes Design

Eines der herausragenden Merkmale von Devstral ist seine leichtgewichtige Architektur. Mit nur 24 Milliarden Parametern kann es auf einer einzigen Nvidia RTX 4090 GPU laufen. Diese Funktion ist ideal für den lokalen Einsatz, die Verwendung auf dem Gerät und datenschutzsensible Anwendungen.

3. Open-Source 

Devstral wird unter der Apache 2.0 Lizenzveröffentlicht und ist für die kommerzielle Nutzung frei verfügbar. Entwickler und Unternehmen können es ohne Einschränkungen einsetzen, verändern und sogar in eigene Produkte integrieren.

4. Erweitertes Kontextfenster

Devstral verfügt über ein beeindruckendes 128k-Kontextfenster, das es ihm ermöglicht, große Mengen an Code und Anweisungen in einer einzigen Interaktion zu verarbeiten und zu verstehen. Das macht es besonders effektiv für die Arbeit mit großen Codebasen und das Lösen komplexer Programmierprobleme.

5. Erweiterter Tokenizer

Devstral verwendet einen Tokenizer von Tekken mit einem 131k großen Vokabular, der Code- und Texteingaben präzise und effizient verarbeiten kann. Dieser Tokenizer verbessert die Fähigkeit des Modells, genaue, kontextbezogene Antworten zu generieren, die auf Softwareentwicklungsaufgaben zugeschnitten sind.

Erste Schritte mit Devstral

Devstral steht auf Plattformen wie Hugging Face, Ollama, Kaggle, Unsloth und LM Studio kostenlos zum Download bereit. Entwickler können auch über die API unter dem Namen devstral-small-2505 zu wettbewerbsfähigen Preisen darauf zugreifen: $0,10 pro Million Input-Tokens und $0,30 pro Million Output-Tokens.

In diesem Leitfaden werden wir zwei wichtige Arbeitsabläufe behandeln:

1. Devstral lokal mit Mistral-Inferenz ausführen.
2. Integration von Devstral mit OpenHands für den Aufbau von Machine Learning Projekten.

Devstral lokal ausführen

Um Devstral lokal auszuführen, verwenden wir eine Runpod-Instanz mit GPU-Unterstützung, laden das Modell von Hugging Face herunter und interagieren damit mit dem mistral-chat CLI-Tool.

1. Richte den Pod mit 100 GB Speicherplatz und der A100 SXM GPU ein und starte die JupyterLab-Instanz.

2. Führe die folgenden Befehle in einem Jupyter Notebook aus, um die notwendigen Abhängigkeiten zu installieren:

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

3. Nutze den Hugging Face Hub, um die Modelldateien, den Tokenizer und die Parameterkonfiguration herunterzuladen. 

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. Öffne ein Terminal in JupyterLab und führe den folgenden Befehl aus, um die mistral-chat CLI zu starten:

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

5. Probiere die folgende Eingabeaufforderung aus, um Devstral zu testen:

"Eine REST-API von Grund auf mit Python erstellen".

Das Modell hat eine detaillierte und genaue Antwort erzeugt, eine Schritt-für-Schritt-Anleitung zum Aufbau einer REST-API mit 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 mit OpenHands ausführen

Über die Mistal AI API kannst du ganz einfach auf das Devstral-Modell zugreifen. In diesem Projekt werden wir die Devstral API zusammen mit OpenHands nutzen, um unser maschinelles Lernprojekt von Grund auf aufzubauen. OpenHands ist eine Open-Source-Plattform, die dir als KI-Software-Ingenieur bei der Erstellung und Fertigstellung deines Coding-Projekts dient.

1. Besuche die Mistral AI Plattform und generiere deinen API-Schlüssel.

2. Lade $5 mit der Debit-/Kreditkarte auf dein Konto. 

3. Führe das folgende Skript aus, um 

• Setze den API-Schlüssel als Umgebungsvariable.
• Ziehe das OpenHands Docker-Image.
• Erstelle eine Konfigurationsdatei.
• Starte die OpenHands-Anwendung in einem Docker-Container.

# 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

Die Webanwendung wird verfügbar sein unter 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 in OpenHands testen

1. Klicke auf die Schaltfläche "Von Grund auf neu starten", um mit der Erstellung eines Projekts zu beginnen.

2.   Du wirst auf die neue Benutzeroberfläche weitergeleitet, die ein Chat-Interface und weitere Registerkarten für die Entwicklung enthält.

3. Verwende die Chat-Schnittstelle, um Aufforderungen zu geben. Innerhalb der nächsten Sekunde beginnt Devstral mit der Erstellung von Verzeichnissen, Dateien und Code für das Projekt.

4. Wechsle zur Registerkarte VS-Code, um den generierten Code anzuzeigen, zu bearbeiten und auszuführen.

5. Devstral ist so gut, dass es die Anwendung gestartet hat, in der Webanwendung testet und auch den Webagenten zum Surfen auf der Webseite verwendet.

Sobald das Projekt fertig ist, kannst du es auf GitHub veröffentlichen und mit deinem Team teilen.

Fazit

Devstral ist eine gute Nachricht für die Open-Source-Gemeinschaft. Du kannst OpenHands mit Ollama oder VLLM verwenden, um das Modell lokal auszuführen und dann über die OpenHands-Benutzeroberfläche mit ihm zu interagieren. Außerdem kannst du Devstral mithilfe von Erweiterungen in deinen Code-Editor integrieren, was es zu einer äußerst effektiven Option macht.

In diesem Tutorial haben wir Devstral, ein agentenbasiertes Kodierungsmodell, erkundet und seine Fähigkeiten getestet, indem wir es lokal und mit OpenHands ausgeführt haben. Die Ergebnisse waren beeindruckend. Devstral ist schnell, hochpräzise und zeichnet sich dadurch aus, dass es Agenten zur Ausführung komplexer Aufgaben aufruft. Seine Fähigkeit, reale Herausforderungen in der Softwareentwicklung schnell und präzise zu bewältigen, macht es zu einer hervorragenden Wahl für Entwickler.

Du kannst mehr über Agentic AI erfahren in unserem Blogartikel erfahren und kannst mit unserem Kurs selbst Hand anlegen, Agentische Systeme mit LangChain entwerfen.