Guide de démarrage rapide Devstral : Exécutez localement le LLM de Mistral AI

Il semble que les nouveaux modèles d'IA arrivent à un rythme rapide, et Mistral AI a ajouté à l'excitation avec le lancement de Devstral, un modèle de codage révolutionnaire à source ouverte. Devstral est un grand modèle de langage (LLM) de codage agentique qui peut être exécuté localement sur un GPU RTX 4090 ou un Mac avec 32 Go de RAM, ce qui le rend accessible pour un déploiement local et une utilisation sur l'appareil. Il est rapide, précis et facile à utiliser. 

Dans ce tutoriel, nous allons apprendre tout ce que vous devez savoir sur Devstral, y compris ses principales caractéristiques et ce qui le rend unique. Nous apprendrons également à exécuter Devstral localement à l'aide d'outils tels que Mistral Chat CLI et à intégrer l'API Mistral AI à OpenHands pour tester les capacités agentiques de Devstral.

Vous pouvez en savoir plus sur les autres outils de Mistral dans des guides distincts, notamment Mistral Medium 3, Mistral OCR APIde Mistral, et Mistral Le Chat.

Qu'est-ce que le Mistral Devstral ?

Devstral est un modèle agentique de pointe conçu pour les tâches d'ingénierie logicielle. Il a été développé par Mistral AI en collaboration avec All Hands AI. Il excelle dans la résolution de problèmes de codage réels, tels que l'exploration de grandes bases de code, l'édition de plusieurs fichiers et la résolution de problèmes sur le dépôt GitHub. 

Les performances de Devstral sur le benchmark SWE-Bench Verified sont inégalées, avec un score de 46,8 %, ce qui le positionne comme le premier modèle open-source sur ce benchmark, dépassant de 6 % les modèles de pointe antérieurs.

Source : Devstral | Mistral AI

Construit sur Mistral-Small-3.1, Devstral dispose d'une fenêtre contextuelle de 128k, ce qui lui permet de traiter et de comprendre de grandes quantités de code et de dépendances. Contrairement à son modèle de base, Devstral est uniquement textuel, car l'encodeur de vision a été supprimé lors de la mise au point afin de le spécialiser pour les tâches de codage. 

Sa capacité à fonctionner de manière transparente avec des outils tels que OpenHands lui permet de surpasser même des modèles beaucoup plus grands, tels que Deepseek-V3-0324 (671B) et le Qwen3 232B-A22B.

Principales caractéristiques de Devstral

Voici quelques caractéristiques notables de Devstral qui le distinguent des autres modèles de codage.

1. Codage agentique

Devstral est spécialement conçu pour exceller dans les tâches de codage agentique, ce qui en fait un modèle idéal pour la construction et le déploiement d'agents de génie logiciel. Sa capacité à résoudre des tâches complexes, en plusieurs étapes, au sein de grandes bases de code, permet aux développeurs de relever efficacement les défis du codage dans le monde réel.

2. Conception légère

L'une des caractéristiques principales de Devstral est son architecture légère. Avec seulement 24 milliards de paramètres, il peut fonctionner sur un seul GPU Nvidia RTX 4090. Cette caractéristique en fait un outil idéal pour le déploiement local, l'utilisation sur l'appareil et les applications sensibles au respect de la vie privée.

3. Source ouverte 

Publié sous la licence Apache 2.0, Devstral est disponible gratuitement pour une utilisation commerciale. Les développeurs et les organisations peuvent le déployer, le modifier et même l'intégrer dans des produits propriétaires sans restrictions.

4. Fenêtre contextuelle étendue

Devstral dispose d'une impressionnante fenêtre contextuelle de 128k, ce qui lui permet de traiter et de comprendre de grandes quantités de code et d'instructions en une seule interaction. Il est donc particulièrement efficace pour travailler avec de grandes bases de code et résoudre des problèmes de programmation complexes.

5. Un tokenizer avancé

Devstral utilise un tokenizerTekken avec un vocabulaire de 131k, ce qui lui permet de traiter les entrées de code et de texte avec précision et efficacité. Ce tokenizer améliore la capacité du modèle à générer des réponses précises et contextuelles adaptées aux tâches d'ingénierie logicielle.

Démarrer avec Devstral

