Technical Tutorials

Alors que les grands modèles de langage (LLM) évoluent de simples complétions de texte vers des agents autonomes, les modèles architecturaux pour les construire doivent aussi mûrir. Bien que des frameworks comme LangChain aient été essentiels pour simplifier l'intégration des LLM, ils étaient principalement conçus pour des chaînes linéaires. Cependant, les applications enterprise réelles suivent rarement une ligne droite. Elles nécessitent des boucles, une logique de branching, une exécution conditionnelle et, surtout, une gestion d'état persistante. C'est ici que LangGraph entre en scène. Construit sur LangChain, LangGraph est une bibliothèque pour créer des applications multi-acteurs avec état utilisant des LLM, conçue spécifiquement pour résoudre les limites des structures de graphes linéaires.

Pourquoi des graphes plutôt que des chaînes ?

Le changement fondamental dans LangGraph est le passage d'un graphe acyclique dirigé (DAG) à un graphe général qui supporte les cycles. Dans une chaîne traditionnelle, les données circulent de A à B à C. Si une erreur se produit ou qu'un point de décision est atteint, la chaîne se brise généralement ou nécessite une logique de wrapper complexe pour gérer les nouvelles tentatives. En revanche, un graphe permet aux nœuds de se reconnecter aux nœuds précédents, permettant des comportements récursifs. Cette structure est idéale pour les agents qui doivent :

Planifier et Exécuter : Générer un plan, exécuter une étape, observer le résultat et replanifier si l'étape a échoué.
Gérer les erreurs avec élégance : Rediriger l'exécution vers un nœud de gestion d'erreurs sans faire planter l'ensemble du flux de travail.
Gérer un état complexe : Maintenir un objet d'état partagé qui évolue à mesure que l'agent interagit avec des outils et de la mémoire.

Concepts clés : Nœuds, Arêtes et État

Pour exploiter LangGraph, vous devez penser en termes de machines à états. Les trois abstractions principales sont :

État (State) : Un TypedDict Python qui définit le schéma des données circulant dans le graphe. Chaque nœud lit et écrit dans cet état.
Nœuds : Des fonctions ou classes individuelles qui effectuent des calculs, appellent des LLM ou exécutent des outils. Ce sont des fonctions pures qui transforment l'état.
Arêtes (Edges) : Les connexions entre les nœuds. Elles peuvent être statiques (toujours aller au Nœud B) ou conditionnelles (décider entre le Nœud B ou le Nœud C en fonction de l'état).

En définissant ces composants, vous créez un flux de travail visualisable et débogable. LangGraph fournit un outil de visualisation qui rend votre structure de graphe, facilitant la compréhension des comportements d'agents complexes.

Construire une boucle simple : Le motif ReAct

L'un des cas d'utilisation les plus courants pour LangGraph est la mise en œuvre du motif ReAct (Reasoning and Acting), où un agent alterne entre la réflexion (appeler un LLM) et l'action (utiliser des outils). Voici un exemple pratique de la façon de définir une structure d'état et de graphe simple en Python.

from langchain_core.messages import HumanMessage
from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated, List, Operator
import operator

# 1. Définir le schéma de l'état
class AgentState(TypedDict):
    messages: Annotated[List, operator.add]
    steps: int

# 2. Définir les nœuds
def chatbot(state: AgentState):
    # Simuler la logique du LLM
    dernier_message = state["messages"][-1].content
    if "hello" in dernier_message.lower():
        return {"messages": [HumanMessage(content="Hi there! How can I help?")] }
    return {"messages": [HumanMessage(content="I'm not sure how to help with that.")] }

def check_step(state: AgentState):
    # Logique conditionnelle pour arrêter si les étapes dépassent la limite
    if state["steps"] < 5:
        return "continue"
    return "end"

# 3. Construire le graphe
workflow = StateGraph(AgentState)

# Ajouter les nœuds
workflow.add_node("chatbot", chatbot)
workflow.add_node("check", check_step)

# Ajouter les arêtes
workflow.add_edge(START, "chatbot")
workflow.add_conditional_edges(
    "chatbot",
    check_step,
    {
        "continue": "chatbot",  # Boucle arrière si continue
        "end": END              # Arrêter si end
    }
)

# Compiler l'application
app = workflow.compile()

# Exécuter le graphe
initial_state = {"messages": [HumanMessage(content="Hello")], "steps": 0}
result = app.invoke(initial_state)

Applications pratiques en entreprise

LangGraph brille dans les scénarios nécessitant des interactions humaines dans la boucle (human-in-the-loop). Par exemple, dans un bot de support client, vous pourriez vouloir que l'agent rédige une réponse, mette le graphe en pause, attende l'approbation d'un superviseur humain via une interface utilisateur séparée, puis n'envoie le message qu'après approbation. L'API checkpoint de LangGraph vous permet de sauvegarder l'état du graphe à n'importe quel nœud, permettant des capacités de pause et de reprise essentielles pour la conformité enterprise et les traces d'audit. De plus, LangGraph prend en charge les systèmes multi-agents. Vous pouvez définir des sous-graphes pour des agents spécialisés (par exemple, un "Agent de Recherche" et un "Agent de Codage") et les orchestrer au sein d'un graphe parent. Cette modularité permet des architectures hautement évolutives et maintenables.

Conclusion

LangGraph représente une étape significative dans l'évolution du développement d'applications LLM. En fournissant un cadre robuste pour les flux de travail cycliques, la gestion d'état et la visualisation, il permet aux développeurs de construire des agents qui ne sont pas seulement intelligents, mais aussi fiables et déterministes dans leur flux de contrôle. Pour les développeurs souhaitant aller au-delà des simples chatbots et construire des systèmes autonomes complexes, maîtriser LangGraph n'est plus une option — c'est essentiel.