Créer un agent IA en Python : tutoriel pas-à-pas avec code

Comprendre ce qu’est un agent IA et ses concepts fondamentaux

Un agent IA est un programme qui confie le choix de ses actions à un LLM. Là où ChatGPT, Gemini ou Claude agissent comme des cerveaux puissants sans « mains », un agent utilise ce cerveau pour décider d’agir : appeler une API, lire un fichier, envoyer un e-mail. Le modèle seul produit du texte ; l’agent agit.

• Agent confie ses actions au LLM le modèle décide, le code exécute.
• Modèle seul produit du texte il ne peut ni lire un fichier, ni envoyer une requête HTTP sans outils.
• Boucle observer-décider-agir l’agent observe le contexte, décide de l’étape suivante, agit, puis recommence.
• Différence avec simple chatbot le chatbot répond une fois ; l’agent enchaîne les actions pour atteindre un objectif.
• Outils via function calling c’est l’interface qui permet au LLM de déclencher des tâches dont il n’a pas les informations intégrées.

Cette boucle repose sur 3 modules : la perception (comprendre la demande), la prise de décision (choisir un outil), et l’action (exécuter la tâche). Dans 90 % des cas, le LLM choisit correctement l’outil ; dans 10 % des cas, il faudra une correction manuelle ou une validation supplémentaire.

Avant de plonger dans le code, retenez cette idée : un agent n’est pas un chatbot amélioré, c’est un système en boucle avec une mémoire qui s’enrichit à chaque itération. C’est cette architecture que vous allez construire pas-à-pas dans la suite du tutoriel.

Créer un agent IA pas-à-pas avec Python

Comprendre la boucle agentique avant d’utiliser un framework

Avant de vous tourner vers LangChain ou smolagents, il est essentiel de construire la boucle à la main. Cette approche, souvent négligée, vous permet de comprendre la mécanique interne avant d’utiliser la « magie » des frameworks. Un parcours structuré en 5 étapes, d’une durée totale d’1 h 40, vous guide du squelette le plus simple vers un agent complet et outillé.

Étape 1 : Construire la boucle agentique de base

La boucle agentique repose sur 3 modules fondamentaux : la perception, la prise de décision et l’action. Le squelette minimal fonctionnel doit intégrer ces éléments dans une boucle continue :

– Entrée : réception du prompt utilisateur et de l’état courant
– État : mémoire interne qui s’enrichit à chaque itération
– Décision : le LLM choisit la prochaine action à exécuter
– Action : exécution de l’outil ou génération de la réponse finale

Le point crucial : la sortie structurée JSON est obligatoire. Le LLM doit retourner un objet contenant ` »action »`, ` »arguments »` et ` »justification »`. Sans cette structure stricte, votre agent ne peut pas interpréter les décisions du modèle ni enchaîner les étapes. Cette discipline garantit que l’agent, dans 90 % des cas, exécute la bonne action les 10 % restants nécessitant une validation humaine ou une boucle de correction.

Étape 2 : Ajouter des outils et la mémoire

Une fois la boucle de base opérationnelle, vous connectez l’agent au monde réel. Un outil est une fonction Python classique, mais le LLM doit savoir quand et comment l’utiliser. Le typage et les docstrings deviennent essentiels : c’est eux qui guident le modèle dans le choix de l’outil approprié. La mémoire s’ajoute ensuite elle permet à l’agent de conserver le contexte entre les itérations et de ne pas répéter les mêmes erreurs.

Pour structurer votre projet, séparez clairement les responsabilités : `agent.py` pour la boucle, `tools.py` pour les outils, `eval.py` pour les tests. Cette organisation, simple mais rigoureuse, vous évitera de vous perdre lorsque l’agent gagnera en complexité.

Configurer son environnement de développement Python

• Environnement virtuel isolé : obligatoire dès le premier projet (venv ou Poetry).
• Fichier .env : centralise vos clés API sans les exposer dans le code source.
• requirements.txt : verrouillez les versions pour une reproductibilité totale.
• Google Colab : démarrez gratuitement, sans installation locale.
• Docker : garantit une cohérence parfaite entre vos environnements.

Avant d’écrire votre première boucle agentique, il faut préparer un terrain stable. Un environnement virtuel dédié vous évite des conflits de versions entre vos projets : c’est la première brique d’une configuration professionnelle. Utilisez `poetry` ou `uv` si vous voulez une gestion encore plus stricte des dépendances.

La gestion des clés API est un point critique. Rangez-les dans un fichier `.env` à la racine du projet, puis chargez-les via la bibliothèque `python-dotenv`. Cette pratique sécurise vos accès et facilite le partage de code sans fuite de données sensibles. Pour garantir que tout fonctionne après un `git clone`, un `requirements.txt` bien rempli est votre meilleur allié : une seule commande (`pip install -r requirements.txt`) suffit à reproduire l’environnement complet. Le tutoriel IBM utilise notamment Python 3.11.9 comme version de référence.

Si vous débutez, Google Colab est un excellent point de départ : aucune configuration locale nécessaire et une offre gratuite généreuse. Vous pouvez y installer les bibliothèques directement dans les cellules avec `%pip install`. À plus grande échelle, Docker assure une parfaite reproductibilité : l’image contient l’environnement exact, les dépendances et les variables de configuration, éliminant les problèmes de type « ça marche chez moi ».

Créer un agent avec LangChain et ses alternatives

Choisir le bon framework conditionne la vitesse de développement et la maintenabilité de votre agent. Voici une comparaison des options les plus utilisées pour construire un agent IA en Python.

LangChain, le couteau suisse des agents

LangChain s’impose comme le framework le plus complet pour orchestrer des agents complexes. Sa force réside dans sa capacité à connecter plus de 200 modèles IA via une interface unifiée. La méthode bind_tools transmet vos outils au LLM à chaque itération de la boucle agentique. Pour des pipelines qui se ramifient, LangGraph son extension permet de gérer des parcours conditionnels sans blocage, là où un agent simple plafonne.

smolagents et Agno, la légèreté et la mémoire

Pour un tutoriel rapide ou un prototype, smolagents se distingue par sa simplicité : un décorateur @tool suffit à transformer une fonction Python classique en outil utilisable par l’agent. Typage et docstrings sont alors obligatoires, car le framework les analyse pour comprendre comment appeler la fonction.

Agno, de son côté, excelle dans la gestion de la mémoire. Ses capacités short-term et long-term s’appuient sur des bases SQLite ou PostgreSQL, ce qui elle rend parfait pour des agents devant se souvenir des échanges précédents. Le support de MCP (Model Context Protocol) facilite également la connexion à des services externes.

Quel framework pour quel projet ?

Évaluez vos besoins avant de trancher. Pour un projet d’entreprise avec des exigences de robustesse, LangChain reste la référence. Pour une expérimentation rapide ou un agent métier simple, smolagents vous fera gagner un temps précieux. Agno est idéal si la continuité de la conversation est critique. Dans 90 % des cas, un LLM bien configuré produit le résultat attendu ; les 10 % d’erreurs sont souvent dus à une mauvaise définition des outils ou une mémoire mal gérée. Un choix éclairé du framework réduit ces risques dès la conception.

Connecter son agent au monde réel : outils et function calling

Un modèle seul ne peut pas lire un fichier local, interroger une base de données ou déclencher un envoi d’email. Pour cela, il faut lui donner des outils : des fonctions Python classiques que le LLM peut appeler pour exécuter une action concrète. C’est ce qu’on appelle le *function calling*, et c’est la différence entre un agent qui rédige du texte et un agent qui fait des choses.

Définir des outils efficaces avec smolagents et LangChain

La clé pour un outil utile repose sur trois règles simples : un typage strict, une docstring descriptive et une fonction clairement nommée. Le modèle se base uniquement sur ces éléments pour décider quand et comment appeler votre fonction, alors soignez-les autant que votre code.