Devstral est disponible gratuitement en téléchargement sur des plateformes telles que Hugging Face, Ollama, Kaggle, Unsloth et LM Studio. Les développeurs peuvent également y accéder via l'API sous le nom de devstral-small-2505 à des prix compétitifs : 0,10 $ par million de jetons d'entrée et 0,30 $ par million de jetons de sortie.

Dans ce guide, nous aborderons deux flux de travail clés :

1. Exécuter Devstral localement en utilisant l'inférence Mistral.
2. Intégration de Devstral avec OpenHands pour la construction de projets d'apprentissage automatique.

Exécuter Devstral localement

Pour exécuter Devstral localement, nous utiliserons une instance Runpod avec support GPU, téléchargerons le modèle depuis Hugging Face, et interagirons avec lui en utilisant l' outil CLI mistral-chat.

1. Configurez le pod avec un stockage de 100 Go et un GPU A100 SXM, et lancez l'instance JupyterLab.

2. Exécutez les commandes suivantes dans un carnet Jupyter pour installer les dépendances nécessaires :

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

3. Utilisez le Hugging Face Hub pour télécharger les fichiers du modèle, le tokenizer et la configuration des paramètres. 

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. Ouvrez un terminal dans JupyterLab et exécutez la commande suivante pour démarrer le CLI mistral-chat:

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

5. Essayez l'invite suivante pour tester Devstral :

"Créer une API REST à partir de zéro en utilisant Python".

Le modèle a généré une réponse détaillée et précise, un guide étape par étape pour construire une API REST à l'aide de 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
=====================

Exécuter Devstral avec OpenHands

Vous pouvez facilement accéder au modèle Devstral via l'API Mistal AI. Dans ce projet, nous utiliserons l'API Devstral ainsi que le logiciel OpenHands pour construire notre projet d'apprentissage automatique à partir de la base. OpenHands est une plateforme open-source qui vous sert d'ingénieur logiciel IA pour construire et réaliser votre projet de codage.

1. Visitez la plateforme Mistral AI et générez votre clé API.

2. Chargez 5 $ sur votre compte à l'aide de la carte de débit/crédit. 

3. Exécutez le script suivant pour 

• Définissez la clé API en tant que variable d'environnement.
• Téléchargez l'image Docker OpenHands.
• Créer un fichier de configuration.
• Démarrez l'application OpenHands dans un conteneur Docker.

# 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

L'application web sera disponible à l'adresse suivante 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)

Tester Devstral dans OpenHands

1. Cliquez sur le bouton "Launch from Scratch" pour commencer à construire un projet.

2.   Vous serez redirigé vers la nouvelle interface utilisateur, qui comporte une interface de discussion et d'autres onglets pour l'inférence du développement.

3. Utilisez l'interface de chat pour fournir des messages-guides. Dans la seconde qui suit, Devstral commence à créer des répertoires, des fichiers et du code pour le projet.

4. Passez à l'onglet VS Code pour visualiser, modifier et exécuter le code généré.

5. Devstral est si bon qu'il a démarré l'application, testé l'application web et utilisé l'agent web pour naviguer sur la page web.

Une fois le projet terminé, publiez-le sur GitHub pour le partager avec votre équipe.

Conclusion

Devstral est une excellente nouvelle pour la communauté des logiciels libres. Vous pouvez utiliser OpenHands avec Ollama ou VLLM pour exécuter le modèle localement et interagir avec lui via l'interface utilisateur OpenHands. De plus, vous pouvez intégrer Devstral dans votre éditeur de code à l'aide d'extensions, ce qui en fait une option très efficace.

Dans ce tutoriel, nous avons exploré Devstral, un modèle de codage agentique, et testé ses capacités en l'exécutant localement et en utilisant OpenHands. Les résultats sont impressionnants. Devstral est rapide, très précis et excelle dans l'invocation d'agents pour effectuer des tâches complexes. Sa capacité à relever les défis de l'ingénierie logicielle dans le monde réel avec rapidité et précision en fait un choix de premier ordre pour les développeurs.

Vous pouvez en savoir plus sur l'IA agentique grâce à notre article de blog, et vous pouvez mettre la main à la pâte avec notre cours, Concevoir des systèmes agentiques avec LangChain.