L'Atelier — Réseau francophone IA (produit, tech, business)

Qu'est-ce que LangGraph ?

LangGraph est un framework de LangChain pour construire des agents et workflows multi-étapes sous forme de graphes d'état. Contrairement aux chaînes linéaires, LangGraph permet des cycles, des conditions, et une gestion fine de l'état.

Concepts fondamentaux

State (État)

L'état est un objet typé qui persiste entre les nœuds du graphe :

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

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    next_step: str
    iteration_count: int

Nodes (Nœuds)

Chaque nœud est une fonction qui reçoit l'état et retourne un état modifié :

def call_llm(state: AgentState) -> AgentState:
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def call_tool(state: AgentState) -> AgentState:
    tool_result = execute_tool(state["messages"][-1])
    return {"messages": [tool_result]}

Edges (Arêtes) et conditions

def should_continue(state: AgentState) -> str:
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return "end"

graph = StateGraph(AgentState)
graph.add_node("agent", call_llm)
graph.add_node("tools", call_tool)

graph.add_conditional_edges("agent", should_continue, {
    "tools": "tools",
    "end": END
})
graph.add_edge("tools", "agent")  # Cycle !
graph.set_entry_point("agent")

Pattern : Agent ReAct avec LangGraph

from langgraph.prebuilt import create_react_agent

tools = [search_tool, calculator_tool]
agent = create_react_agent(llm, tools)

result = agent.invoke({"messages": [("user", "Quelle est la population de Paris ?")]})

Fonctionnalités avancées

Checkpointing (persistance)

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("checkpoints.db")
app = graph.compile(checkpointer=checkpointer)

# Reprendre une conversation
result = app.invoke(input, config={"configurable": {"thread_id": "123"}})

Human-in-the-loop

from langgraph.prebuilt import ToolNode

# Interrompre avant l'exécution d'un outil
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["tools"]
)

Sous-graphes

Composer des agents en hiérarchie :

sub_agent = create_react_agent(llm, specialized_tools)
main_graph.add_node("researcher", sub_agent)

Quand utiliser LangGraph

Workflows avec des boucles de retry ou de raffinement
Agents qui doivent maintenir un état complexe
Pipelines avec des branchements conditionnels
Systèmes nécessitant une intervention humaine
Multi-agents avec communication

LangGraph : agents avec état et cycles