LangGraph

Définition

LangGraph est un framework d'orchestration d'agents LLM basé sur des graphes d'états, développé par l'équipe LangChain en 2024 comme solution aux limitations des chains séquentielles pour les workflows d'agents complexes. Son modèle de programmation graphe orienté permet de créer des agents avec des boucles de rétroaction, des branchements conditionnels, des états persistants et des checkpoints — essentiels pour les agents de production robustes. L'abstraction fondamentale de LangGraph est le StateGraph : un graphe dans lequel les nœuds (nodes) sont des fonctions qui lisent et modifient un état partagé (state), et les arêtes (edges) définissent les transitions entre nœuds (conditionnelles ou fixes). Cet état peut être persisté (via checkpointers SQLite, Postgres, Redis), permettant la reprise de workflows interrompus et l'implémentation de "human-in-the-loop". LangGraph résout le problème des cycles dans les agents : dans un agent ReAct par exemple, l'agent peut itérer (Thought → Action → Observation) un nombre variable de fois avant de terminer. LangGraph modélise ceci naturellement comme un cycle dans le graphe, avec une condition de terminaison explicite. Les frameworks linéaires (LangChain LCEL, CrewAI séquentiel) ne peuvent pas représenter ces cycles nativement. Les patterns d'agents LangGraph incluent : l'agent ReAct avec outils, le multi-agent supervisor (un nœud supervisor route les requêtes vers des agents spécialisés), le plan-and-execute (nœud planner génère un plan, nœuds executors l'exécutent pas à pas), et le reflexion (nœud critique évalue les sorties et déclenche des cycles de révision). Pour les déploiements production, LangGraph Server (anciennement LangServe) et LangGraph Cloud permettent de déployer des agents LangGraph avec scalabilité horizontale, streaming de réponses et monitoring via LangSmith.

Agent ReAct avec LangGraph

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    tool_calls: list
    final_answer: str

def should_continue(state: AgentState) -> str:
    'Décide si continuer (tool call) ou terminer.'
    if state["final_answer"]:
        return "end"
    return "call_tools"

# Construction du graphe
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", tool_executor)

workflow.set_entry_point("agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {"call_tools": "tools", "end": END}
)
workflow.add_edge("tools", "agent")  # Boucle : tools → agent

app = workflow.compile(
    checkpointer=MemorySaver()  # Persistance de l'état
)

Human-in-the-Loop avec LangGraph

from langgraph.checkpoint.sqlite import SqliteSaver

# Compile avec checkpointer
app = workflow.compile(checkpointer=SqliteSaver.from_conn_string("./checkpoints.db"),
                       interrupt_before=["tools"])  # Pause avant chaque tool call

# L'agent pause → humain valide → reprise
config = {"configurable": {"thread_id": "session-123"}}
app.stream({"messages": [HumanMessage("Analyse ce log d'incident")]}, config)
# → L'agent propose un tool call → attend approbation humaine
app.stream(None, config)  # Reprendre après validation

Articles liés

Expert en cybersécurité offensive et intelligence artificielle. Pentest, audit et développement IA sur-mesure.

Services

Ressources

Projets & Outils

Contact

Nous contacter

Mentions légales Confidentialité Politique éditoriale Plan du site ⭐ Source préférée

Un projet cybersécurité ?

Expert dispo · Réponse 24h

Devis