LangGraph vs LangChain : lequel choisir ?

Introduction

Quand on débute avec les agents IA en Python, la question revient systématiquement : faut-il utiliser LangChain ou LangGraph ? La confusion est compréhensible — les deux partagent le même écosystème, la même organisation (LangChain Inc.), et souvent les mêmes imports. Pourtant, ce ne sont pas des concurrents directs. LangGraph est construit sur LangChain et répond à un besoin différent : orchestrer des agents complexes avec des workflows à états. Ce guide vous donne une réponse claire selon votre cas d'usage.

---

Résumé rapide

Critère	LangChain	LangGraph
Rôle principal	Couche d'abstraction LLM + chaînes	Orchestration d'agents par graphe d'états
Relation	Framework de base	Extension construite sur LangChain
Complexité	Faible à modérée	Modérée à élevée
Cas d'usage idéal	Pipelines LLM linéaires, chatbots	Agents multi-étapes, workflows cycliques
Gestion d'état	Limitée (mémoire conversationnelle)	Native et explicite (StateGraph)
Courbe d'apprentissage	Accessible	Plus raide

---

Explication : LangGraph est construit sur LangChain

Avant de comparer, il faut comprendre la relation architecturale entre les deux outils — c'est la clé pour éviter un faux dilemme.

LangChain est né en 2022 comme couche d'abstraction entre votre code Python et les LLM (OpenAI, Anthropic, Mistral…). Il fournit une interface unifiée pour appeler des modèles, chaîner des étapes de traitement (prompts, parsers, retrievers), et connecter des outils externes. Son paradigme central est la chain : une séquence linéaire d'opérations. LangChain excelle pour les pipelines RAG (Retrieval-Augmented Generation), les chatbots simples, et tout workflow qui se déroule de gauche à droite sans retour en arrière.

LangGraph est apparu en 2024 pour adresser une limite fondamentale de LangChain : l'impossibilité de modéliser des workflows non-linéaires et cycliques. Un agent qui doit boucler, se corriger, prendre des décisions conditionnelles ou maintenir un état complexe entre plusieurs appels LLM ne rentre pas dans le modèle de chaîne.

LangGraph introduit un paradigme de graphe d'états : chaque nœud est une fonction ou un agent, chaque arête représente une transition conditionnelle, et un StateGraph central maintient l'état partagé entre toutes les étapes. Techniquement, LangGraph importe et utilise les composants LangChain (LLM wrappers, tools, prompts) — il n'en est pas une alternative, mais une extension.

La métaphore : LangChain est le moteur, LangGraph est la boîte de vitesses automatique qui permet de changer de rapport selon la situation.

---

Développement principal

Tableau comparatif détaillé

Critère	LangChain	LangGraph
Paradigme	Chaînes séquentielles (LCEL)	Graphe d'états dirigé
Gestion d'état	Mémoire conversationnelle basique	StateGraph typé, persistant
Cycles et boucles	Non supportés nativement	Natifs (arêtes conditionnelles)
Agents multi-étapes	AgentExecutor (limité)	Orchestration complète
Debugging	LangSmith intégré	LangSmith + visualisation du graphe
Multi-agents	Minimal	Natif (superviseur/sous-agents)
Déploiement production	Variable	LangGraph Platform (API + workers)
Dépendance	Autonome	Requiert LangChain
Communauté	Très large, mature	En forte croissance
Verbosité du code	Modérée	Plus élevée

Forces et limites de LangChain

Forces :

• Intégration native avec 300+ LLM, embeddings et vector stores
• Syntaxe LCEL (LangChain Expression Language) concise pour les pipelines linéaires
• Écosystème documenté avec des dizaines d'exemples prêts à l'emploi
• Idéal pour prototyper rapidement un pipeline RAG ou un chatbot

Limites :

• AgentExecutor devient difficile à déboguer et à contrôler sur des workflows complexes
• Pas de gestion d'état structurée entre plusieurs appels LLM indépendants
• Les boucles et la logique conditionnelle complexe nécessitent du code custom peu maintenable
• Peu adapté à la collaboration entre plusieurs agents spécialisés

Forces et limites de LangGraph

Forces :

• Contrôle total sur la logique de décision (conditions, boucles, retours en arrière)
• État partagé typé avec TypedDict — robuste en production
• Visualisation du graphe pour le debugging
• Orchestration native de systèmes multi-agents
• LangGraph Platform pour déployer des agents en production avec persistance et concurrence

Limites :

• Verbosité : même un agent simple nécessite plus de boilerplate
• Courbe d'apprentissage sur le concept de graphe d'états
• Dépendance à LangChain — si vous voulez sortir de l'écosystème, c'est plus complexe
• Moins d'exemples documentés que LangChain pur

Quand utiliser LangChain seul

Choisissez LangChain (sans LangGraph) si votre workflow est :

