LangGraph est un framework Python d'orchestration pour agents IA, développé par l'équipe de LangChain, qui décrit un agent comme un graphe d'états et sauvegarde cet état à chaque étape. Il se justifie quand le processus est long, comporte plusieurs étapes, doit s'arrêter pour une validation humaine ou doit reprendre après un incident. Pour un agent qui répond en quelques secondes en lisant des données, une boucle d'outils classique suffit et coûte moins cher à maintenir.
Cet article s'adresse aux responsables techniques et aux développeurs de PME, d'ETI et d'éditeurs, ainsi qu'aux dirigeants qui doivent décider avec quoi construire leur agent. Les éléments sur LangGraph viennent de la documentation officielle consultée le 19 novembre 2026, et l'exemple de code a été exécuté avec la version 1.2.23. L'API a beaucoup bougé ces deux dernières années, donc vérifiez les noms avant de figer vos dépendances.
Nous n'avons pas de mission livrée avec LangGraph que nous puissions citer. Notre expérience de production porte sur d'autres agents, décrits plus bas avec leurs limites, et sur les exigences qui reviennent quel que soit le framework.
Points clés à retenir
- LangGraph décrit un agent comme un graphe d'états, avec persistance, interruption pour validation humaine et flux d'événements
- Il se justifie pour les processus longs à étapes, avec une validation au milieu, une reprise sur incident ou plusieurs agents coordonnés
- Pour un agent court, en lecture, sans validation, une boucle d'outils simple suffit
- Droits par utilisateur, jeu de test, mesure, observabilité et coûts restent à construire avec ou sans LangGraph
- LangGraph fonctionne sans LangChain et sans offre hébergée, avec un checkpointer durable comme PostgresSaver en production
- Pydantic AI et le Claude Agent SDK couvrent d'autres besoins, ils ne sont pas des concurrents directs sur chaque point
Ce que LangGraph apporte à un agent
Selon sa documentation, LangGraph est un framework d'orchestration de bas niveau et un runtime pour des agents à état qui durent. Vous déclarez un état, des nœuds (des fonctions qui lisent l'état et renvoient une mise à jour) et des arêtes (les transitions, éventuellement conditionnelles). Le flux de l'agent devient du code lisible, pas un comportement implicite d'une boucle.
| Capacité | Ce que LangGraph apporte |
|---|---|
| État explicite | Un schéma d'état partagé que chaque nœud lit et met à jour, donc une exécution que l'on peut inspecter étape par étape |
| Persistance | Un checkpointer sauvegarde l'état et permet de reprendre après une panne ou une pause |
| Interruption | L'exécution s'arrête, la personne inspecte ou modifie l'état, puis le graphe continue |
| Flux | Diffusion des jetons, des mises à jour d'état et d'autres événements pendant l'exécution |
| Mémoire | État court terme propre à chaque fil de conversation, et mémoire plus longue entre les sessions |
Ce modèle a un coût, il faut écrire le graphe. En échange, chaque étape est explicite, donc testable, et l'état peut être relu après coup, ce qui compte dès qu'un responsable métier demande pourquoi l'agent a fait telle chose.
Un exemple court avec validation humaine avant écriture
Le cas le plus parlant est un agent qui prépare une action, attend l'accord d'une personne, puis l'exécute. L'exemple suit la syntaxe de la documentation officielle (StateGraph, InMemorySaver, interrupt, Command). Le nœud preparer appellerait un modèle dans un vrai agent, il est ici remplacé par une valeur fixe pour que le graphe tourne sans appel réseau.
from typing import TypedDict
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt
class Etat(TypedDict):
demande: str
brouillon: str
valide: bool
resultat: str
def preparer(etat: Etat):
# Ici, un appel de modèle ou d'outil. Le résultat est écrit dans l'état.
return {"brouillon": f"Avoir de 120 EUR pour : {etat['demande']}"}
def valider(etat: Etat):
# Le graphe s'arrête ici, l'état est sauvegardé, rien ne tourne en attendant.
decision = interrupt({"a_valider": etat["brouillon"]})
return {"valide": bool(decision)}
def executer(etat: Etat):
return {"resultat": "Avoir émis"}
def abandonner(etat: Etat):
return {"resultat": "Refusé par la personne"}
def aiguiller(etat: Etat):
return "executer" if etat["valide"] else "abandonner"
builder = StateGraph(Etat)
builder.add_node("preparer", preparer)
builder.add_node("valider", valider)
builder.add_node("executer", executer)
builder.add_node("abandonner", abandonner)
builder.add_edge(START, "preparer")
builder.add_edge("preparer", "valider")
builder.add_conditional_edges("valider", aiguiller, ["executer", "abandonner"])
builder.add_edge("executer", END)
builder.add_edge("abandonner", END)
graph = builder.compile(checkpointer=InMemorySaver())
config = {"configurable": {"thread_id": "dossier-42"}}
premier = graph.invoke({"demande": "facture 2026-118"}, config)
print(premier["__interrupt__"][0].value)
final = graph.invoke(Command(resume=True), config)
print(final["resultat"])
Trois points valent pour tous vos agents. L'état est un schéma déclaré, pas un historique de messages que l'on espère complet. L'appel à interrupt suspend le graphe et demande un checkpointer et un identifiant de fil (thread_id), la documentation précisant qu'il faut réutiliser le même identifiant à la reprise. La valeur passée à Command(resume=...) devient le retour de interrupt.
Deux précisions de la documentation de persistance comptent pour la suite. InMemorySaver garde les points de reprise en mémoire vive, ils disparaissent au redémarrage. En production, elle cite PostgresSaver, et recommande de purger les anciens points de reprise. Dans cet exemple, l'écriture se trouve dans un nœud séparé, exécuté seulement après la validation, c'est la bonne habitude. Le détail du fonctionnement est dans la page sur les interruptions.
Quand LangGraph se justifie, et quand une boucle d'outils suffit
La question n'est pas de savoir si LangGraph est bon, mais si votre processus a besoin de ce qu'il apporte. Une boucle d'outils (le modèle appelle un outil, lit le résultat, recommence) est plus simple à écrire, à lire et à maintenir. On passe au graphe quand cette boucle ne suffit plus.
Les cas où le graphe se justifie
- Un processus long à étapes, qui dure des minutes, des heures ou des jours, et dont l'état doit survivre à un redémarrage.
- Une validation humaine au milieu, avec une personne qui répond le lendemain et un agent qui reprend là où il s'était arrêté.
- Une reprise sur incident, pour ne pas refaire les étapes déjà payées en tokens quand un appel échoue.
- Plusieurs agents coordonnés, dont les passages de relais doivent être explicites et vérifiables.
Les cas où une boucle d'outils suffit
Un agent qui interroge vos données en lecture seule, répond en quelques secondes et n'écrit rien n'a pas besoin d'un graphe. Il en va de même pour un assistant avec un seul agent, des outils bien bornés et aucune étape à valider. Ajouter un graphe à ce type d'agent augmente le code à relire sans réduire un risque.
Ce que montre un cas réel
Pour ModelRH, nous avons développé un agent orchestrateur à 23 outils typés, chargés selon les droits de l'utilisateur, avec une validation humaine avant le calcul, des résultats bornés et un flux de réponse en SSE. Le cas est détaillé dans notre cas client ModelRH. Il ne dit rien du framework, mais il illustre le type d'exigences, validation au milieu et flux, qu'un framework doit savoir porter. Si elles figurent dans votre cahier des charges, LangGraph est un candidat sérieux.
Ce qui reste à développer, quel que soit le framework
Un graphe ne rend pas un agent fiable à lui seul. Il organise l'exécution, mais il ne connaît ni vos utilisateurs, ni vos règles métier, ni votre budget. Ces points décident de la mise en production, avec LangGraph comme avec un autre outil.
| Sujet | Ce que LangGraph apporte | Ce qu'il reste à développer |
|---|---|---|
| Droits par utilisateur | Rien de spécifique | Les outils chargés selon le profil, le cloisonnement entre clients, le contrôle dans l'API appelée |
| Jeu de test | Rien | Des scénarios issus de demandes réelles, rejoués à chaque changement de prompt, d'outil ou de modèle |
| Mesure | Des états inspectables à chaque étape | Taux de réussite, appels inutiles, durée et coût par tâche |
| Observabilité | Des états sauvegardés par étape | Des traces, des alertes et un outil pour les relire |
| Coûts | Rien | Un plafond de tours, un budget par tâche, la purge des anciens points de reprise |
Les droits se règlent dans les outils et dans l'API appelée, pas dans le prompt. Le jeu de test se construit à partir de demandes réelles. Sur un projet pour un éditeur de plateforme IA, nous avons construit un benchmark du tool calling, avec des agents Pydantic AI et des serveurs MCP FastMCP, et nous avons suivi l'exécution avec Logfire. La méthode se transpose à n'importe quel framework.
Pour l'observabilité, l'état sauvegardé par étape aide à relire une exécution, mais il ne remplace pas des traces avec les appels d'outils, les durées et les coûts. Notre article sur Langfuse et l'observabilité des LLM détaille cette instrumentation, qui s'ajoute autour du graphe.
LangGraph, LangChain et l'offre hébergée
La documentation décrit LangChain comme le framework d'agents, avec ses abstractions et ses intégrations de modèles et d'outils, et précise que LangGraph fonctionne seul et n'exige pas LangChain. Le point d'entrée haut niveau de LangChain est la fonction create_agent, qui prend un modèle et une liste d'outils. On y commence pour un agent simple, on descend vers LangGraph quand il faut piloter l'état et le flux soi-même. Notre comparatif des frameworks d'agents situe aussi CrewAI et les autres.
Côté hébergement, l'éditeur propose LangSmith, qu'il présente comme la plateforme de traçage, d'évaluation, de prompts et de déploiement. Son produit de déploiement s'appelle LangSmith Agent Server, et la documentation indique qu'avec lui la persistance est gérée à votre place, sans configurer de checkpointer. Rien n'oblige à l'utiliser. Un déploiement maison (un service Python, une base Postgres pour les points de reprise) reste possible. Les conditions et la tarification de l'offre hébergée sont à vérifier sur le site de l'éditeur, elles changent.
Pour faire monter une équipe en compétence sur ces briques, notre formation LangGraph couvre l'orchestration d'agents avec persistance et validation humaine.
LangGraph, Pydantic AI et Claude Agent SDK
Ces trois outils sont utilisables en production et ne répondent pas à la même contrainte. Pydantic AI est un framework Python indépendant du fournisseur de modèle, centré sur le typage. Le Claude Agent SDK fournit la boucle d'agent de Claude Code pour les modèles Claude, que nous détaillons dans notre article sur le Claude Agent SDK en production.
| Critère | LangGraph | Pydantic AI | Claude Agent SDK |
|---|---|---|---|
| Idée centrale | Un graphe d'états explicite, avec persistance et interruption | Des agents Python typés, avec outils, sorties structurées et dépendances | La boucle d'agent de Claude Code, avec ses outils et ses permissions |
| Modèles | Plusieurs, par les intégrations de l'écosystème | Plusieurs fournisseurs, dont des modèles locaux | Claude (API Anthropic, Bedrock, Google Cloud, Foundry) |
| Validation humaine | Fonction interrupt et reprise par Command | Approbation humaine des outils | Callback can_use_tool et hooks |
| Exploitation | Une bibliothèque Python, plus une base pour les points de reprise | Une bibliothèque Python ordinaire | Un binaire Claude Code embarqué, à héberger |
| Cas typique | Processus long à étapes, avec pause et reprise | Agent métier branché sur des API, modèle à pouvoir changer | Agent qui travaille sur des fichiers ou des documents, avec Claude |
Le choix tient en trois questions. Votre processus comporte-t-il des étapes longues, avec pause et reprise ? Le modèle sera-t-il le même pour longtemps ? Votre équipe préfère-t-elle des objets typés, un graphe explicite ou une boucle toute faite ? Les trois répondent à des besoins réels, et dans les trois cas droits, validation, mesure et coûts restent à construire. Notre guide des agents IA en entreprise aide à vérifier avant tout qu'un agent est le bon outil pour votre cas.
Pour un besoin qui dépasse le prototype, c'est le travail de notre offre de développement d'agents IA sur mesure, avec des outils typés selon les droits, une validation humaine, un jeu de test et un suivi en production, quel que soit le framework retenu.
Vous hésitez entre un graphe et une boucle d'outils ?
Décrivez-nous le processus, les validations nécessaires et le modèle visé. Nous vous disons ce que nous construirions, avec quel outil, et comment nous le mesurerions, sur devis.
Prendre un rendez-vousQuestions fréquentes sur LangGraph
Pour aller plus loin
- Guide des agents IA en entreprise, pour savoir quand un agent apporte quelque chose.
- Frameworks d'agents IA, LangChain, LangGraph et CrewAI face aux besoins d'un projet réel.
- Claude Agent SDK en production, ce que la bibliothèque gère et ce qu'il reste à développer.
- Cas client ModelRH, des outils typés selon les droits et une validation humaine.
Formation
Pour que vos équipes appliquent ces usages sur leurs propres documents, voir notre formation agents IA, construite sur vos cas.