– Fonction Python typée et documentée : définissez des types précis (`str`, `int`) et expliquez chaque paramètre dans la docstring. Le LLM s’en sert pour générer l’appel correct.
– Décorateur `@tool` analyse la docstring : dans smolagents (bibliothèque open-source de Hugging Face), le décorateur lit automatiquement la description pour construire la fiche de l’outil.
– LangChain : classe `Tool` descriptive : avec LangChain, on passe par `Tool(name= »… », description= »… », func=mon_agent)`. La description doit être ultra-précise sur le périmètre et le résultat.
– `args_schema` valide les arguments : en s’appuyant sur `pydantic.BaseModel`, ce schéma vérifie que les arguments reçus sont corrects avant l’exécution. Une protection essentielle.
– `return_direct` : réponse renvoyée utilisateur : si l’outil produit le résultat final (ex. une recherche de solde), activez ce paramètre pour éviter que le LLM reformule et risque d’introduire une erreur.

Utiliser le function calling pour les appels API

Un cas pratique fréquent : un agent qui interroge une API de météo. Plutôt que de répondre par cœur, le modèle détecte qu’il a besoin d’une donnée externe, appelle votre fonction `get_weather(city: str)`, puis intègre le résultat brut dans sa réponse finale. Attention, cela reste une opération à risque : dans 90 % des cas, le LLM exécute correctement la tâche, mais dans 10 % des cas, il se trompe. Toute action critique (paiement, envoi) doit donc être validée par du code humain, jamais laissée à la seule discrétion du modèle. Pour les appels externes, ajoutez systématiquement un garde-fou : timeout, gestion des erreurs HTTP et retry. Un bon outil est un outil qui échoue proprement et informe le LLM de l’échec pour qu’il puisse s’adapter.

Applications pratiques : exemples d’agents IA en action

Passons de la théorie à la pratique. Voici cinq exemples concrets d’agents IA que vous pouvez construire dès maintenant. Chacun illustre une brique d’architecture différente : appel API, manipulation de fichiers, classification et génération de contenu.

• Agent météo avec API externe L’exemple fondamental pour maîtriser le function calling : l’agent appelle une API météo, récupère les données JSON et formule une réponse lisible. Idéal pour comprendre le cycle perception → décision → action.
• Agent tri de fichiers automatique Un agent qui observe un dossier, identifie les types de fichiers par extension et les déplace dans des sous-dossiers. Il mobilise la mémoire pour se souvenir de ses actions et éviter les doublons.
• Agent classement d’emails Il lit les sujets et corps de messages, les classe par catégories (factures, prospect, personnel) grâce à la sortie structurée JSON. Un LLM atteint 90 % de réussite sur cette tâche simple ; les 10 % d’erreurs sont visibles et corrigeables.
• Agent auditeur SEO Il analyse un site, vérifie les balises title et meta, puis génère un rapport d’audit. C’est l’application phare de SimplerLLM et une excellente vitrine pour la sortie structurée du modèle.
• Agent résumé générant actions Il lit un long document, le résume et produit une liste d’actions à entreprendre. L’agent utilise la mémoire long-terme pour conserver le contexte entre chaque étape de traitement.

Ces projets se construisent en 2 à 6 mois selon votre rythme. Commencez par l’agent météo : il vous prendra quelques heures et vous donnera toutes les bases pour avancer vers des cas plus complexes comme l’audit SEO ou le classement d’emails.

Questions fréquentes sur la création d’agents IA en Python

Quels sont les prérequis pour créer un agent IA ?

Une base solide en Python (fonctions, classes, gestion des erreurs) et une compréhension des API REST sont indispensables. Vous devez également connaître les bases des modèles de langage (LLM) comme GPT ou Llama, sans être un expert en machine learning avancé.

Quel framework Python choisir pour un agent IA ?

LangChain est le choix idéal pour les débutants grâce à sa documentation riche et ses abstractions simplifiées. Pour les projets nécessitant plus de contrôle et de légèreté, optez pour smolagents ou bien pour les développeurs avancés, une boucle maison avec l’API OpenAI est recommandée.