• Linéaire : étapes qui s'enchaînent sans condition ni boucle
• Simple : chatbot avec mémoire conversationnelle, pipeline RAG standard, résumé de document
• Prototype : vous avez besoin de quelque chose qui fonctionne en quelques heures
• Faible tolérance à la complexité : votre équipe n'est pas familière avec les graphes d'états

Exemples typiques : chatbot FAQ, pipeline question-réponse sur PDF, génération de contenu automatisée, extraction d'information structurée.

Quand utiliser LangGraph

Choisissez LangGraph dès que votre agent doit :

• Boucler : un agent de recherche qui itère jusqu'à trouver une réponse satisfaisante
• Décider : router vers différents sous-agents selon le contexte
• Corriger : un agent de code qui teste, détecte les erreurs et se corrige
• Collaborer : plusieurs agents spécialisés coordonnés par un superviseur
• Persister : maintenir un état complexe sur plusieurs sessions utilisateur

Exemples typiques : agent de recherche web itératif, agent de codage autonome, système de validation multi-étapes, orchestration de systèmes multi-agents.

Différence d'approche : pseudocode

Approche LangChain (pipeline RAG linéaire) :

# LangChain — pipeline séquentiel avec LCEL
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_template(
    "Réponds à la question : {question}\nContexte : {context}"
)

# Chain linéaire : retriever → prompt → LLM → parser
chain = retriever | prompt | llm | StrOutputParser()

# Exécution directe, pas d'état persistant
response = chain.invoke({"question": "Qu'est-ce que LangGraph ?"})

Approche LangGraph (agent avec boucle de correction) :

# LangGraph — graphe d'états avec logique conditionnelle
from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    question: str
    research: list[str]
    answer: str
    quality_score: float

def research_node(state: AgentState) -> AgentState:
    # Appel LLM pour chercher des informations
    ...
    return {**state, "research": results}

def answer_node(state: AgentState) -> AgentState:
    # Génère une réponse basée sur la recherche
    ...
    return {**state, "answer": answer, "quality_score": score}

def should_continue(state: AgentState) -> str:
    # Logique de décision : continuer ou terminer
    if state["quality_score"] < 0.8:
        return "research"  # Boucle vers nouvelle recherche
    return END

# Construction du graphe
graph = StateGraph(AgentState)
graph.add_node("research", research_node)
graph.add_node("answer", answer_node)
graph.add_conditional_edges("answer", should_continue)
graph.set_entry_point("research")

agent = graph.compile()
result = agent.invoke({"question": "Qu'est-ce que LangGraph ?"})

La différence est structurelle : LangChain exprime un flux de données, LangGraph exprime un flux de contrôle.

Conclusion tranchée

Utilisez LangChain seul pour tout pipeline linéaire, tout prototype, tout système où la complexité de LangGraph n'apporte pas de valeur. LangChain reste le meilleur outil d'intégration LLM de l'écosystème Python.

Utilisez LangGraph dès que votre agent doit raisonner en plusieurs étapes avec des cycles, des décisions conditionnelles ou une collaboration entre agents. En production, LangGraph est aujourd'hui la référence pour les agents robustes et maintenables.

Ce n'est pas un choix exclusif : la plupart des projets LangGraph utilisent LangChain en dessous. La vraie question est "ai-je besoin d'un graphe d'états ?" — si oui, LangGraph. Sinon, LangChain suffit.

---

Exemple concret

Même use-case : agent de recherche web + synthèse

Imaginons un agent qui doit répondre à une question complexe en cherchant sur le web et en synthétisant les résultats.

Version LangChain (pipeline direct) :

# LangChain — une seule passe, résultat immédiat
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

search = DuckDuckGoSearchRun()
llm = ChatOpenAI(model="gpt-4o")

# Pipeline : recherche → formatage → synthèse LLM
def research_and_synthesize(question: str) -> str:
    search_results = search.run(question)
    prompt = ChatPromptTemplate.from_template(
        "Question : {question}\n\nRésultats de recherche :\n{results}\n\nSynthèse :"
    )
    chain = prompt | llm | StrOutputParser()
    return chain.invoke({"question": question, "results": search_results})

Simple et efficace — mais si les résultats sont insuffisants, l'agent ne peut pas relancer une recherche. Il retourne ce qu'il a, même si c'est incomplet.

Version LangGraph (agent itératif avec contrôle qualité) :

# LangGraph — agent qui boucle jusqu'à obtenir une réponse satisfaisante
class ResearchState(TypedDict):
    question: str
    search_queries: list[str]
    results: list[str]
    synthesis: str
    is_sufficient: bool
    iterations: int

def generate_query_node(state):
    # Génère une requête de recherche adaptée
    query = llm.invoke(f"Génère une requête de recherche pour : {state['question']}")
    return {**state, "search_queries": state["search_queries"] + [query.content]}

def search_node(state):
    # Exécute la recherche avec la dernière requête
    results = search.run(state["search_queries"][-1])
    return {**state, "results": state["results"] + [results]}

