Les composants de base de LangGraph

Pour créer des applications avec LangGraph, vous devez comprendre ses composants principaux. Explorons les blocs fondamentaux qui constituent une application LangGraph.

Une application dans LangGraph commence à partir d’un point d’entrée, et selon l’exécution, le flux peut aller vers une fonction ou une autre jusqu’à ce qu’il atteigne la FIN.

1. État

L’état est le concept central dans LangGraph. Il représente toutes les informations qui circulent à travers votre application.

from typing_extensions import TypedDict

class State(TypedDict):
    graph_state: str

L’état est défini par l’utilisateur, donc les champs doivent être soigneusement conçus pour contenir toutes les données nécessaires au processus de prise de décision !

💡 Astuce : Réfléchissez soigneusement aux informations que votre application doit suivre entre les étapes.

2. Nœuds

Les nœuds sont des fonctions Python. Chaque nœud :

• Prend l’état en entrée
• Effectue une opération
• Retourne des mises à jour de l’état

def node_1(state):
    print("---Node 1---")
    return {"graph_state": state['graph_state'] +" I am"}

def node_2(state):
    print("---Node 2---")
    return {"graph_state": state['graph_state'] +" happy!"}

def node_3(state):
    print("---Node 3---")
    return {"graph_state": state['graph_state'] +" sad!"}

Par exemple, les nœuds peuvent contenir :

• Appels de LLM : Générer du texte ou prendre des décisions
• Appels d’outils : Interagir avec des systèmes externes
• Logique conditionnelle : Déterminer les prochaines étapes
• Intervention humaine : Obtenir des contributions des utilisateurs

💡 Info : Certains nœuds nécessaires pour l’ensemble du workflow comme START et END existent directement dans LangGraph.

3. Arêtes

Les arêtes connectent les nœuds et définissent les chemins possibles à travers votre graphe :

import random
from typing import Literal

def decide_mood(state) -> Literal["node_2", "node_3"]:
    
    # Souvent, nous utiliserons l'état pour décider du prochain nœud à visiter
    user_input = state['graph_state'] 
    
    # Ici, faisons juste une répartition 50/50 entre les nœuds 2, 3
    if random.random() < 0.5:

        # 50% du temps, nous retournons Node 2
        return "node_2"
    
    # 50% du temps, nous retournons Node 3
    return "node_3"

Les arêtes peuvent être :

• Directes : Toujours aller du nœud A au nœud B
• Conditionnelles : Choisir le prochain nœud basé sur l’état actuel

4. StateGraph

Le StateGraph est le conteneur qui détient l’ensemble du workflow de votre agent :

from IPython.display import Image, display
from langgraph.graph import StateGraph, START, END

# Construire le graphe
builder = StateGraph(State)
builder.add_node("node_1", node_1)
builder.add_node("node_2", node_2)
builder.add_node("node_3", node_3)

# Logique
builder.add_edge(START, "node_1")
builder.add_conditional_edges("node_1", decide_mood)
builder.add_edge("node_2", END)
builder.add_edge("node_3", END)

# Ajouter
graph = builder.compile()

Qui peut ensuite être visualisé !

# Visualiser
display(Image(graph.get_graph().draw_mermaid_png()))

Mais plus important encore, l’invocation :

graph.invoke({"graph_state" : "Hi, this is Lance."})

ressort :

---Node 1---
---Node 3---
{'graph_state': 'Hi, this is Lance. I am sad!'}

Et maintenant ?

Dans la prochaine section, nous mettrons ces concepts en pratique en construisant notre premier graphe. Ce graphe permet à Alfred de prendre vos emails, les classifier, et rédiger une réponse préliminaire s’ils sont authentiques.