Comment construire un agent IA avec LangChain : guide étape par étape

Créer un répertoire de travail temporaire et sécurisé

Le passage des grands modèles de langage (LLM) qui se contentent de générer du texte à des agents IA capables d'agir constitue l'une des évolutions les plus marquantes du génie logiciel moderne. Un système agentique perçoit son environnement, prend des décisions et utilise des outils pour atteindre des objectifs spécifiques, dépassant ainsi le simple cadre des chatbots questions-réponses. LangChain, un framework open-source, s'est imposé comme la référence pour construire ces applications sophistiquées en connectant les LLM à des données externes, des outils et d'autres LLM.

Ce tutoriel propose un guide complet et pas à pas sur la construction d'un agent IA avec LangChain. Vous apprendrez les concepts fondamentaux et suivrez une mise en œuvre pratique, ce qui vous permettra de créer vos propres agents autonomes capables d'effectuer des tâches concrètes.

Ce que vous allez apprendre

À la fin de ce tutoriel, vous comprendrez les principes fondamentaux de l'IA agentique et du framework LangChain. Vous serez capable de configurer un environnement de développement, de vous connecter à un LLM, de définir des outils personnalisés et de construire un agent fonctionnel en utilisant l'API moderne create_agent. Vous allez construire et exécuter un agent IA complet capable d'interagir avec un système de fichiers local à partir de commandes en langage naturel, ce qui vous donnera une base pratique pour créer des automatisations plus complexes.

1. Fondamentaux de LangChain et concepts clés

Avant de plonger dans le code, il est essentiel de comprendre ce qu'est un agent IA et comment LangChain facilite sa création. À la base, un agent est un système qui utilise un LLM comme moteur de raisonnement. L'agent reçoit une demande utilisateur, invite le LLM à décider d'une action, exécute cette action (souvent en appelant un outil), puis traite le résultat pour formuler une réponse. Ce cycle se répète jusqu'à ce que la tâche soit terminée.

LangChain fournit un framework standard pour implémenter cette boucle de raisonnement, notamment grâce à son support du framework ReAct (Reason + Act). LangChain est un outil de haut niveau construit sur LangGraph, un framework d'orchestration de bas niveau qui offre un contrôle granulaire sur le flux de travail et l'état de l'agent.

Pour construire un agent avec LangChain, vous avez besoin de quatre composants principaux :

1. Un LLM : Le moteur de raisonnement de votre agent.
2. Des outils : Des fonctions qui permettent à l'agent d'interagir avec le monde extérieur, comme des API, des bases de données ou un système de fichiers.
3. La boucle de l'agent : La couche d'orchestration « cerveau » qui gère le LLM, les outils et l'état.
4. La mémoire (point de contrôle) : La capacité de persister l'état de l'agent, lui permettant de se souvenir des interactions passées au sein d'un fil de conversation.

2. Configuration de votre environnement de développement

Pour commencer, vous devez installer LangChain et ses dépendances principales. Ce tutoriel illustre le processus en Python, mais les concepts et les schémas généraux sont similaires pour les utilisateurs de TypeScript.

Tout d'abord, assurez-vous d'avoir Python 3 et Pip installés sur votre système. Pour les systèmes basés sur Debian/Ubuntu, vous pouvez utiliser les commandes suivantes. Pour les autres systèmes d'exploitation, suivez la méthode d'installation appropriée.

sudo apt update
sudo apt install python3 python3-pip

Ensuite, installez les principaux packages LangChain. Le package langchain est le framework central. langchain-community contient des outils maintenus par la communauté, et langgraph est nécessaire pour l'API moderne de création d'agents.

pip install langchain langgraph langchain-community

3. Intégration d'un grand modèle de langage

La première étape de la construction de votre agent consiste à le connecter à un LLM. LangChain prend en charge des dizaines de fournisseurs de modèles, notamment Google Gemini, OpenAI, Anthropic, et bien d'autres. Pour ce tutoriel, nous utiliserons le modèle Gemini de Google.

