Chaque exemple cité dans cet article a été réalisé avec succès grâce à Devstral, même s’il n’est pas toujours présenté visuellement.
Qu'est-ce que Devstral ?
Mistral AI a annoncé le lancement de Devstral, un nouveau modèle open source orienté ingénierie logicielle le 21 mai 2025.
Devstral est un modèle LLM agentique open source, conçu principalement pour les tâches de développement logiciel, c’est-à-dire la résolution de problèmes de programmation multi‑étapes dans de grands projets de code. Ce modèle est finement optimisé pour les agents de codage autonomes, capables de naviguer dans des bases de code complexes, modifier plusieurs fichiers, proposer des corrections tout en agissant de manière “agentique”.
Ce qui le distingue :
Devstral a été développé en collaboration avec All Hands AI pour résoudre des problèmes complexes de développement (problèmes GitHub réelles) en se comportant comme un véritable agent : il analyse de larges bases de code, modifie plusieurs fichiers et exécute des tests pour valider ses changements.
Il obtient également un score de 46,8 % sur le benchmark SWE-Bench Verified* (500 problèmes réelles), surpassant les modèles open source plus volumineux (DeepSeek-V3-0324, Qwen3-232B-A22B) et certains modèles fermés comme GPT-4.1-mini.
*(SWE‑Bench Verified est un benchmark (jeu de tests) utilisé pour évaluer la capacité des modèles d'IA à résoudre de vrais bugs logiciels dans des projets open-source GitHub).
Comparaison des modèles IA sur SWE-Bench Verified
Avec seulement 24 milliards de paramètres et une fenêtre de contexte de 128 k tokens, issu de Mistral Small 3.1, Devstral peut tourner en local sur une RTX 4090 ou sur un Mac avec 32 Go de RAM, ce qui fait de lui un modèle léger et puissant.
Il possède également la licence Apache 2.0 complète ce qui signifie qu'il peut être aussi bien utilisé pour un usage personnel que commercial, la modification du modèle est également autorisée tout comme la redistribution de celui-ci qui est totalement libre.
Enfin il s’intègre de manière fluide aux frameworks d’agent comme OpenHands, SWE-Agent ou OpenDevin, qui orchestrent son interaction avec le code et l’environnement de développement. Il excelle pour inspecter et modifier plusieurs fichiers ainsi que dans la correction des bugs directement dans un dépôt.
Prérequis et installation en local
Nous avons vu précédemment ce qu'était Devstral, nous allons à présent détailler les prérequis nécessaires à son utilisation en local, tant au niveau matériel que logiciel. Nous aborderons également trois méthodes d'utilisation : en ligne de commande, via un plugin, et en utilisant OpenHands.
Matériel recommandé
Pour une utilisation fluide et optimale de Devstral, il est conseillé de disposer d’une machine avec les caractéristiques suivantes :
- GPU : minimum 24 Go de VRAM
- RAM : entre 32 et 64 Go
- Stockage : SSD NVMe recommandé
- CPU : processeur 8 cœurs ou plus (surtout si vous ne disposez pas de GPU)
Il est toutefois possible d’utiliser Devstral avec une configuration plus modeste. Cependant, les performances seront fortement impactées, notamment en termes de temps de réponse. Voici une configuration minimale pour débuter :
- GPU : au moins 12 Go de VRAM
- RAM : 16 Go
- Stockage : 10 Go d’espace libre
- CPU : processeur 4 cœurs
Prérequis logiciel
Devstral est compatible avec Linux, macOS, et Windows (ce dernier étant recommandé avec WSL). Il nécessite au minimum Python 3.9. Si vous utilisez un GPU Nvidia il vous faudra une version supérieure à 11.8 pour CUDA (Outil qui permet de faire des calculs lourds sur le GPU plutôt que sur le CPU).
Les instructions d’installation et les exemples qui vont suivre ont été réalisés sur une machine Linux. Il se peut donc que certaines étapes diffèrent légèrement selon votre système d’exploitation.
Installation via Ollama
Ollama est un outil open-source puissant permettant d’exécuter des LLM localement. J'ai choisi Ollama car il est très simple à installer et utiliser, qu'il peut tourner sur tous les systèmes d'exploitation et permet facilement le téléchargement et l'exécution d'énormément de modèles. Il existe également d'autres alternatives avec LM Studio, llama.cpp, GPT4All, etc..Pour des cas d'usages simples mais néanmoins robuste Ollama et LM Studio seront privilégiés.
Pour les machines Windows et Mac il suffit de se rendre sur https://ollama.com/download et télécharger le .exe et .dmg respectivement et de l’exécuter. Pour linux il faudra lancer la commande suivante dans un terminal :
curl -fsSL https://ollama.com/install.sh | shUne fois ollama installé il faudra lui demander de récupérer Devstral, pour ce faire il faudra lancer la commande :
ollama pull devstralSi vous exécutez la commande telle quelle, la dernière version de Devstral sera automatiquement téléchargée. Si vous souhaitez utiliser une version spécifique, vous pouvez le faire en remplaçant le mot-clé devstral dans la commande par le nom exact de la version désirée. (par exemple : ollama pull devstral:24b-small-2505-q8_0)
Le téléchargement pèse environ 15 Go, il faudra donc patienter quelques minutes selon la vitesse de votre connexion.
Une fois le téléchargement terminé, vous pouvez lancer Devstral avec la commande suivante :
ollama run devstralUne fois devstral lancé vous devriez obtenir un terminal similaire à celui-ci :
Exécution de la commande de lancement de Devstral par Ollama dans un terminal
Mise en place via Plugin
Il existe plusieurs plugins pour IntelliJ permettant d'intégrer un agent de code préalablement téléchargé en local, afin d’utiliser l’assistant de votre choix. Dans mon cas, j’ai opté pour le plugin MyOllamaEnhancer. Pour les utilisateurs de VS Code, plusieurs extensions similaires sont également disponibles, telles que Ollama Dev Companion ou VSCode Ollama.
Ces plugins nécessitent que Devstral ait été installé au préalable via Ollama, comme décrit dans la section précédente.
En ce qui concerne l'installation et la configuration de MyOllamaEnhancer il suffit de le télécharger via le marketplace d'IntelliJ via le menu Settings > Plugin. Une fois celui-ci téléchargé il faudra le configurer comme tel :
Configuration de MyOllamaEnhancer dans IntelliJ
Attention à bien modifier le champ Ollama Model par le modèle spécifique que vous avez téléchargé via Ollama.
Installation via OpenHands
Il s'agit du cas d’usage le plus courant pour ce type de LLM agentique, car c’est dans ce contexte qu’il donne les meilleurs résultats. (Nous verrons d’ailleurs des exemples concrets dans le chapitre suivant)
Avant toute chose, vous devez générer une clé d’API Mistral. Cela peut se faire gratuitement en vous rendant à l’adresse suivante : https://console.mistral.ai/api-keys.
Une fois votre clé obtenue, ouvrez un terminal et exécutez les commandes suivantes :
# Store the API key securely as an environment variable (avoid hardcoding in scripts)
export MISTRAL_API_KEY=<MY_KEY>en remplaçant <MY_KEY> par la clé API créée précédemment.
# Pull the runtime image for OpenHands
docker pull docker.all-hands.dev/all-hands-ai/runtime:0.48-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.48-nikolaik \
-e LOG_ALL_EVENTS=true \
-v /var/run/docker.sock:/var/run/docker.sock \
-v ~/.openhands-state:/.openhands-state \
-p 3000:3000 \
--add-host host.docker.internal:host-gateway \
--network=host \
--name openhands-app \
docker.all-hands.dev/all-hands-ai/openhands:0.48À la suite de l’exécution de cette dernière commande, l'application web va se lancer et sera disponible à l'adresse http://0.0.0.0:3000. Vous devriez avoir une interface ressemblant à celle-ci :
Interface d'accueil d'OpenHands
Devstral : un compagnon à toutes épreuves ?
Nous avons exploré plusieurs façons d’installer Devstral en local. Toutefois, toutes ne se valent pas en termes d’efficacité. À travers différents exemples, nous allons maintenant voir comment utiliser Devstral de manière optimale selon la méthode choisie.
En utilisant la version CLI
Si on reprend notre terminal où nous l'avions laissé après avoir lancé Devstral via Ollama, celui-ci attend un prompt afin de pouvoir nous assister.
Nous commençons avec une demande assez basique d'écriture de javadoc pour une méthode écrite en Java :
Génération de documentation Java avec Devstral dans un terminal
Pour une action simple telle que celle-ci où l'environnement de développement n'a que peu de valeur, la réponse du prompt est plutôt efficace et peut être utilisée directement dans votre projet ou avec très peu d'ajustement.
En second exemple, on va lui passer une méthode assez complexe mais très mal structurée et difficile à maintenir inspirée du kata GildedRose. Voici le prompt ainsi que la méthode passé au prompt :
Refacto le code suivant pour une meilleur lisibilité et maintenabilitépublic void updateQuality() {
for (int i = 0; i < items.length; i++) {
if (!items[i].name.equals("Aged Brie")
&& !items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) {
if (items[i].quality > 0) {
if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) {
items[i].quality = items[i].quality - 1;
}
}
} else {
if (items[i].quality < 50) {
items[i].quality = items[i].quality + 1;
if (items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) {
if (items[i].sellIn < 11) {
if (items[i].quality < 50) {
items[i].quality = items[i].quality + 1;
}
}
if (items[i].sellIn < 6) {
if (items[i].quality < 50) {
items[i].quality = items[i].quality + 1;
}
}
}
}
}
if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) {
items[i].sellIn = items[i].sellIn - 1;
}
if (items[i].sellIn < 0) {
if (!items[i].name.equals("Aged Brie")) {
if (!items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) {
if (items[i].quality > 0) {
if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) {
items[i].quality = items[i].quality - 1;
}
}
} else {
items[i].quality = items[i].quality - items[i].quality;
}
} else {
if (items[i].quality < 50) {
items[i].quality = items[i].quality + 1;
}
}
}
}
}Le résultat est le suivant :
public void updateQuality() {
for (Item item : items) {
updateItem(item);
}
}
private void updateItem(Item item) {
if (isSulfuras(item)) {
return; // Sulfuras does not change
}
updateQualityBasedOnName(item);
updateSellIn(item);
if (item.sellIn < 0) {
handleExpiredItem(item);
}
}
private boolean isSulfuras(Item item) {
return "Sulfuras, Hand of Ragnaros".equals(item.name);
}
private void updateQualityBasedOnName(Item item) {
if ("Aged Brie".equals(item.name)) {
increaseQuality(item, 1);
} else if ("Backstage passes to a TAFKAL80ETC concert".equals(item.name)) {
handleBackstagePasses(item);
} else {
decreaseQuality(item, 1);
}
}
private void handleBackstagePasses(Item item) {
int qualityIncrease = getBackstagePassesQualityIncrease(item.sellIn);
increaseQuality(item, qualityIncrease);
}
private int getBackstagePassesQualityIncrease(int sellIn) {
if (sellIn < 0) {
return -item.quality; // Quality drops to 0
} else if (sellIn < 6) {
return 3;
} else if (sellIn < 11) {
return 2;
} else {
return 1;
}
}
private void increaseQuality(Item item, int amount) {
if (item.quality + amount <= 50) {
item.quality += amount;
} else {
item.quality = 50;
}
}
private void decreaseQuality(Item item, int amount) {
if (item.quality - amount >= 0) {
item.quality -= amount;
} else {
item.quality = 0;
}
}
private void updateSellIn(Item item) {
item.sellIn--;
}
private void handleExpiredItem(Item item) {
if ("Aged Brie".equals(item.name)) {
increaseQuality(item, 1);
} else if ("Backstage passes to a TAFKAL80ETC concert".equals(item.name)) {
item.quality = 0;
} else {
decreaseQuality(item, 1);
}
}
Pour ce second exemple, la réponse fournie est effectivement beaucoup plus lisible et maintenable que la méthode d'origine. En revanche on commence à apercevoir certaines erreurs et notamment sur cette méthode :
Erreur lors du refactoring du code GildedRose avec Devstral
Item n'est pas défini donc il y a une incohérence. Sans un vrai environnement à lui fournir, Devstral devient beaucoup moins performant et fait des erreurs qu'une autre IA ne ferait pas forcément en temps normal.
Devstral est avant tout conçu pour fonctionner dans un environnement complet et peut absorber une grande quantité de données afin de proposer la solution adéquate à l’environnement dans lequel il évolue.
En utilisant le plugin MyOllamaEnhancer
Après avoir installé le plugin dans Intellij, lorsque vous effectuez un clic droit sur un texte sélectionné et que vous choisissez "Enhance this with options", plusieurs options seront proposées : meilleure lisibilité, ajout d'un commentaire, réparer un bug, créer un test unitaire, etc..
Fenêtre d'options du plugin MyOllamaEnhancer dans IntelliJ
La deuxième possibilité consiste à effectuer un clic droit sur un morceau de texte, puis à choisir l’option "Enhance this with prompt".
Contrairement aux suggestions automatiques, cette action vous permet de formuler manuellement une instruction sur ce que vous souhaitez que Devstral fasse du texte sélectionné.
Cependant, là encore, le potentiel de Devstral reste limité, car l’analyse se fait uniquement sur un fragment isolé de code. Il pourra donc répondre efficacement à des requêtes simples sur du code déjà clair et de complexité modérée, mais ne sera pas en mesure de contextualiser des éléments plus complexes.
En utilisant OpenHands
C’est la méthode la plus adaptée pour exploiter pleinement les capacités d’un LLM agentique comme Devstral.
En effet, il peut ici scanner l’ensemble du contexte du projet avant d’agir, ce qui lui permet de proposer des réponses beaucoup plus pertinentes et ciblées.
Nous allons explorer cette approche à travers deux cas d’usage :
- la création d’un nouveau projet
- l’amélioration d’un projet existant récupéré depuis GitHub
Dans l’exemple qui suit, j’ai choisi de créer un nouveau projet Java Spring Boot, structuré selon une architecture DDD (Domain-Driven Design), avec un cas concret pour illustrer son fonctionnement.
Création d’un projet Java Spring Boot structuré en DDD avec Devstral. Le volet gauche liste en temps réel les actions exécutées, et le volet droit présente les fichiers modifiés
Une fois votre prompt rédigé, Devstral détaille les différentes étapes qu’il s’apprête à exécuter pour atteindre le résultat attendu.
Vous obtenez ainsi un aperçu clair du processus dans le volet gauche de l’interface. C’est dans cet espace que toutes les actions seront listées en temps réel, ce qui vous permet de suivre précisément chaque étape.
Sur la droite, plusieurs onglets vous permettent d’interagir avec le projet :
- Changes : affiche la liste complète des fichiers ajoutés, modifiés ou supprimés
- VS Code : un éditeur VS Code intégré dans OpenHands, offrant une vue en temps réel de l’arborescence du projet et de son contenu
- Browser : permet de prévisualiser le projet localement via un navigateur intégré
Après quelques secondes toutes les actions ont été réalisées par Devstral.
Résumé des actions effectuées après une demande de création de projet Java Spring Boot structuré selon une architecture DDD
En examinant de plus près les actions réalisées, on constate que Devstral a automatiquement généré un projet Spring Boot structuré selon les principes du DDD (Domain-Driven Design), avec une arborescence cohérente respectant cette architecture.
Un exemple concret a été mis en place, incluant les entités Client, Order et Product. Pour chacune d'elles, Devstral a également créé les couches applicative, contrôleur et répertoire, permettant une séparation claire des responsabilités.
Par défaut, Devstral a choisi Gradle comme outil de build, mais il aurait tout aussi bien pu utiliser Maven si cela avait été précisé dans le prompt.
Le projet est configuré pour fonctionner avec la dernière version LTS de Java (Java 21).
Enfin, une configuration pour une base de données H2 a été ajoutée, ainsi qu’une suite complète de tests automatisés en Java.
Ces tests valident les interactions entre les différentes entités et simulent un processus d'achat complet. Tous les tests ont été exécutés avec succès, garantissant le bon fonctionnement de l’ensemble.
Résumé des différentes étapes d'actions en détail
Afin de pouvoir tester l'application en direct, celle-ci est directement lancée en local afin de tester son bon fonctionnement. Dans mon exemple, le projet est lancé sur le port 50020.
Mise à disposition des endpoints utiles de l'application nouvellement créée en local
Pour aller plus loin, nous aurions également pu demander à Devstral de rédiger les tests en Cucumber, afin de mieux refléter les concepts de domaine métier et de renforcer l’alignement avec notre approche orientée DDD.
Il aurait aussi été possible de lui faire :
- Créer un dépôt GitHub et y pousser automatiquement le projet généré
- Configurer un workflow GitHub Actions pour lancer les tests unitaires automatiquement à chaque création de merge request
- Ou encore intégrer d’autres éléments de CI/CD selon nos besoins
C’est précisément dans ce type de scénarios que la qualité du prompt devient essentielle : plus votre demande est précise et détaillée, plus Devstral pourra fournir des résultats pertinents, complets et en phase avec vos attentes.
Nous allons maintenant observer comment Devstral se comporte avec un projet existant.
Dans cet exemple, le projet est récupéré depuis GitHub. Pour cela, plusieurs configurations sont disponibles et nécessaires dans OpenHands, accessibles via le bouton Paramètres.
Configuration de Git dans OpenHands
Une fois la configuration terminée, je peux sélectionner la branche que je souhaite récupérer pour effectuer mes actions.
Après sélection, l’interface que nous avons vue précédemment s’affiche, avec le projet entièrement chargé, conservant son fonctionnement habituel.
Dans cet exemple, nous avons choisi un projet complet comprenant :
- un frontend Angular
- un backend Spring Boot structuré selon une architecture hexagonale et la méthode DDD
- une intégration de Kafka pour la gestion des événements
- une conteneurisation via Docker
- une base de données PostgreSQL
Ces conditions offrent un cadre idéal pour exploiter pleinement les capacités de Devstral.
Nous avons commencé avec une action plutôt simple comme la génération d'une javadoc complète, sans grande surprise Devstral a été très efficace.
Volet d'actions en temps réel
Exemple de documentation générée par Devstral
Pour aller plus loin nous lui demandons de scanner toute la partie frontend du projet afin d'identifier les améliorations possibles.
1. Code Organization and Structure
Routing Module: Create a separate routing module instead of using inline routes in app.routes.ts.
Feature Modules: Consider organizing components into feature modules for better scalability.
2. Error Handling
Global Error Handling: Implement a global error handling mechanism using Angular's ErrorHandler.
User Notifications: Use Angular's MatSnackBar for displaying error messages to users.
3. Form Validation
Enhanced Validation: Add more specific validation rules (minlength, maxlength, pattern) for form fields.
Error Messages: Display validation error messages to users.
4. Styling and Accessibility
Improved Styling: Enhance the styling for better user experience, especially for forms and job lists.
Accessibility: Add ARIA attributes to improve accessibility.
Responsiveness: Ensure the application is responsive and works well on different screen sizes.
5. Performance
Lazy Loading: Implement lazy loading for feature modules.
Bundle Size: Optimize the application's bundle size.
Change Detection: Use onPush change detection strategy where appropriate.
6. Testing
Comprehensive Tests: Ensure all components and services have proper unit tests.
End-to-End Tests: Add end-to-end tests using a tool like Cypress.
Test Coverage: Implement test coverage reporting.
7. API Configuration
Environment Variables: Use environment variables for the API URL in the JobOfferService.
Environment Files: Create different environment files for development, staging, and production.
8. Internationalization (i18n)
i18n Support: Implement i18n support using Angular's i18n tools.
Translations: Extract translatable strings and provide translations for different languages.
9. Security
Input Validation: Implement proper input validation and sanitization to prevent XSS attacks.
HTTPS: Use HTTPS for API calls.
Authentication: Implement authentication and authorization if needed.
10. Documentation
Code Comments: Add comments to explain complex logic in the code.
Application Documentation: Create documentation for the application, including setup instructions, architecture overview, and usage guidelines.Le résumé est plutôt pertinent au vu du code actuel. On va s'attaquer au point numéro 1 car il faut avant tout que le code soit bien structuré et organisé pour la suite. Il est parfois mieux de découper les demandes que l'on va faire à notre IA pour éviter de se retrouver à faire des modifications partout en cas d'une erreur de sa part.
Nous lui demandons donc de restructurer et d'organiser au mieux le code de toute notre partie frontend via le prompt suivant :
Améliore la structure et l’organisation de toute la partie frontend du projet. Regroupe le code en commun et rend le code plus maintenable.
Résumé des actions réalisées en détail dans le cadre d'une amélioration structurelle et organisationnelle de la partie frontend d'un projet complet
Interface VSCode intégrée à OpenHands listant les fichiers du projets ainsi que les modifications apportées
Le résultat est plus que satisfaisant puisque beaucoup de code a été centralisé et Devstral nous a également corrigé les erreurs qui interviennent à la suite de ces changements. Pour un total de 11 fichiers modifiés, aucune erreur de build à remonter et tous les tests validés, on peut dire que c'est un succès.
"Mais alors avons nous trouvé l'assistant de code parfait ?"
Mistral gagnant ?
Aujourd'hui de nombreuses entreprises peinent encore à intégrer pleinement des outils d’IA dans leurs processus, c’est souvent en raison de préoccupations légitimes liées à la confidentialité et au partage de données sensibles. Dans ce contexte, Devstral se démarque en offrant la possibilité d’une utilisation entièrement locale, sans nécessité d’accès à Internet. Cette approche garantit que le traitement et l’analyse des données se font en interne, éliminant ainsi les risques liés à la transmission vers des serveurs externes, tout en conservant les avantages d’un modèle de langage puissant et spécialisé.
Celui-ci n’est pas exempt de défauts pour autant, il lui arrive fréquemment de générer du code inutile, ou parfois de produire des solutions trop complexes ou au contraire insuffisantes selon la taille et la nature du projet. Mais il n'est pas le seul responsable puisqu’aujourd'hui la qualité et la précision du prompt restent essentielles pour orienter au mieux l’IA.
Devstral ne se résume pas à une simple intelligence artificielle, il est conçu pour devenir un assistant de développement du quotidien. Cela passe par l'adoption d'une approche itérative de vos tâches mais également de l'utiliser dans un contexte complet et complexe pour en tirer le meilleur apport. Les projets bien fournis (architectures et concepts avancés, configuration CI, microservice, conteneurisation, etc..) sont le terrain de jeu idéal pour Devstral. Bien qu'il ne soit pas parfait, il peut vous permettre de gagner un temps considérable au quotidien.
Mistral a d'ores et déjà annoncé qu'il travaillait sur une version Devstral Large et qu'il serait prochainement disponible.
L’IA évoluant à une vitesse exponentielle, il est aujourd'hui impossible de prédire avec certitude comment les agents de code vont évoluer. Ce qui est certain, c’est qu’ils deviendront de plus en plus performants, et qu’il sera crucial de les intégrer dans des cas d’usage spécifiques pour maximiser les gains en termes de temps et de qualité.
Le futur du code est entre vos mains… et un peu entre celles de Devstral aussi !
