Outils & Modèles Par

LangGraph en production : quand l'utiliser pour un agent IA

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 expliciteUn 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
PersistanceUn checkpointer sauvegarde l'état et permet de reprendre après une panne ou une pause
InterruptionL'exécution s'arrête, la personne inspecte ou modifie l'état, puis le graphe continue
FluxDiffusion 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.

SujetCe que LangGraph apporteCe qu'il reste à développer
Droits par utilisateurRien de spécifiqueLes outils chargés selon le profil, le cloisonnement entre clients, le contrôle dans l'API appelée
Jeu de testRienDes scénarios issus de demandes réelles, rejoués à chaque changement de prompt, d'outil ou de modèle
MesureDes états inspectables à chaque étapeTaux de réussite, appels inutiles, durée et coût par tâche
ObservabilitéDes états sauvegardés par étapeDes traces, des alertes et un outil pour les relire
CoûtsRienUn 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èreLangGraphPydantic AIClaude Agent SDK
Idée centraleUn graphe d'états explicite, avec persistance et interruptionDes agents Python typés, avec outils, sorties structurées et dépendancesLa boucle d'agent de Claude Code, avec ses outils et ses permissions
ModèlesPlusieurs, par les intégrations de l'écosystèmePlusieurs fournisseurs, dont des modèles locauxClaude (API Anthropic, Bedrock, Google Cloud, Foundry)
Validation humaineFonction interrupt et reprise par CommandApprobation humaine des outilsCallback can_use_tool et hooks
ExploitationUne bibliothèque Python, plus une base pour les points de repriseUne bibliothèque Python ordinaireUn binaire Claude Code embarqué, à héberger
Cas typiqueProcessus long à étapes, avec pause et repriseAgent métier branché sur des API, modèle à pouvoir changerAgent 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-vous

Questions fréquentes sur LangGraph

LangGraph est un framework d'orchestration de bas niveau, avec son runtime, pour des agents à état qui durent. On décrit l'agent comme un graphe dont les nœuds sont des fonctions et dont l'état est partagé. La bibliothèque sauvegarde cet état à chaque étape, ce qui permet de reprendre après une panne, de suspendre pour une validation humaine et de diffuser les résultats au fil de l'exécution.
Selon la documentation, LangChain est le framework d'agents, avec ses abstractions et ses intégrations de modèles et d'outils, tandis que LangGraph est la couche d'orchestration qui donne le contrôle explicite de l'état et du flux. LangGraph fonctionne seul et ne demande pas LangChain, même si ses exemples s'en servent souvent. On commence par LangChain pour un agent simple et on descend vers LangGraph quand il faut piloter chaque transition.
Rarement. Un agent qui répond à des questions en lisant des données, en quelques secondes, sans validation ni reprise, tient dans une boucle d'outils classique. LangGraph apporte de la valeur quand le processus est long, comporte plusieurs étapes, doit s'arrêter pour une validation humaine ou doit pouvoir reprendre après un incident.
On compile le graphe avec un checkpointer, on appelle la fonction interrupt dans le nœud qui doit attendre, puis on reprend l'exécution avec Command(resume=...) sur le même identifiant de fil (thread_id). La valeur de reprise devient le retour de interrupt. Placez l'écriture dans un nœud distinct, exécuté après la validation, pour qu'aucune action ne parte avant la décision.
L'installation se fait avec pip install -U langgraph (ou uv add langgraph). Le plus simple est de reproduire l'exemple de la documentation officielle, un StateGraph à un nœud, puis d'ajouter un checkpointer et une interruption. Pour un premier tutoriel, gardez un modèle simulé et vérifiez le graphe sans appel réseau avant de brancher un vrai modèle.
Non, la bibliothèque s'utilise seule. En auto-hébergement, il faut un checkpointer durable, la documentation citant PostgresSaver pour la production. LangSmith est la plateforme de traçage, d'évaluation et de déploiement de l'éditeur, et son Agent Server prend en charge la persistance à votre place. Vérifiez les conditions et la tarification sur le site de l'éditeur avant de choisir.
Les trois sont utilisables en production et répondent à des contraintes différentes. LangGraph convient aux processus à étapes avec pause et reprise. Pydantic AI convient aux agents Python typés qui doivent pouvoir changer de modèle. Le Claude Agent SDK convient à une boucle d'agent complète avec les modèles Claude. Le choix dépend du processus à couvrir, du modèle visé et de l'équipe qui maintiendra le code.
La bibliothèque elle-même ne se facture pas. Le coût vient des appels au modèle, au volume de tokens, et de l'hébergement de la base qui stocke les points de reprise. Il augmente avec le nombre d'étapes et la taille du contexte. Il faut le mesurer par tâche sur un jeu de test avant de chiffrer un déploiement, et purger les anciens points de reprise.

Pour aller plus loin

Formation

Pour que vos équipes appliquent ces usages sur leurs propres documents, voir notre formation agents IA, construite sur vos cas.

Agents IA sur mesure

Une tâche qui prend des heures à votre équipe chaque semaine ?

On construit l'agent qui la traite de bout en bout dans vos outils : il lit, vérifie, rédige ou saisit, et vous gardez la validation sur ce qui compte.

Anas Rabhi, ingénieur IA et data scientist, fondateur de Tensoria
Anas R. Ingénieur IA, fondateur de Tensoria ianas.fr

Je suis ingénieur IA et data scientist, fondateur de Tensoria. Depuis plus de 6 ans, je conçois et développe des systèmes IA pour les entreprises : assistants internes basés sur RAG, agents IA en production, automatisations sur mesure, traitement intelligent de documents. Je prends le projet en charge du cadrage à la mise en production, sur les modèles du marché (Mistral, Claude, GPT) ou sur des modèles ouverts hébergés chez le client quand la confidentialité l'exige.