Vous aurez besoin d'une clé API depuis la console Gemini. Une fois que vous l'avez, vous pouvez installer le package d'intégration Google GenAI et configurer votre environnement.

pip install -qU "langchain[google-genai]"

Maintenant, vous pouvez écrire le code Python pour initialiser le modèle. Le module getpass est utilisé pour demander votre clé API de manière sécurisée.

import getpass
import os
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, SystemMessage

if not os.environ.get("GOOGLE_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("Entrez la clé API pour Google Gemini : ")

model = init_chat_model("gemini-2.0-flash", model_provider="google_genai")

Vous pouvez tester la configuration en invoquant le modèle avec une requête simple.

response = model.invoke("Quand a commencé la Révolution française ?")
print(response.content)

4. Définition des outils pour votre agent

Les outils sont ce qui rend les agents puissants. Ils permettent au LLM d'effectuer des actions au-delà de la simple génération de texte. Dans ce tutoriel, nous allons construire un agent capable de gérer des fichiers sur votre ordinateur local en utilisant le FileManagementToolkit de LangChain.

Le FileManagementToolkit fait partie du package langchain-community, que vous avez déjà installé. Cette boîte à outils vous permet de spécifier les opérations sur les fichiers que l'agent peut effectuer, telles que la lecture, l'écriture et la liste des fichiers.

Importez les modules nécessaires et définissez les outils. Il est essentiel pour la sécurité de restreindre l'agent à un répertoire temporaire plutôt que de lui donner libre accès à l'ensemble de votre système de fichiers.

from langchain_community.agent_toolkits import FileManagementToolkit
from tempfile import TemporaryDirectory

working_directory = TemporaryDirectory()

# Initialiser la boîte à outils avec les outils sélectionnés et un répertoire racine
tools = FileManagementToolkit(
    root_dir=str(working_directory.name),
    selected_tools=["read_file", "write_file", "list_directory"],
).get_tools()

5. Construction de l'agent avec create_agent

Avec le LLM et les outils prêts, vous pouvez maintenant construire l'agent. La méthode moderne et recommandée pour construire des agents dans LangChain consiste à utiliser la fonction create_agent.

Cette fonction prend votre modèle et une liste d'outils et crée un exécuteur d'agent qui gère la boucle de raisonnement. Elle simplifie le processus, éliminant la nécessité de créer manuellement un agent ReAct et un exécuteur.

from langchain.agents import create_agent

# Les variables "model" et "tools" proviennent des étapes précédentes.
agent = create_agent(
    model=model,
    tools=tools
)

Cette seule ligne de code crée un agent sophistiqué. L'agent utilise le modèle pour décider quel outil appeler en fonction de l'entrée de l'utilisateur. Il peut gérer l'enchaînement de plusieurs appels d'outils pour accomplir une tâche complexe.

⚠️ Important : Bien que LangChain puisse être utilisé avec des méthodes de création d'agents plus anciennes comme create_react_agent, l'API create_agent est l'approche moderne et recommandée, et devrait être votre choix par défaut pour construire de nouveaux agents.

6. Exécution de votre premier agent

Maintenant que l'agent est construit, vous pouvez l'exécuter en l'invoquant avec un message utilisateur. Les commandes suivantes démontreront la capacité de l'agent à interagir avec le système de fichiers.

Commencez par demander à l'agent de lister les fichiers dans le répertoire de travail actuel. À ce stade, le répertoire est vide.

input_message = {"role": "user", "content": "Liste les fichiers dans le répertoire de travail actuel"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Ensuite, demandez à l'agent de créer un fichier nommé sample-file.txt.

input_message = {"role": "user", "content": "Crée un fichier nommé sample-file.txt"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Enfin, demandez à l'agent de lister à nouveau les fichiers. Il montrera maintenant que sample-file.txt existe.

input_message = {"role": "user", "content": "Liste les fichiers dans le répertoire de travail actuel"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Comme vous pouvez le voir, l'agent a interprété avec succès les commandes en langage naturel, a appelé les outils appropriés (list_directory, write_file) et a fourni un retour sur les actions effectuées. C'est une démonstration simple mais puissante de la façon de construire un agent IA avec LangChain.

7. Ajout de mémoire à votre agent

L'une des principales limitations d'un agent sans état est qu'il oublie tout contexte après la fin d'une invocation. Pour créer un agent conversationnel capable de se souvenir des interactions passées, vous devez ajouter de la mémoire. Cela est réalisé via un « point de contrôle » (checkpointer) qui sauvegarde l'état de l'agent.

LangGraph fournit une classe MemorySaver, qui est un simple point de contrôle en mémoire. Dans un environnement de production, vous utiliseriez une option plus robuste comme PostgresSaver ou le point de contrôle basé sur MongoDB, mais MemorySaver est parfait pour les tests et le développement.

Tout d'abord, importez et initialisez le point de contrôle.

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

Ensuite, recréez votre agent en passant le checkpointer comme argument.

agent_with_memory = create_agent(
    model=model,
    tools=tools,
    checkpointer=checkpointer
)

Pour utiliser la mémoire, vous devez spécifier un thread_id dans la configuration. Ce thread_id agit comme un identifiant de conversation, permettant à l'agent de maintenir une mémoire distincte pour chaque conversation.

config = {"configurable": {"thread_id": "user-123"}}

agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Je m'appelle Alice"}]},
    config=config
)

result = agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Quel est mon nom ?"}]},
    config=config
)
# L'agent répond : "Votre nom est Alice."
print(result["messages"][-1].content)

Cet ajout simple permet à votre agent de tenir des conversations avec contexte, le rendant beaucoup plus intelligent et utile.

8. Au-delà des bases : les systèmes multi-agents

Au fur et à mesure de votre progression, vous pourriez rencontrer des tâches trop complexes pour un seul agent. LangChain prend en charge la construction de systèmes multi-agents sophistiqués, où des agents spécialisés collaborent pour résoudre des problèmes. C'est un modèle architectural puissant pour les flux de travail complexes.

Les sous-agents sont un modèle multi-agent central où un agent superviseur principal coordonne plusieurs sous-agents spécialisés, les appelant comme des outils. Par exemple, un sous-agent pourrait être responsable de la recherche, un autre de la création de contenu, et un troisième de la révision du travail.

Modèle	Comment ça fonctionne
Sous-agents	Un agent principal coordonne les sous-agents en tant qu'outils. Tout routage passe par l'agent principal, qui décide quand invoquer chaque sous-agent.
Transferts	Le comportement change dynamiquement en fonction de l'état, où un appel d'outil déclenche un passage à un agent ou une configuration différente.
Compétences	Des invites et des connaissances spécialisées sont chargées à la demande dans le contexte d'un seul agent.
Routeur	Une étape de routage classifie l'entrée et la dirige vers un ou plusieurs agents spécialisés pour traitement.

Choisir le bon modèle est crucial. Par exemple, une architecture de sous-agents est excellente pour l'exécution parallèle et le développement distribué, tandis qu'un modèle de transfert est plus efficace pour les demandes utilisateur répétitives dans une seule conversation. L'utilisation du modèle de sous-agents dans une application d'assistant personnel permet l'isolation du contexte — chaque sous-agent travaille sur une tâche dans une fenêtre de contexte propre, empêchant la mémoire de l'agent principal d'être surchargée.

Sources

1. Chris Tozzi. « Build an AI agent with LangChain in this beginner tutorial. » TechTarget, Sep 2025.
2. « Quickstart » Documentation officielle de LangChain.
3. « Multi-agent » Documentation officielle de LangChain.
4. « Workflows and agents » Documentation officielle de LangChain.
5. « langchain-fundamentals » Documentation des compétences LangChain, GitHub.
6. « How to Build an AI Agent with LangChain and LangGraph: Build an Autonomous Starbucks Agent. » freeCodeCamp, Dec 2025.
7. « Subagents » Documentation officielle de LangChain.
8. « LangChain Python Tutorial: A Complete Guide for 2026. » Le blog JetBrains, Mar 2026.

— Editorial Team