LangChain pour les agents IA : Tutoriel complet
Les agents IA sont des entités logicielles autonomes qui peuvent percevoir leur environnement, prendre des décisions et agir pour atteindre des objectifs spécifiques. Ils représentent une avancée significative dans la manière dont nous interagissons avec et construisons des systèmes intelligents. Si vous souhaitez comprendre les composants essentiels et l’implémentation pratique des agents IA, commencez par Le guide complet des agents IA en 2026. LangChain se distingue comme un cadre puissant pour construire ces agents, fournissant les abstractions nécessaires et les outils pour intégrer de grands modèles de langage (LLMs) avec des sources de données externes et des capacités de calcul. Ce tutoriel vous guidera dans la création d’agents IA en 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 de langage 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, orientant son comportement et son utilisation des outils.
- Exécutant d’agent : L’environnement d’exécution qui gère la boucle de l’agent, passant les observations et les 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 des articles. Le LLM, face à une requête, déciderait s’il faut 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 construire un agent, assurez-vous d’avoir LangChain installé et d’accéder à 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 en tant que variable d’environnement :
import os
os.environ["OPENAI_API_KEY"] = "VOTRE_CLÉ_API_OPENAI"
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 niveau de randomisation de la sortie du LLM. Une valeur de 0 rend la sortie plus déterministe et factuelle, ce qui est adapté à la prise de décision des agents.
Construire votre premier agent LangChain : Un agent de recherche simple
Construisons un agent capable de répondre à des questions en utilisant la recherche sur le web. Cela nécessite un outil de recherche web. LangChain fournit des intégrations pour divers fournisseurs de recherche. Nous allons utiliser l’outil `TavilySearchResults`, qui est souvent un bon choix par défaut.
Tout d’abord, installez le package nécessaire et configurez votre clé API Tavily :
pip install langchain-community tavily-python
import os
os.environ["TAVILY_API_KEY"] = "VOTRE_CLÉ_API_TAVILY"
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 processus de réflexion 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'exécutant de l'agent
# 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 récupérons 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 Entrée d’Action.
- `create_react_agent` combine le LLM, les outils et le prompt en un agent.
- `AgentExecutor` exécute l’agent, gérant la séquence des observations et des actions. Le drapeau `verbose=True` est crucial pour le débogage, car il montre le processus de réflexion interne de l’agent.
La sortie avec `verbose=True` montrera la « Pensée », « Action », « Entrée d’Action » et « Observation » de l’agent à chaque étape, illustrant son raisonnement.
Ajouter des outils et des capacités plus complexes
Les agents deviennent vraiment puissants lorsqu’ils peuvent interagir avec divers systèmes. Élargissons notre agent avec 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écorator pour une création d'outil simple
# 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 renvoie 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'exécutant de l'agent
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 ? De plus, trouvez qui a gagné la dernière Coupe du Monde."})
print(response["output"])
Ici, nous avons utilisé le décorateur `@tool` pour définir rapidement un outil `calculator`. Ce décorateur déduit automatiquement la description et le schéma d’arguments de l’outil, que le LLM utilise pour comprendre comment l’appeler. L’agent décidera désormais s’il faut utiliser le `calculator` ou les `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 ayant des forces et des mécanismes de prise de décision différents :
- `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 une « Entrée d’Action ». C’est une approche très efficace et largement utilisée pour des agents à usage général.
- `create_json_agent` : Conçu pour des agents qui interagissent avec des API 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 fonction 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.
Le choix du 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 OpenAI, `create_openai_functions_agent` est un excellent point de départ en raison de sa solidité. Examinons un exemple en 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 dans le format spécifié."""
import datetime
return datetime.datetime.now().strftime(format_str)
tools = [search_tool, current_time]
# 3. Définir le prompt de l'agent (en utilisant des messages spécifiques à l'agent OpenAI)
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 heure est-il actuellement et quels étaient les principaux titres de la presse d'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 injecté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 puissent réaliser des interactions complexes et 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 de la 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 prompt de l'agent
system_message = SystemMessage(
content="Vous êtes un assistant IA utile. Utilisez les outils disponibles pour répondre aux questions. Soyez concis dans vos réponses."
)
prompt = [
system_message,
MessagesPlaceholder(variable_name="chat_history"), # Espace réservé pour l'historique des discussions
HumanMessage(content="{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
]
# 4. Créer la mémoire
# ConversationBufferWindowMemory garde une fenêtre des 'k' dernières 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 sur plusieurs 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" (la 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, lui permettant de comprendre des références comme “sa population” dans le deuxième tour. C’est essentiel pour construire des agents IA engageants et fonctionnels, notamment pour des cas d’utilisation tels que la Création d’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écifiques, bases de données ou API internes.
Les outils personnalisés peuvent être de simples fonctions décorées avec @tool, comme montré avec calculator et current_time. Pour des scénarios plus complexes, vous pourriez 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 la 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 d'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 introuvable pour la table '{table_name}' avec l'ID '{record_id}'"
async def _arun(self, table_name: str, record_id: int) -> str:
"""Version asynchrone de l'outil (optionnelle)."""
# Implémenter la logique asynchrone ici
raise NotImplementedError("Appel asynchrone non implémenté pour cet outil.")
# Ajouter cet outil à la liste d'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 au LLM des instructions claires 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. Lorsque vous comparez des frameworks, considérez comment chacun gère ces intégrations d’outils personnalisés ; voir Comparer les 5 meilleurs frameworks d’agents IA 2026 pour plus de contexte.
Points clés à retenir
- 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 de l’agent.
- Le modèle ReAct (Raisonner et Agir) est une approche solide, souvent facilitée par les prompts de LangChain Hub.
create_openai_functions_agentest 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 sur plusieurs tours et la conscience contextuelle. - Les outils personnalisés sont faciles à créer en utilisant le décorateur
@toolou en héritant deBaseToolpour des interactions plus complexes, permettant aux agents de s’intégrer dans des systèmes propriétaires. - Utilisez toujours
verbose=Truependant 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 nécessaires pour concrétiser vos idées d’agents IA. Alors 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 intelligentes et autonomes.
🕒 Published: