LangGraph : des agents avec état sous forme de graphe orienté

LangGraph est un framework d'orchestration bas niveau de LangChain Inc. destiné à construire des agents IA avec état et de longue durée. Il ne modélise pas un agent comme un script linéaire, mais comme un graphe orienté composé de nœuds et d'arêtes, avec un objet d'état partagé, un checkpointing persistant, des points human-in-the-loop et du streaming. Depuis octobre 2025, LangGraph est disponible en version majeure stable 1.x, sous licence MIT, et prend en charge Python et JavaScript/TypeScript.

Pour exploiter des agents en production au-delà de simples appels à l'API d'un LLM, il faut un pilotage du déroulement maîtrisé et un état fiable. C'est exactement pour cela que LangGraph a été conçu : faible niveau d'abstraction, contrôle explicite, durable execution.

Réponses rapides

• Ce que c'est : une couche d'orchestration qui décrit les workflows d'agents comme un graphe de nœuds (logique) et d'arêtes (flux de contrôle) reposant sur un état partagé.
• Pour quels usages : les workflows multi-étapes complexes, contrôlés et de longue durée, en particulier avec état, validations et obligation d'audit.
• Distinction : LangGraph n'est pas le successeur de LangChain, mais la couche d'orchestration avec état qui se place au-dessus. LangChain fournit les modèles et les outils, LangGraph le déroulement.

Le modèle de base : Nodes, Edges, State, Reducer

LangGraph décrit un agent comme un State Graph. Le modèle repose sur trois briques :

• State : un objet typé et partagé qui traverse l'ensemble du graphe. Chaque étape lit dans le state et y réécrit. Le state est la seule source de vérité sur l'avancement d'une exécution.
• Nodes (nœuds) : des fonctions qui effectuent le travail, par exemple appeler un LLM, exécuter un outil ou valider un résultat. Un nœud reçoit le state actuel et renvoie une mise à jour du state.
• Edges (arêtes) : elles déterminent quel nœud s'exécute ensuite. Les arêtes conditionnelles (conditional edges) permettent des branchements selon le state, ce qui rend possibles des boucles, des retries et des chemins dynamiques qu'un pipeline linéaire ne peut pas représenter.

Le concept de reducer est essentiel. Lorsque plusieurs nœuds écrivent dans le même champ du state, comme une liste de messages, le reducer détermine comment les mises à jour sont fusionnées, par exemple en ajoutant au lieu d'écraser. Les étapes parallèles ou itératives restent ainsi sans conflit. C'est toute la différence entre une boucle d'agent fragile bricolée maison et une machine à états maîtrisée.

Persistance et checkpointing : durable execution

La propriété la plus importante de LangGraph en production est la durable execution grâce au checkpointing. Après chaque étape, le state est enregistré de façon persistante dans un backend. Il en découle trois capacités concrètes :

• Pause et reprise : une exécution peut être interrompue puis reprise plus tard exactement au même endroit, sans perte de progression.
• Tolérance aux pannes : si un workflow de longue durée plante, il ne repart pas de zéro, mais du dernier checkpoint.
• Voyage dans le temps : on peut inspecter un state antérieur et faire repartir l'exécution dans une nouvelle branche à partir d'un point précis, ce qui facilite nettement le débogage et l'auditabilité.

Depuis la version 1.2, des timeouts par nœud limitent la durée d'exécution de chaque nœud. Un arrêt contrôlé (graceful drain) stoppe une exécution après l'étape en cours et enregistre un checkpoint qui permet de la reprendre. Pour les threads longs, le DeltaChannel n'enregistre à chaque étape que la modification au lieu de la valeur entière, mais il est actuellement marqué comme bêta.

Human-in-the-loop, streaming et sous-graphes

Human-in-the-loop (HITL) : comme le state est persistant, un graphe peut s'arrêter à un endroit défini et attendre une décision humaine, par exemple une validation avant une action payante ou irréversible. Le workflow ne continue qu'après confirmation. C'est précisément ce dont ont besoin les secteurs réglementés soumis à une exigence de supervision humaine (human oversight).

Streaming : LangGraph diffuse en streaming les résultats intermédiaires, les tokens et la progression des étapes. Deux options sont disponibles, un streaming type-safe (v2) et un streaming par blocs de contenu (v3), pour que les interfaces affichent en direct la progression de l'agent.

Sous-graphes : un graphe peut être intégré comme nœud dans un graphe plus grand. Cela permet d'encapsuler des modules d'agents réutilisables et de composer proprement des architectures multi-agents complexes, comme les patterns supervisor ou swarm, au lieu de tout entasser dans un déroulement monolithique.

Pseudo-code : un graphe simple

L'exemple de pseudo-code suivant montre une boucle d'agent minimale : un nœud modèle décide, un nœud outils exécute, une arête conditionnelle ferme la boucle.

```
State = {
messages: list # Reducer : ajouter, ne pas écraser
}

def call_model(state):
reponse = llm.invoke(state.messages)
return {"messages": [reponse]}

def call_tools(state):
resultat = tools.run(state.messages[-1].tool_calls)
return {"messages": [resultat]}

def should_continue(state):
if state.messages[-1].a_des_tool_calls:
return "tools" # arête conditionnelle -> exécuter l'outil
return END # réponse prête -> terminer

graph = StateGraph(State)
graph.add_node("model", call_model)
graph.add_node("tools", call_tools)
graph.set_entry_point("model")
graph.add_conditional_edges("model", should_continue)
graph.add_edge("tools", "model") # boucle de retour vers le modèle

app = graph.compile(checkpointer=Checkpointer())
app.invoke({"messages": [user_input]}, config={"thread_id": "client-42"})
```

Le thread_id rattache l'exécution à une série de checkpoints. C'est précisément ce mécanisme qui permet de poursuivre plus tard le même fil de conversation ou de processus au lieu de tout recommencer à chaque fois.

LangGraph vs LangChain : la différence

Une confusion fréquente : LangGraph n'est pas la prochaine version de LangChain. Les deux viennent de LangChain Inc., mais remplissent des rôles différents. LangChain est la bibliothèque pour les modèles, les prompts et les intégrations d'outils (plus de 750 outils dans l'écosystème). LangGraph est l'orchestration bas niveau qui assemble ces briques en un déroulement avec état et de longue durée. La migration du LangChain classique vers LangGraph se fait de manière incrémentale, et les composants LangChain existants restent utilisables.

L'écosystème se structure en couches bien distinctes : LangChain (bibliothèque et intégrations) fournit les briques, LangGraph (orchestration, durable) pilote le déroulement, LangSmith (évaluation et observabilité) assure le tracing, et LangSmith Deployment (anciennement LangGraph Platform) propose un hébergement managé.

Pour les protocoles MCP et A2A, il existe désormais des voies officielles. En Python, tu intègres les outils MCP via le module langchain.mcp, disponible à partir de langchain 1.4.0 via l'extra langchain[mcp] et actuellement marqué comme bêta. Il remplace le paquet langchain-mcp-adapters, dont le dépôt est archivé. À l'inverse, l'Agent Server, sur lequel repose LangSmith Deployment, expose nativement tes agents en tant qu'endpoint MCP sous /mcp et endpoint A2A sous /a2a/{assistant_id}.

Fonctionnalités et bénéfices en un coup d'œil

Exemple concret : processus contrôlé avec validation

Une agence B2B développe pour un client du secteur de l'assurance un agent qui prétraite les déclarations de sinistre : lire les documents, extraire les données, les vérifier au regard des polices, faire intervenir un gestionnaire pour validation lorsque le montant dépasse 5 000 euros, puis créer le dossier.

Avec LangGraph, cela devient un graphe à quatre nœuds avec une arête conditionnelle au niveau du seuil. Si le montant dépasse la limite, le graphe s'arrête à un point HITL et enregistre son state de façon persistante ; après validation, il reprend. Si le système tombe en panne entre-temps, l'exécution reprend au dernier checkpoint et aucun document n'est traité deux fois. Chaque étape est traçable dans LangSmith, ce qui satisfait l'exigence d'auditabilité.

Le prix de ce contrôle, c'est la courbe d'apprentissage. Des analyses tierces chiffrent le surcoût à environ 120 lignes de code pour un agent ReAct, contre environ 40 dans des frameworks plus légers. En contrepartie, le déroulement se pilote de façon déterministe au lieu de reposer sur une boucle boîte noire difficile à déboguer. LangGraph est utilisé en production notamment par Klarna, Replit, Uber, LinkedIn et Elastic.

Pour les agences et les équipes B2B

LangGraph est le bon choix si tu as besoin d'agents contrôlés, de longue durée et auditables, pas du prototype de démo le plus rapide. Pour les entreprises en Europe soumises à des exigences de RGPD et de souveraineté, un point est décisif : le framework est open source (MIT) et entièrement auto-hébergeable, par exemple sur STACKIT, IONOS ou OVHcloud. La solution managée LangSmith existe aussi dans une région UE avec un centre de données Google Cloud aux Pays-Bas, au même prix sur tous les plans. Le cocontractant reste toutefois la société américaine LangChain : selon la FAQ sur les régions, il n'existe pas de société européenne pour les contrats clients. Il faut donc vérifier en amont le contrat de sous-traitance (DPA) et les transferts vers des pays tiers (ceci ne constitue pas un conseil juridique). Chez Blck Alpaca, nous évaluons avec toi si LangGraph, un framework plus léger ou une solution directe et épurée correspond le mieux à ton cas d'usage, puis nous mettons en œuvre l'architecture dans le respect des exigences de souveraineté. Contacte-nous pour une évaluation de frameworks.