LangChain contre LangGraph : choisir entre les chaînes et les graphes à état

Si vous commencez à travailler sur le développement d’IA, deux noms reviennent sans cesse :

LangChain et LangGraph.

À première vue, ils semblent interchangeables. S’agit-il du même outil ? Faut-il en apprendre les deux ? Et comment choisir celui qui convient à votre projet ?

Décomposons cela avec un exemple simple.

Qu’est-ce que LangChain ?

Pensez à LangChain comme à une boîte à outils pour assembler des applications d’IA.

Il vous fournit des éléments prêts à l’emploi qui vous permettent de travailler avec des LLM et de les relier à d’autres ressources telles que :

• Prompts
• LLMs
• Outils
• APIs
• Documents
• Bases de données vectorielles
• Récupérateurs

Disons que vous souhaitez créer un tuteur d’IA de base.

Le flux de travail pourrait ressembler à ceci :

Student Question
       ↓
     Prompt
       ↓
      LLM
       ↓
     Answer

LangChain rend l’assemblage de ce type de pipeline assez simple.

Exemple simple de LangChain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini")prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful programming teacher."),
    ("human", "{question}")
])chain = prompt | llmresponse = chain.invoke({
    "question": "What is recursion?"
})print(response.content)

La logique ici est simple et linéaire :

Question → Prompt → LLM → Réponse

Ce type de pipeline en ligne droite est précisément ce pour quoi LangChain excelle.

Qu’est-ce que LangGraph ?

Supposons maintenant que votre tuteur IA doive gérer plus d’une seule étape.

Au lieu de simplement fournir une réponse, vous souhaitez qu’il :

1. Réponde à la question de l’élève.
2. Évalue si cette réponse est vraiment bonne.
3. Si elle est bonne, s’arrête là.
4. Si elle n’est pas bonne, la révise.
5. Vérifie à nouveau la réponse révisée.

Le flux ressemble maintenant davantage à ceci :

Student Question
                    ↓
              Generate Answer
                    ↓
               Check Answer
                ↙        ↘
             Good          Bad
              ↓             ↓
            Finish       Improve
                            ↓
                       Check Again

C’est précisément le type de scénario pour lequel LangGraph a été conçu.

LangGraph vous permet de concevoir des flux de travail qui peuvent inclure :

• Plusieurs étapes
• Branchements conditionnels
• Boucles
• État partagé
• Points de décision
• Approbation avec intervention humaine
• Comportement des agents plus riche

Un exemple simple de LangGraph

Pour commencer, vous définissez l’état que votre application doit suivre.

from typing import TypedDict

class State(TypedDict):
    question: str
    answer: str
    good: bool

Cet état suit trois éléments :

question
answer
good

Ensuite, vous créez des étapes individuelles, appelées nœuds, au sein de votre graphe.

Générer la réponse

def generate_answer(state):

    response = llm.invoke(
        f"Answer this question simply:\n{state['question']}"
    )    return {
        "answer": response.content
    }

Vérifier la réponse

def check_answer(state):

    response = llm.invoke(
        f"""
        Is this answer good?        Question:
        {state['question']}        Answer:
        {state['answer']}        Reply only YES or NO.
        """
    )    return {
        "good": response.content.strip().upper() == "YES"
    }

Ensuite, vous définissez une fonction de décision :

def decision(state):

    if state["good"]:
        return "finish"    return "improve"

Ce qui est important ici, c’est que LangGraph est celui qui relie ces nœuds entre eux et décide quel nœud sera exécuté ensuite.

Si la vérification échoue, le graphe peut revenir au nœud d’amélioration et réexécuter la vérification par la suite.

Quelle est donc la principale différence ?

Le moyen le plus simple de définir cette distinction est le suivant :

LangChain = Blocs de construction

LangChain fournit les composants individuels à partir desquels on assemble une application d’IA.

Par exemple :

LLM
Prompt
Retriever
Tool
Vector Database
     ↓
   LangChain

LangGraph = Flux de travail

LangGraph définit la manière dont ces composants interagissent et dans quel ordre.

Start
         ↓
      Generate
         ↓
       Check
      ↙     ↘
    Good     Bad
     ↓        ↓
   Finish   Improve
              ↓
            Check

LangChain et LangGraph sont-ils des concurrents ?

Pas vraiment.

Ils sont conçus pour être utilisés en parallèle.

Par exemple :

LangGraph
                     ↓
          ┌──────────┴──────────┐
          ↓                     ↓
     LangChain              LangChain
     Retriever                 Tools
          ↓                     ↓
          └──────────┬──────────┘
                     ↓
                    LLM

LangChain fournit les blocs de construction et les outils, tandis que LangGraph orchestre le flux de travail global autour d’eux.

Quand devriez-vous utiliser LangChain ?

LangChain est le choix idéal lorsque votre application suit un parcours plutôt linéaire.

Les cas typiques incluent :

• Un chatbot de base
• Une application basée sur RAG
• La réponse à des questions provenant d’un PDF
• La recherche dans des documents
• Une application simple alimentée par un LLM
• L’appel à des outils simples

Un flux de base pourrait ressembler à ceci :

User
 ↓
Retrieve Information
 ↓
LLM
 ↓
Answer

Pour ce type de configuration, créer une structure graphique complète est généralement excessif.

Quand devriez-vous utiliser LangGraph ?

LangGraph trouve sa place lorsque votre application nécessite une logique et des décisions ramifiées, et non simplement une séquence fixe d’étapes.

Cela inclut des situations telles que :

• Des agents IA autonomes
• Des workflows comprenant plusieurs étapes
• Des systèmes avec plusieurs agents coopératifs
• Des processus impliquant un intervenant humain

Flux qui nécessitent une boucle

Applications exigeant un état persistant entre les étapes

Chaînes avancées d’appels d’outils

Pour illustrer, imaginez un tuteur IA structuré de cette manière :

Student asks question
        ↓
Analyze level
        ↓
Generate explanation
        ↓
Give quiz
        ↓
Check answer
        ↓
Correct?
   ↙          ↘
 YES           NO
  ↓             ↓
Next topic   Explain again

Ce type de comportement branché et à état est précisément là où LangGraph excelle.

L’analogie la plus simple

Imaginez que vous construisez une maison.

LangChain agit comme votre boîte à outils.

Il vous fournit des éléments tels que :

Briques, outils, matériaux et composants.

LangGraph agit comme le plan d’architecture.

Il définit la séquence :

Poser les fondations → ériger les murs → ajouter le toit → vérifier le travail → si quelque chose ne va pas, revenir en arrière pour corriger.

En bref :

LangChain vous aide à assembler les éléments.

LangGraph vous aide à gérer ce processus.

Conclusion

Plutôt que de considérer LangChain et LangGraph comme des outils indépendants, il est plus exact de les voir comme deux couches du même ensemble logiciel.

AI Application
              ↓
          LangGraph
       (Workflow / Logic)
              ↓
          LangChain
      (Tools / Components)
              ↓
             LLM

Si votre cas d’usage est simple, LangChain seul suffira probablement à répondre à vos besoins.

Lorsque votre application nécessite le suivi de l’état, une logique conditionnelle, des boucles ou un comportement d’agent complexe, LangGraph s’avère plus adapté.

Cependant, dans de nombreux systèmes en production, les deux sont combinés.

Règle à retenir :

LangChain construit les composants. LangGraph relie et contrôle le flux.

Lectures complémentaires