Prendre RDV
Lexique · Frameworks / outils IA

LangGraph : définition, fonctionnement et cas d'usage

Le framework d'orchestration qui modélise les agents IA sous forme de graphes avec état : principes, exemple de code, fonctionnalités de production et différences avec LangChain.

Par Équipe Blent· Mis à jour le · 12 min de lecture· Niveau avancé

LangGraph en bref

Type
Framework open source d'orchestration
Éditeur
LangChain Inc.
Lancement
2024
Langages
Python, JavaScript / TypeScript
Licence
MIT
Spécialité
Agents et workflows avec état
Notions clés
État, nœuds, arêtes, checkpoints

Définition : LangGraph

LangGraph est un framework open source d'orchestration, développé par l'équipe de LangChain, qui permet de construire des agents IA et des workflows à base de LLM sous forme de graphes. Chaque nœud du graphe est une étape de traitement (appel à un modèle, recherche, outil), chaque arête définit la transition vers l'étape suivante, et un état partagé circule entre les nœuds. Contrairement à une chaîne linéaire, un graphe LangGraph peut contenir des boucles, des branchements conditionnels et des points de pause, et il sauvegarde son état à chaque étape pour reprendre une exécution, faire valider une action par un humain ou conserver la mémoire d'une conversation.

En une phrase : LangGraph orchestre des agents IA comme des graphes d'étapes qui partagent un état, avec boucles, persistance et validation humaine.

Dans cette définition

Qu'est-ce que LangGraph ?

LangGraph a été lancé début 2024 par l'équipe de LangChain pour répondre à une limite très concrète : les chaînes linéaires conviennent à un traitement fixe, mais pas à un agent IA, qui doit décider de la suite à chaque étape, réessayer, ou attendre une intervention humaine.

Le framework reprend une idée simple de la théorie des graphes. Une application est décrite comme un ensemble de nœuds (les étapes de traitement) reliés par des arêtes (les transitions), autour d'un état partagé qui circule de nœud en nœud. Ce modèle, inspiré de systèmes de calcul distribué comme Pregel, rend explicites des comportements qui restaient implicites dans un agent « boîte noire » : quand boucler, quand s'arrêter, quand demander de l'aide.

LangGraph est volontairement bas niveau : il n'impose ni prompt, ni architecture d'agent. Il fournit le moteur d'exécution, la persistance et les mécanismes de contrôle. Il a atteint sa version 1.0 en octobre 2025, et c'est sur lui que s'exécutent désormais les agents créés avec LangChain.

À retenir : LangChain fournit les briques, LangGraph orchestre leur exécution. On peut utiliser LangGraph sans LangChain, mais les deux sont conçus pour fonctionner ensemble.

Comment fonctionne LangGraph ?

Construire une application avec LangGraph revient à décrire un graphe en cinq temps, puis à le compiler en un programme exécutable.

  1. Définir l'état

    L'état est la structure de données partagée par tout le graphe : messages, question, documents retrouvés, résultat d'un outil. Il est typé (TypedDict ou Pydantic) et chaque champ peut avoir sa propre règle de mise à jour.

  2. Écrire les nœuds

    Un nœud est une simple fonction Python qui reçoit l'état et renvoie les champs à modifier. Il peut appeler un LLM, interroger une base, exécuter un outil ou appliquer une règle métier.

  3. Relier les nœuds par des arêtes

    Les arêtes fixes enchaînent deux étapes ; les arêtes conditionnelles choisissent la suite en fonction de l'état. C'est ce qui permet les boucles et les branchements.

  4. Compiler avec un checkpointer

    La compilation vérifie le graphe et y associe un mécanisme de persistance qui sauvegarde l'état après chaque étape, en mémoire, dans SQLite ou dans PostgreSQL.

  5. Exécuter, suivre et reprendre

    Le graphe s'exécute pour un fil de conversation donné. On peut diffuser les étapes en temps réel, l'interrompre pour une validation humaine, puis le reprendre exactement où il s'était arrêté.

