LangChain pour les agents IA : Tutoriel complet
Les agents IA sont des entités logicielles autonomes capables de percevoir leur environnement, de prendre des décisions et d’agir pour atteindre des objectifs spécifiques. Ils représentent une avancée significative dans notre façon d’interagir avec et de construire des systèmes intelligents. Si vous cherchez à comprendre les composants fondamentaux et l’implémentation pratique des agents IA, commencez par Le guide complet des agents IA en 2026. LangChain se distingue comme un puissant cadre pour construire ces agents, fournissant les abstractions et outils nécessaires pour intégrer des modèles linguistiques de grande taille (LLMs) avec des sources de données externes et des capacités de calcul. Ce tutoriel vous accompagnera dans la création d’agents IA utilisant LangChain, en se concentrant sur les aspects pratiques et les mécanismes sous-jacents.
Comprendre les fondamentaux des agents LangChain
Au cœur de LangChain, un agent orchestre l’interaction entre un LLM et un ensemble d’outils. Le LLM agit comme le “cerveau” de l’agent, décidant quel outil utiliser et avec quelle entrée, en fonction de l’objectif actuel et de l’état observé. Les outils sont des fonctions qui effectuent des tâches spécifiques, comme rechercher sur le web, interroger une base de données ou exécuter du code.
Les principaux composants d’un agent LangChain sont :
- LLM : Le modèle linguistique responsable du raisonnement et de la prise de décision.
- Outils : Fonctions que l’agent peut appeler pour interagir avec le monde extérieur.
- Prompt : Instructions données au LLM, guidant son comportement et son utilisation des outils.
- Agent Executor : L’exécution qui gère la boucle de l’agent, passant des observations et des actions entre le LLM et les outils.
Considérons un agent conçu pour répondre à des questions sur l’actualité. Il pourrait avoir un outil pour effectuer des recherches sur le web et un autre pour les articles. Le LLM, étant donné une requête, déciderait s’il doit rechercher sur le web, exécuter la recherche, observer les résultats, puis éventuellement les résumer avant de formuler une réponse finale.
Configurer votre environnement LangChain
Avant de créer un agent, assurez-vous d’avoir LangChain installé et d’avoir accès à un LLM. Nous utiliserons les modèles d’OpenAI pour ce tutoriel, mais LangChain prend en charge de nombreux autres.
pip install langchain langchain-openai
Vous devrez définir votre clé API OpenAI comme variable d’environnement :
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
Pour des exemples plus simples, vous pouvez instancier le LLM directement :
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(temperature=0)
Le paramètre `temperature` contrôle le caractère aléatoire de la sortie du LLM. Une valeur de 0 rend la sortie plus déterministe et factuelle, ce qui est adapté pour la prise de décision de l’agent.
Construire votre premier agent LangChain : Un agent de recherche simple
Construisons un agent capable de répondre à des questions en utilisant la recherche web. Cela nécessite un outil de recherche web. LangChain propose des intégrations pour divers fournisseurs de recherche. Nous utiliserons l’outil `TavilySearchResults`, qui est souvent un bon choix par défaut.
Tout d’abord, installez le paquet nécessaire et définissez votre clé API Tavily :
pip install langchain-community tavily-python
import os
os.environ["TAVILY_API_KEY"] = "YOUR_TAVILY_API_KEY"
Maintenant, définissons les outils et instancions l’agent.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. Initialiser le LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Définir les outils
search_tool = TavilySearchResults(max_results=3) # Limiter à 3 résultats de recherche
tools = [search_tool]
# 3. Récupérer le prompt de l'Agent ReAct depuis le LangChain Hub
# Le modèle ReAct (Raisonnement et Action) est une approche courante pour les agents.
# Il incite le LLM à générer un raisonnement avant de prendre une action.
prompt = hub.pull("hwchase17/react")
# 4. Créer l'agent
# create_react_agent construit un agent qui utilise le prompt ReAct.
agent = create_react_agent(llm, tools, prompt)
# 5. Créer l'Agent Executor
# L'AgentExecutor est responsable de l'exécution de la boucle de décision de l'agent.
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Exécuter l'agent
response = agent_executor.invoke({"input": "Quelle est la capitale de la France et quelle est sa population actuelle ?"})
print(response["output"])
Dans cet exemple :
- Nous initialisons `ChatOpenAI` comme notre LLM.
- Nous créons un outil `TavilySearchResults`.
- Nous extrayons un prompt ReAct standard depuis `langchain_hub`. Ce prompt guide le LLM à penser étape par étape (Pensée) puis à décider d’une Action et d’une Action d’Entrée.
- `create_react_agent` combine le LLM, les outils et le prompt en un agent.
- `AgentExecutor` exécute l’agent, gérant la séquence d’observations et d’actions. Le paramètre `verbose=True` est crucial pour le débogage, car il montre le raisonnement interne de l’agent.
La sortie avec `verbose=True` montrera la “Pensée”, “Action”, “Action d’Entrée” et “Observation” de l’agent à chaque étape, démontrant son raisonnement.
Ajouter des outils et capacités plus complexes
Les agents deviennent vraiment puissants lorsqu’ils peuvent interagir avec divers systèmes. Étendons notre agent en lui ajoutant un outil pour effectuer des calculs.
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.tools import tool # Décorateur pour la création de simples outils
# 1. Initialiser le LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Définir les outils
search_tool = TavilySearchResults(max_results=3)
@tool
def calculator(expression: str) -> str:
"""Évalue une expression mathématique et retourne le résultat."""
try:
return str(eval(expression))
except Exception as e:
return f"Erreur lors de l'évaluation de l'expression : {e}"
tools = [search_tool, calculator]
# 3. Récupérer le prompt de l'Agent ReAct
prompt = hub.pull("hwchase17/react")
# 4. Créer l'agent
agent = create_react_agent(llm, tools, prompt)
# 5. Créer l'Agent Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Exécuter l'agent avec une nouvelle requête
response = agent_executor.invoke({"input": "Quel est 12345 multiplié par 67890 ? Aussi, trouvez qui a gagné le dernier Coupe du Monde."})
print(response["output"])
Ici, nous avons utilisé le décorateur `@tool` pour définir rapidement un outil `calculator`. Ce décorateur infère automatiquement la description de l’outil et le schéma des arguments, que le LLM utilise pour comprendre comment l’appeler. L’agent décidera maintenant s’il doit utiliser le `calculator` ou le `TavilySearchResults` en fonction de la requête d’entrée. Cette modularité est essentielle pour construire des agents IA sophistiqués. Pour une coordination multi-agents plus avancée, des cadres comme CrewAI Multi-Agent Systems Guide offrent des abstractions puissantes.
Types d’agents et leurs cas d’utilisation
LangChain propose plusieurs types d’agents, chacun avec des forces différentes et des mécanismes de prise de décision sous-jacents :
- `create_react_agent` (Agent ReAct) : Utilise le modèle ReAct (Raisonnement et Action). Le LLM génère une “Pensée” (monologue interne) puis une “Action” (appel d’outil) et “Action d’Entrée”. C’est une approche très efficace et largement utilisée pour les agents à usage général.
- `create_json_agent` : Conçu pour les agents qui interagissent avec des APIs s’attendant à des entrées et sorties JSON. Le LLM est incité à générer des appels d’outil au format JSON.
- `create_openai_functions_agent` : utilise les capacités d’appel de fonctions d’OpenAI. Le LLM produit directement un objet structuré indiquant l’outil à appeler et ses arguments, ce qui peut être plus fiable que l’analyse de texte. C’est souvent le choix préféré lors de l’utilisation des modèles OpenAI.
Choisir le bon type d’agent dépend de votre cas d’utilisation spécifique et du LLM que vous utilisez. Pour la plupart des tâches générales avec les modèles d’OpenAI, `create_openai_functions_agent` est un excellent point de départ en raison de sa solidité. Voyons un exemple l’utilisant.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. Initialiser LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Définir les Outils
search_tool = TavilySearchResults(max_results=3)
@tool
def current_time(format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
"""Retourne la date et l'heure actuelles au format spécifié."""
import datetime
return datetime.datetime.now().strftime(format_str)
tools = [search_tool, current_time]
# 3. Définir le message de l'Agent
system_message = SystemMessage(
content="Vous êtes un assistant IA utile. Utilisez les outils disponibles pour répondre aux questions."
)
prompt = [system_message, HumanMessage(content="{input}"), MessagesPlaceholder(variable_name="agent_scratchpad")]
# 4. Créer l'Agent en utilisant create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Créer l'Exécuteur de l'Agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Exécuter l'Agent
response = agent_executor.invoke({"input": "Quelle est l'heure actuelle et quels étaient les principaux titres de l'actualité hier ?"})
print(response["output"])
Remarquez le `MessagesPlaceholder(variable_name=”agent_scratchpad”)` dans le prompt. C’est ici que les pensées, actions et observations intermédiaires de l’agent sont intégrées dans l’historique de la conversation, permettant au LLM de maintenir le contexte.
Gestion de l’État et de la Mémoire de l’Agent
Pour que les agents réalisent des interactions complexes sur plusieurs tours, ils ont besoin de mémoire. LangChain fournit divers composants de mémoire pour stocker et récupérer l’historique des conversations. L’`AgentExecutor` peut être configuré avec mémoire.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferWindowMemory # Importer la mémoire
# 1. Initialiser LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Définir les Outils
search_tool = TavilySearchResults(max_results=3)
tools = [search_tool]
# 3. Définir le message de l'Agent
system_message = SystemMessage(
content="Vous êtes un assistant IA utile. Utilisez les outils disponibles pour répondre aux questions. Gardez vos réponses concises."
)
prompt = [
system_message,
MessagesPlaceholder(variable_name="chat_history"), # Espace réservé pour l'historique de la conversation
HumanMessage(content="{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
]
# 4. Créer la Mémoire
# ConversationBufferWindowMemory garde un aperçu des dernières 'k' interactions.
memory = ConversationBufferWindowMemory(memory_key="chat_history", return_messages=True, k=3)
# 5. Créer l'Agent
agent = create_openai_functions_agent(llm, tools, prompt)
# 6. Créer l'Exécuteur de l'Agent avec mémoire
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
memory=memory # Ajouter la mémoire ici
)
# 7. Exécuter une Conversation Multi-Tours
print("--- Premier Tour ---")
response1 = agent_executor.invoke({"input": "Quelle est la capitale du Japon ?"})
print(response1["output"])
print("\n--- Deuxième Tour ---")
response2 = agent_executor.invoke({"input": "Quelle est sa population ?"}) # Se référant à "sa" (capitale du Japon)
print(response2["output"])
print("\n--- Troisième Tour ---")
response3 = agent_executor.invoke({"input": "Et qu'en est-il de la capitale du Brésil ?"})
print(response3["output"])
En introduisant `ConversationBufferWindowMemory` et en incluant `MessagesPlaceholder(variable_name=”chat_history”)` dans le prompt, l’agent peut désormais maintenir le contexte à travers plusieurs tours. Le LLM voit les messages précédents, ce qui lui permet de comprendre des références comme “sa population” au deuxième tour. Cela est essentiel pour construire des agents IA engageants et fonctionnels, en particulier pour des cas d’utilisation tels qu’un Créer un Agent IA pour le Service Client.
Personnalisation Avancée de l’Agent et Développement d’Outils
Bien que LangChain propose de nombreux outils intégrés, vous aurez souvent besoin de créer des outils personnalisés pour interagir avec vos applications spéciales, bases de données ou API internes.
Les outils personnalisés peuvent être de simples fonctions décorées avec `@tool`, comme le montre `calculator` et `current_time`. Pour des scénarios plus complexes, vous pouvez définir une classe qui hérite de `BaseTool` ou utiliser `StructuredTool` pour une définition précise des arguments.
from langchain.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
# Définir le schéma d'entrée pour l'outil personnalisé
class GetDatabaseRecordInput(BaseModel):
table_name: str = Field(description="Nom de la table de base de données")
record_id: int = Field(description="ID de l'enregistrement à récupérer")
class GetDatabaseRecordTool(BaseTool):
name = "get_database_record"
description = "Utile pour récupérer un enregistrement spécifique d'une table de base de données par son ID."
args_schema: Type[BaseModel] = GetDatabaseRecordInput
def _run(self, table_name: str, record_id: int) -> str:
"""Simule la récupération d'un enregistrement dans une base de données."""
print(f"DEBUG: Récupération de l'enregistrement {record_id} de la table {table_name}")
if table_name == "users" and record_id == 1:
return "Enregistrement utilisateur : {'id': 1, 'name': 'Alice', 'email': '[email protected]'}"
elif table_name == "products" and record_id == 101:
return "Enregistrement produit : {'id': 101, 'name': 'Laptop', 'price': 1200}"
return f"Enregistrement non trouvé pour la table '{table_name}' avec ID '{record_id}'"
async def _arun(self, table_name: str, record_id: int) -> str:
"""Version asynchrone de l'outil (facultatif)."""
# Implémentez la logique asynchrone ici
raise NotImplementedError("Appel asynchrone non implémenté pour cet outil.")
# Ajoutez cet outil à la liste des outils de votre agent
# tools.append(GetDatabaseRecordTool())
Ce `GetDatabaseRecordTool` démontre comment définir un outil avec un schéma d’entrée spécifique en utilisant Pydantic, fournissant ainsi des instructions claires au LLM sur la manière de l’utiliser. Ce niveau de contrôle est essentiel pour intégrer des agents dans des systèmes d’entreprise. En comparant les frameworks, considérez comment chacun gère ces intégrations d’outils personnalisés ; consultez Comparer les 5 Meilleurs Frameworks d’Agents IA 2026 pour plus de contexte.
Points Clés
- Les agents LangChain utilisent un LLM pour orchestrer l’utilisation des outils, leur permettant d’interagir avec le monde extérieur au-delà de leurs données d’entraînement.
- Les composants principaux sont le LLM, les Outils, un Prompt et l’Exécuteur d’Agents.
- Le modèle ReAct (Raisonner et Agir) est une approche solide, souvent facilité par des prompts de LangChain Hub.
- `create_openai_functions_agent` est généralement recommandé pour les modèles OpenAI en raison de sa sortie structurée fiable.
- Les composants de mémoire (par exemple, `ConversationBufferWindowMemory`) sont cruciaux pour les conversations multi-tours et la conscience contextuelle.
- Il est facile de créer des outils personnalisés en utilisant le décorateur `@tool` ou en héritant de `BaseTool` pour des interactions plus complexes, permettant aux agents de s’intégrer à des systèmes propriétaires.
- Utilisez toujours `verbose=True` pendant le développement pour inspecter le processus de pensée interne de l’agent et déboguer efficacement.
Conclusion
LangChain fournit un cadre complet et flexible pour construire des agents IA. En comprenant ses composants principaux—LLMs, outils, prompts et exécuteurs—vous pouvez construire des agents capables de raisonnement complexe et d’interaction. Des agents de recherche simples aux systèmes sophistiqués avec mémoire et intégrations personnalisées, LangChain offre les éléments constitutifs pour réaliser vos idées d’agents IA. À mesure que le domaine des agents IA continue d’évoluer, maîtriser des frameworks comme LangChain sera de plus en plus précieux pour développer des applications autonomes intelligentes.
🕒 Published: