Qu’est-ce qu’un agent IA et en quoi il diffère d’un simple chatbot
Un agent IA est un système autonome qui utilise un modèle de langage (LLM) comme moteur de raisonnement pour planifier et exécuter des tâches complexes. Contrairement à un chatbot classique qui se contente de répondre à des questions, un agent peut décomposer un objectif en sous-tâches, utiliser des outils externes (recherche web, exécution de code, requêtes API, lecture de fichiers), observer les résultats intermédiaires, et ajuster son plan en conséquence. C’est la différence entre un assistant qui vous dit comment réserver un vol et un agent qui réserve effectivement le vol pour vous.
Le concept d’agent s’articule autour d’une boucle : Perception (recevoir des informations), Raisonnement (analyser et planifier avec le LLM), Action (exécuter via des outils), Observation (évaluer le résultat). Cette boucle se répète jusqu’à ce que l’objectif soit atteint ou que l’agent détermine qu’il ne peut pas le réaliser.
Créer un agent simple avec LangChain
LangChain est le framework le plus utilisé pour construire des agents IA. Installez-le avec pip install langchain langchain-openai. Voici un agent minimal qui peut effectuer des recherches web et des calculs :
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool
from langchain import hub
import numexpr
# Définir le LLM
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# Définir les outils disponibles pour l'agent
def calculer(expression: str) -> str:
"""Évalue une expression mathématique."""
try:
result = numexpr.evaluate(expression).item()
return str(result)
except Exception as e:
return f"Erreur de calcul : {e}"
def rechercher(query: str) -> str:
"""Simule une recherche web (remplacer par une vraie API)."""
# En production, utilisez SerpAPI, Tavily, ou Brave Search API
return f"Résultats de recherche pour : {query}"
tools = [
Tool(name="Calculatrice", func=calculer,
description="Utile pour les calculs mathématiques. "
"Input : une expression mathématique."),
Tool(name="Recherche", func=rechercher,
description="Utile pour rechercher des informations actuelles. "
"Input : une requête de recherche."),
]
# Créer l'agent avec le prompt ReAct
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Tester l'agent
result = executor.invoke({
"input": "Quel est le PIB du Sénégal et combien cela fait par habitant "
"si la population est de 18 millions ?"
})
print(result["output"])Quand vous lancez ce code avec verbose=True, vous voyez le raisonnement de l’agent en temps réel. Il va d’abord utiliser l’outil Recherche pour trouver le PIB du Sénégal, puis l’outil Calculatrice pour diviser ce chiffre par 18 millions. Le pattern ReAct (Reasoning + Acting) alterne entre les phases de réflexion et d’action.
Les outils : ce qui donne ses pouvoirs à l’agent
La puissance d’un agent dépend directement des outils que vous lui fournissez. Les outils les plus utiles en contexte professionnel sont la recherche web (Tavily Search API offre un plan gratuit de 1000 requêtes/mois), l’exécution de code Python (avec la bibliothèque langchain_experimental.tools.PythonREPLTool), la lecture et écriture de fichiers, les requêtes à des API externes (votre CRM, votre base de données, vos services internes), et l’envoi d’emails ou de messages.
Chaque outil est défini par un nom, une fonction Python, et une description textuelle. La description est cruciale car c’est elle que le LLM lit pour décider quel outil utiliser. Une description vague produit des choix d’outils incohérents. Une description précise qui explique quand utiliser l’outil et quel format d’input il attend améliore considérablement la fiabilité de l’agent.
Créer un agent multi-outils pour l’entreprise
Voici un exemple d’agent assistant commercial qui consulte un catalogue produit, calcule des devis, et rédige des emails :
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import json
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# Base de données produits simulée
CATALOGUE = {
"laptop-pro": {"nom": "Laptop Pro 15", "prix": 450000, "stock": 12},
"ecran-27": {"nom": "Écran 27 pouces 4K", "prix": 185000, "stock": 8},
"clavier-meca": {"nom": "Clavier mécanique RGB", "prix": 35000, "stock": 25},
}
@tool
def consulter_catalogue(produit_id: str) -> str:
"""Consulte le catalogue pour obtenir le prix et le stock d'un produit.
Input : l'identifiant du produit (ex: laptop-pro, ecran-27)."""
if produit_id in CATALOGUE:
p = CATALOGUE[produit_id]
return f"{p['nom']} - Prix : {p['prix']} FCFA - Stock : {p['stock']} unités"
return "Produit non trouvé. Produits disponibles : " + ", ".join(CATALOGUE.keys())
@tool
def calculer_devis(produits_json: str) -> str:
"""Calcule un devis à partir d'une liste de produits et quantités.
Input : JSON avec format [{"id": "laptop-pro", "quantite": 2}]"""
try:
items = json.loads(produits_json)
total = 0
lignes = []
for item in items:
p = CATALOGUE.get(item["id"])
if p:
sous_total = p["prix"] * item["quantite"]
total += sous_total
lignes.append(f"{p['nom']} x{item['quantite']} = {sous_total:,} FCFA")
lignes.append(f"TOTAL : {total:,} FCFA")
return "\n".join(lignes)
except Exception as e:
return f"Erreur : {e}"
@tool
def rediger_email(destinataire_et_contenu: str) -> str:
"""Rédige un email professionnel. Input : description du destinataire et du contenu souhaité."""
return f"Email rédigé pour : {destinataire_et_contenu} (à envoyer manuellement)"
tools = [consulter_catalogue, calculer_devis, rediger_email]
prompt = ChatPromptTemplate.from_messages([
("system", "Tu es un assistant commercial pour TechStore Dakar. "
"Tu aides à consulter le catalogue, faire des devis et rédiger des emails. "
"Les prix sont en FCFA. Sois professionnel et précis."),
("human", "{input}"),
MessagesPlaceholder("agent_scratchpad"),
])
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Test
result = executor.invoke({
"input": "Un client veut 3 laptops et 3 écrans. Fais-moi le devis "
"et rédige un email de proposition commerciale."
})
print(result["output"])Cet agent va automatiquement consulter le catalogue pour obtenir les prix, calculer le devis total, puis rédiger un email de proposition commerciale avec les détails du devis. Le tout en une seule commande en langage naturel.
CrewAI : orchestrer plusieurs agents spécialisés
CrewAI (crewai.com) permet de créer une équipe d’agents qui collaborent. Chaque agent a un rôle spécifique, un objectif, et un jeu d’outils. Installez-le avec pip install crewai. Le concept est de définir des Agents (qui sont-ils), des Tasks (que doivent-ils faire), et un Crew (comment collaborent-ils). Par exemple, un agent « Chercheur » collecte des informations, un agent « Rédacteur » écrit un article à partir de ces informations, et un agent « Éditeur » relit et corrige le tout.
Bonnes pratiques et limites
Les agents IA sont puissants mais pas infaillibles. Limitez le nombre d’outils par agent (5 à 10 maximum) car trop d’outils confusent le LLM. Implémentez des gardes-fous : limitez le nombre d’itérations de la boucle (max_iterations=10), définissez un timeout, et ajoutez une validation humaine pour les actions critiques (envoi d’email, modification de base de données). Loguez toutes les actions de l’agent pour pouvoir déboguer et améliorer son comportement. Enfin, testez abondamment avec des cas limites avant de déployer en production.