Exemple : un RAG qui sait élargir sa recherche

Ce graphe interroge d'abord une base documentaire interne. Si aucun passage pertinent n'est trouvé, il bascule sur une recherche web avant de générer la réponse. L'état est sauvegardé à chaque étape pour chaque conversation.

python
from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver

class State(TypedDict):
    question: str
    documents: list[str]
    answer: str

def retrieve(state: State) -> dict:
    return {"documents": retriever.search(state["question"])}

def web_search(state: State) -> dict:
    return {"documents": web.search(state["question"])}

def generate(state: State) -> dict:
    return {"answer": llm_answer(state["question"], state["documents"])}

def route(state: State) -> str:
    # Rien de pertinent en interne : on élargit la recherche
    return "generate" if state["documents"] else "web_search"

builder = StateGraph(State)
builder.add_node("retrieve", retrieve)
builder.add_node("web_search", web_search)
builder.add_node("generate", generate)
builder.add_edge(START, "retrieve")
builder.add_conditional_edges("retrieve", route, ["generate", "web_search"])
builder.add_edge("web_search", "generate")
builder.add_edge("generate", END)

graph = builder.compile(checkpointer=InMemorySaver())
graph.invoke(
    {"question": "Quelle est notre politique de télétravail ?"},
    config={"configurable": {"thread_id": "conversation-42"}},
)

Le schéma est lisible d'un coup d'œil : trois nœuds, une arête conditionnelle, et un identifiant de fil (thread_id) qui permet de retrouver l'état de cette conversation lors des échanges suivants. En production, InMemorySaver est remplacé par un checkpointer PostgreSQL.

Les fonctionnalités clés pour la production

Au-delà du graphe lui-même, LangGraph apporte les mécanismes qui distinguent un prototype d'un agent exploitable. Notre article LangGraph : c'est quoi ? les détaille un par un.

  • Persistance (checkpointing) : l'état est enregistré après chaque nœud. Une exécution interrompue par une erreur ou un redémarrage reprend au dernier point sauvegardé.
  • Validation humaine (human-in-the-loop) : la fonction interrupt met le graphe en pause et attend une décision humaine avant de poursuivre.
  • Streaming : les étapes, les mises à jour d'état et les tokens générés sont diffusés en temps réel vers l'interface.
  • Retour arrière (time travel) : l'historique des checkpoints permet de rejouer une exécution depuis un état antérieur, pour déboguer ou explorer une autre branche.
  • Mémoire de long terme : un store dédié conserve des informations entre conversations, comme les préférences d'un utilisateur.
  • Sous-graphes et multi-agents : un graphe peut en contenir d'autres, ce qui permet de composer des architectures avec superviseur et agents spécialisés.

Que peut-on construire avec LangGraph ?

LangGraph prend tout son sens dès qu'une application LLM doit décider, revenir en arrière ou attendre une intervention humaine.

  • Agent outillé

    Un agent qui raisonne, appelle des outils, observe le résultat et recommence jusqu'à obtenir sa réponse.

  • RAG agentique

    Un RAG qui évalue la pertinence des documents retrouvés et relance une recherche si nécessaire.

  • Validation humaine

    Un workflow qui se met en pause avant une action sensible (envoi, paiement, écriture) pour la faire approuver.

  • Systèmes multi-agents

    Un superviseur qui délègue des sous-tâches à des agents spécialisés et assemble leurs résultats.

  • Assistant persistant

    Un assistant qui conserve le fil de chaque conversation et la mémoire de chaque utilisateur dans la durée.

  • Automatisation de processus

    Un traitement métier en plusieurs étapes (qualification, extraction, contrôle, routage) piloté par des LLM.

Quels sont les avantages de LangGraph ?