def evaluate_node(state):
    # Évalue si les résultats sont suffisants
    evaluation = llm.invoke(
        f"Les résultats suivants répondent-ils à '{state['question']}' ? "
        f"Réponds par OUI ou NON.\n\n{state['results']}"
    )
    sufficient = "OUI" in evaluation.content
    synthesis = llm.invoke(f"Synthétise : {state['results']}").content if sufficient else ""
    return {**state, "is_sufficient": sufficient, "synthesis": synthesis,
            "iterations": state["iterations"] + 1}

def route(state):
    if state["is_sufficient"] or state["iterations"] >= 3:
        return END
    return "generate_query"  # Nouvelle recherche

graph = StateGraph(ResearchState)
graph.add_node("generate_query", generate_query_node)
graph.add_node("search", search_node)
graph.add_node("evaluate", evaluate_node)
graph.add_edge("generate_query", "search")
graph.add_edge("search", "evaluate")
graph.add_conditional_edges("evaluate", route)
graph.set_entry_point("generate_query")

La version LangGraph est plus verbale, mais elle peut itérer, s'auto-corriger et garantir une meilleure qualité de réponse — ce que la version LangChain ne peut pas faire nativement.

---

Bonnes pratiques

Ne pas choisir LangGraph par défaut. Si votre pipeline est linéaire, LangChain avec LCEL est plus lisible, plus rapide à développer et plus facile à maintenir. Réservez LangGraph aux cas où la complexité est justifiée.

Typer votre StateGraph dès le début. Utiliser TypedDict pour définir l'état de votre graphe évite les bugs silencieux en production et facilite le debugging avec LangSmith.

Limiter les itérations. Tout agent qui peut boucler doit avoir un compteur d'itérations maximal. Sans ça, un agent peut tourner indéfiniment et générer des coûts LLM incontrôlables.

Utiliser LangSmith pour les deux outils. La traçabilité des appels LLM est indispensable dès que vous dépassez le prototype — LangSmith fonctionne avec LangChain et LangGraph.

Migrer progressivement. Si vous avez un AgentExecutor LangChain qui devient ingérable, migrez vers LangGraph nœud par nœud. Les composants LangChain (LLM, tools, prompts) fonctionnent directement dans un graphe LangGraph sans réécriture.

Documenter le graphe. LangGraph permet d'exporter une visualisation du graphe. Utilisez-la comme documentation vivante pour votre équipe.

---

Questions fréquentes

LangGraph remplace-t-il LangChain ? Non. LangGraph est construit sur LangChain et l'utilise en interne. Vous ne choisissez pas l'un ou l'autre — vous choisissez LangChain seul pour les cas simples, ou LangChain + LangGraph pour les agents complexes. Les deux coexistent et se complètent.

Peut-on migrer un projet LangChain vers LangGraph ? Oui, et c'est souvent progressif. Vos chains LCEL, vos prompts et vos tools LangChain fonctionnent directement comme nœuds dans un StateGraph. La migration consiste principalement à restructurer la logique de contrôle autour du graphe, pas à réécrire les intégrations LLM.

LangGraph est-il plus lent que LangChain ? La différence de performance est négligeable comparée aux latences des appels LLM. LangGraph ajoute un overhead minimal pour la gestion d'état. En production, LangGraph Platform peut même améliorer les performances grâce à l'exécution parallèle des nœuds indépendants.

Faut-il connaître LangChain pour apprendre LangGraph ? C'est fortement recommandé. LangGraph utilise les abstractions LangChain (ChatModel, Tool, PromptTemplate). Comprendre LangChain d'abord facilite l'apprentissage de LangGraph. Comptez 1-2 semaines pour maîtriser LangChain, puis 1-2 semaines supplémentaires pour LangGraph.

LangGraph fonctionne-t-il avec d'autres LLM que OpenAI ? Oui. LangGraph utilise les wrappers LangChain, qui supportent Anthropic, Mistral, Ollama, Groq, et des dizaines d'autres providers. Vous changez de LLM en modifiant une ligne, sans toucher à la logique du graphe.

---

Articles liés

LangGraph et LangChain s'inscrivent dans un écosystème plus large de frameworks pour agents IA. Pour choisir entre tous les outils disponibles — CrewAI, AutoGen, Semantic Kernel — consultez le comparatif complet des frameworks agent IA. Si vous hésitez spécifiquement entre LangGraph et CrewAI pour un système multi-agents, le comparatif CrewAI vs LangGraph vous donnera une réponse ciblée. Pour aller plus loin sur LangGraph, la page dédiée à LangGraph couvre l'architecture, l'installation et les patterns avancés.

• Comparatif complet des frameworks agent IA
• CrewAI vs LangGraph : quel orchestrateur choisir ?
• LangGraph : guide complet
• LangChain : guide complet
• Systèmes multi-agents : architecture et patterns