Agentic Coding avec appel d'outils
På denna sida
Leçon mise à jour le 2 novembre 2026. Les exemples originaux utilisaient Devstral, qui a été retiré de l’API le 31 juillet 2026. Ils utilisent désormais Mistral Small 4 (
mistral-small-2603), et la boucle agentique suit le modèle de la documentation Mistral (tous les appels d’outils dans une réponse sont traités jusqu’à la réponse finale). Source : Function calling.
Qu’est-ce que l’agentic coding ?
L’agentic coding change la nature de ce que tu demandes au modèle de faire. Au lieu de demander un extrait, puis un autre, puis un troisième, et de les assembler toi-même, tu assigns une tâche complète. Le modèle la résout en enchaînant les étapes lui-même : exploration, planification, implémentation et vérification. Tu restes le décideur de ce qui doit être fait, mais tu arrêtes de micro-gérer chaque mouvement.
Les modèles Devstral ont été conçus pour ce flux de travail ; les modèles polyvalents actuels, menés par Mistral Small 4, le gèrent via l’appel d’outils. Un agent ne se contente pas de répondre à une question ; il agit sur le dépôt.
Le cycle agentique
Phase 1 — Comprendre
L’agent commence toujours par prendre ses repères. Il lit la structure des dossiers et des fichiers, identifie les fichiers pertinents pour la tâche demandée, trace les dépendances entre les modules pour voir ce qu’un changement pourrait affecter, et note les conventions existantes : nommage, organisation des tests et motifs récurrents. Cette phase semble improductive car elle n’écrit aucun code, pourtant elle détermine si le code résultant ressemblera au tien ou à celui d’un inconnu.
Phase 2 — Planifier
Avant d’écrire une seule ligne, l’agent formule un plan. Il décompose la tâche en sous-tâches ordonnées, distingue les fichiers à modifier de ceux à créer, anticipe les effets de bord et les risques de régression, et arrête une approche technique. C’est à ce moment que ton intervention coûte le moins cher : corriger un plan prend trente secondes ; corriger dix fichiers que tu as déjà écrits prend beaucoup plus de temps.
Phase 3 — Exécuter
L’implémentation déploie le plan étape par étape. L’agent modifie les fichiers existants, en crée de nouveaux lorsque la structure l’exige, met à jour les imports et les dépendances déplacés par ses changements, et ajuste les fichiers de configuration au passage. La cohérence de ces changements est exactement ce qu’un modèle de complétion ne peut garantir.
Phase 4 — Vérifier
Enfin vient la preuve que le travail tient la route. L’agent exécute la suite de tests existante, écrit de nouveaux tests pour le code qu’il vient d’ajouter, s’assure que la construction passe, et examine son propre diff pour détecter des erreurs ou des modifications parasites. Un agent qui saute cette phase produit du code plausible, pas du code correct.
Exemple concret : correction d’un bug
Supposons que tu dises à l’agent : « Les utilisateurs obtiennent une erreur 500 lorsqu’ils soumettent un formulaire avec un e-mail contenant un ’+’ ». Le cycle prend alors cette forme :
1. COMPRENDRE
-> Rechercher les fichiers liés au formulaire (rechercher "email" dans le code)
-> Lire le contrôleur gérant la soumission
-> Lire la fonction de validation des e-mails
-> Identifier l'expression régulière rejetant le '+'
2. PLANIFIER
-> Modifier l'expression régulière de validation pour accepter le '+'
-> Ajouter un test unitaire pour les e-mails avec '+'
-> Vérifier qu'aucune autre partie du code ne filtre le '+'
3. EXÉCUTER
-> Modifier src/validators/email.py : corriger le motif regex
-> Créer tests/test_email_validation.py : ajouter des cas avec '+'
-> Modifier src/controllers/form.py : ajouter un log pour le débogage
4. VÉRIFIER
-> Exécuter pytest -> tous les tests passent
-> Vérifier le diff -> les changements sont cohérents et minimaux
Remarque la troisième ligne du plan : l’agent ne se contente pas de corriger là où le bug se manifeste ; il vérifie qu’aucun autre filtre ne rejette le caractère ailleurs. Cette recherche de la cause racine, plutôt que du simple symptôme, est ce qui distingue une correction agentique d’un rustine ponctuelle.
Utilisation d’outils en pratique
L’agent agit sur son environnement via des appels de fonctions. Tu déclares les outils disponibles dans la requête, y compris leur nom, leur description et leur schéma de paramètres ; le modèle choisit lesquels appeler et avec quels arguments.
# Exemple d'une conversation agentique
messages = [
{
"role": "user",
"content": "Ajoute une validation de mot de passe fort au module d'authentification."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Lire le contenu d'un fichier du projet",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Chemin du fichier"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Écrire ou modifier un fichier du projet",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Exécuter une commande shell",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # valeur par défaut : le modèle décide s'il doit appeler un outil
)
Pour cette requête, la séquence typique commence par read_file("src/auth/validators.py") pour comprendre le code existant, continue avec read_file("tests/test_auth.py") pour voir le format des tests actuels, puis passe à l’écriture : write_file("src/auth/validators.py", ...) avec la règle de validation ajoutée, write_file("tests/test_auth.py", ...) avec les nouveaux cas, et enfin run_command("pytest tests/test_auth.py") pour vérifier. L’ordre compte : en ouvrant les deux fichiers avant de toucher un seul caractère, l’agent reprend tes conventions et les reproduit, au lieu d’en importer vues ailleurs.
Boucle agentique multi-tours
Rien de tout cela ne se produit en un seul appel. Le cœur de l’agentic coding est la boucle multi-tours : le modèle propose une action, ton code l’exécute, et tu renvoies le résultat pour qu’il puisse décider de l’étape suivante. Tu gardes le contrôle de l’exécution réelle, ce qui sert aussi de garde-fou de sécurité.
import json
TOOLS = {"read_file": read_file, "write_file": write_file, "run_command": run_command}
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
for _ in range(30): # garde-fou : un agent ne doit jamais boucler indéfiniment
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # plus d'appels d'outils : la réponse finale est arrivée
for tool_call in tool_calls: # une réponse peut contenir plusieurs appels
name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
result = TOOLS[name](**arguments)
messages.append({
"role": "tool",
"name": name,
"content": str(result),
"tool_call_id": tool_call.id,
})
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
print(response.choices[0].message.content)
Trois détails comptent. Le message de l’agent et chaque résultat d’outil sont réinjectés dans l’historique, appariés par le tool_call_id : omets l’un ou l’autre, et l’agent perd le fil, rappelant les mêmes outils en boucle. Une seule réponse peut contenir plusieurs appels d’outils, car les appels parallèles sont autorisés par défaut (parallel_tool_calls=False les interdit) : traite-les tous. Enfin, limite le nombre de tours et fais valider les commandes shell et les écritures de fichiers par un humain : un agent qui exécute tout ce qu’il propose est un risque, pas un gain de temps.
Viktiga punkter
- L’agentic coding suit un cycle : comprendre, planifier, exécuter, vérifier
- L’agent agit sur le dépôt via l’appel d’outils (
tools,tool_choice) - La boucle multi-tours permet à l’agent d’itérer jusqu’à la résolution complète
- L’agent modifie plusieurs fichiers de manière cohérente en une seule tâche
- La phase de vérification (tests, build) est essentielle pour la fiabilité