LangGraph a été conçu pour la production : son intérêt tient au contrôle qu'il donne sur chaque étape d'un agent.

  • Contrôle explicite du déroulé : chaque étape et chaque transition sont visibles dans le code.
  • Boucles et branchements natifs, impossibles à exprimer proprement avec une chaîne linéaire.
  • Persistance de l'état à chaque étape : reprise après erreur, mémoire de conversation, retour à un état antérieur.
  • Validation humaine intégrée, avec pause et reprise de l'exécution.
  • Streaming des étapes et des tokens pour des interfaces réactives.
  • Indépendant de LangChain : les nœuds peuvent appeler n'importe quel SDK ou modèle.

Quelles sont les limites de LangGraph ?

Ce contrôle a un prix : LangGraph est un outil bas niveau, qui demande plus de conception qu'une solution clé en main.

  • Courbe d'apprentissage réelle : état, réducteurs, checkpoints et interruptions sont des notions à assimiler.
  • Plus verbeux qu'un agent prêt à l'emploi pour un cas simple.
  • La conception du graphe et de l'état reste à la charge de l'équipe : un mauvais découpage se paie vite.
  • L'observabilité fine suppose un outil dédié (LangSmith, Langfuse) en plus du framework.
  • Le déploiement géré proposé par l'éditeur est une offre commerciale ; l'auto-hébergement demande de l'infrastructure.

LangGraph ou LangChain : quelles différences ?

Les deux frameworks viennent de la même équipe et se complètent plus qu'ils ne se concurrencent.

CritèreLangChainLangGraph
Niveau d'abstractionHaut niveau : composants et agent prêt à l'emploiBas niveau : moteur d'orchestration
StructureChaînes et agent standardGraphe explicite de nœuds et d'arêtes
Boucles et branchementsGérés par l'agent standardDéfinis librement dans le graphe
ÉtatHistorique de messagesÉtat typé et personnalisable
Persistance et repriseVia LangGraphNatives, à chaque étape
Idéal pourPrototyper vite, RAG, agents simplesAgents complexes, multi-agents, production

Une approche courante consiste à démarrer avec create_agent de LangChain, puis à descendre dans LangGraph lorsque le comportement de l'agent doit être finement contrôlé.

Quand utiliser LangGraph ?

La question à se poser : votre application suit-elle toujours le même chemin, ou doit-elle décider de la suite à chaque étape ?

Pertinent si

Le déroulé dépend de la situation

  • L'agent doit boucler, réessayer ou changer de stratégie.
  • Certaines actions exigent une validation humaine.
  • Les conversations doivent être reprises et mémorisées.
  • Plusieurs agents spécialisés collaborent.
Moins adapté si

Le traitement est linéaire et court

  • Un enchaînement fixe prompt, modèle, réponse suffit.
  • Un agent standard sans persistance fait l'affaire : create_agent de LangChain suffit.
  • L'équipe découvre les LLM et doit d'abord maîtriser les bases.
  • Une plateforme no-code couvre déjà le besoin.

Outils et alternatives autour de LangGraph

LangGraph s'utilise rarement seul : il s'appuie sur des composants, des outils d'observabilité, et se compare à d'autres frameworks multi-agents.

Les concepts à connaître pour comprendre LangGraph

LangGraph est le point de rencontre de plusieurs notions de l'Agentic AI.

Ressources pour approfondir LangGraph

Trois articles du blog Blent pour concevoir des agents robustes.

Questions fréquentes

Questions fréquentes

Oui. LangGraph est une bibliothèque open source sous licence MIT, utilisable gratuitement, y compris en production et dans un cadre commercial. Seules les offres de déploiement géré et d'observabilité proposées par LangChain Inc. sont payantes.

Expertise

À propos de l'auteur

Équipe Blent

Les ingénieurs et mentors Blent conçoivent, évaluent et mettent en production des agents IA, et forment chaque année des centaines de professionnels à l'IA générative.

Sources et méthodologie

  • Documentation officielle LangGraph (Python et JavaScript)
  • Annonce de LangChain 1.0 et LangGraph 1.0, octobre 2025
  • Retours d'expérience des projets et formations Blent
Lexique

Explorer le lexique

Voir toutes les définitions