Didacticiel LangGraph : Qu'est-ce que LangGraph et comment l'utiliser ?

Imaginez que vous construisiez une application complexe et multi-agents de type "Large Language Model" (LLM). C'est passionnant, mais cela comporte des défis : gérer l'état des différents agents, coordonner leurs interactions et traiter les erreurs de manière efficace. C'est là que LangGraph peut vous aider.

LangGraph est une bibliothèque de l'écosystème LangChain conçue pour relever ces défis. LangGraph fournit un cadre pour la définition, la coordination et l'exécution de plusieurs agents LLM (ou chaînes) de manière structurée.

Il simplifie le processus de développement en permettant la création de graphes cycliques, qui sont essentiels pour le développement d'agents d'exécution. Avec LangGraph, nous pouvons facilement construire des systèmes multi-agents robustes, évolutifs et flexibles.

Si vous souhaitez en savoir plus sur l'écosystème LangChain, je vous recommande cette introduction à LangChain.

Qu'est-ce que LangGraph ?

LangGraph nous permet de créer des applications multi-acteurs avec état en utilisant des LLM aussi facilement que possible. Il étend les capacités de LangChain, en introduisant la possibilité de créer et de gérer des graphes cycliques, qui sont essentiels pour développer des agents sophistiqués. Les concepts fondamentaux de LangGraph comprennent : la structure du graphe, la gestion des états et la coordination.

Structure du graphique

Imaginez votre application sous la forme d'un graphe orienté. Dans LangGraph, chaque nœud représente un agent LLM et les arêtes sont les canaux de communication entre ces agents. Cette structure permet des flux de travail clairs et gérables, où chaque agent effectue des tâches spécifiques et transmet des informations à d'autres agents en fonction des besoins.

Gestion de l'État

L'une des principales caractéristiques de LangGraph est sa gestion automatique des états. Ce cursus nous permet de suivre et de persister les informations à travers de multiples interactions. Au fur et à mesure que les agents exécutent leurs tâches, l'état est mis à jour de manière dynamique, ce qui permet au système de conserver son contexte et de réagir de manière appropriée aux nouvelles données.

Coordination

LangGraph garantit que les agents s'exécutent dans le bon ordre et que les informations nécessaires sont échangées de manière transparente. Cette coordination est vitale pour les applications complexes dans lesquelles plusieurs agents doivent travailler ensemble pour atteindre un objectif commun. En gérant le flux de données et la séquence des opérations, LangGraph permet aux développeurs de se concentrer sur la logique de haut niveau de leurs applications plutôt que sur les subtilités de la coordination des agents.

Pourquoi LangGraph ?

Comme je l'ai mentionné plus haut, LangGraph offre plusieurs avantages significatifs aux développeurs travaillant sur des applications LLM complexes. Voici quelques-uns des avantages concrets qu'offre LangGraph.

Développement simplifié

LangGraph fait abstraction des complexités liées à la gestion des états et à la coordination des agents. Cela signifie que les développeurs peuvent définir leurs flux de travail et leur logique sans se soucier des mécanismes sous-jacents qui garantissent la cohérence des données et l'ordre d'exécution approprié. Cette simplification accélère le processus de développement et réduit la probabilité d'erreurs. Cela change la donne !

Flexibilité

Avec LangGraph, les développeurs ont la possibilité de définir leur propre logique d'agent et leurs propres protocoles de communication. Cela permet de créer des applications hautement personnalisées, adaptées à des cas d'utilisation spécifiques. Que vous ayez besoin d'un chatbot capable de traiter différents types de demandes d'utilisateurs ou d'un système multi-agents capable d'effectuer des tâches complexes, LangGraph vous fournit les outils nécessaires pour construire exactement ce dont vous avez besoin. Il s'agit de vous donner le pouvoir de créer.

Évolutivité

LangGraph est conçu pour faciliter l'exécution d'applications multi-agents à grande échelle. Son architecture robuste peut gérer un volume élevé d'interactions et de flux de travail complexes, ce qui permet de développer des systèmes évolutifs qui peuvent s'adapter à vos besoins. Il convient donc aux applications d'entreprise et aux scénarios dans lesquels les performances et la fiabilité sont essentielles.

Tolérance aux fautes

La fiabilité est un élément essentiel de la conception de LangGraph. La bibliothèque comprend des mécanismes permettant de gérer les erreurs de manière gracieuse, ce qui garantit que votre application peut continuer à fonctionner même lorsque des agents individuels rencontrent des problèmes. Cette tolérance aux pannes est essentielle pour maintenir la stabilité et la robustesse des systèmes multi-agents complexes. La tranquillité d'esprit est à portée de main.

Démarrer avec LangGraph

Voyons comment nous pouvons configurer LangGraph et quels sont les concepts de base.

Installation

Pour installer LangGraph, vous pouvez utiliser pip:

pip install -U langgraph

Concepts de base

Nœuds : Les nœuds représentent des unités de travail au sein de votre LangGraph. Il s'agit généralement de fonctions Python qui effectuent une tâche spécifique, comme par exemple :

• Interagir avec un LLM
• Appeler un outil ou une API
• Effectuer quelques manipulations de données
• Réception des données de l'utilisateur
• Exécution de la logique d'entreprise

Dans LangGraph, vous pouvez ajouter des nœuds en utilisant la syntaxe graph.add_node(name, value).

Les bords : Les arêtes sont des canaux de communication entre les nœuds. Ils définissent le flux d'informations et l'ordre d'exécution. Vous pouvez ajouter des arêtes à l'aide de la syntaxe graph.add_edge(node1, node2).

État : L'état est un objet central mis à jour au fil du temps par les nœuds du graphe. Il gère l'état interne de votre application et peut être remplacé ou complété en fonction des besoins de l'application. Cet état peut contenir des éléments tels que

• Historique de la conversation : Une liste de messages entre l'agent et l'utilisateur.
• Données contextuelles : Informations relatives à la tâche ou à l'interaction en cours.
• Variables internes : Des cursus, des compteurs ou d'autres variables permettant de suivre les progrès et le comportement de l'agent.

Construire une application LangGraph simple

Voici un exemple étape par étape de la création d'une application de chatbot de base à l'aide de LangGraph.

Étape 1 : Définir le graphe des états

Définissez un objet StateGraph pour structurer le chatbot comme une machine à états. Le State est un objet de classe défini avec une seule clé messages de type List et utilise la fonction add_messages() pour ajouter de nouveaux messages plutôt que de les écraser.

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class State(TypedDict):
    # messages have the type "list".
    # The add_messages function appends messages to the list, rather than overwriting them
    messages: Annotated[list, add_messages]
graph_builder = StateGraph(State)

Étape 2 : Initialiser un LLM et l'ajouter en tant que nœud de Chatbot

Ici, nous initialisons le modèle AzureChatOpenAI et créons une simple fonction de chatbot qui prend les messages d'état en entrée et génère un message de réponse (qui est ensuite ajouté à l'état).

Cette fonction de chatbot est ajoutée au graphe sous la forme d'un nœud nommé "chatbot".

from langchain_openai import AzureChatOpenAI
llm = AzureChatOpenAI(
    openai_api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    azure_deployment=os.environ["AZURE_OPENAI_CHAT_DEPLOYMENT_NAME"],
)
def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}
‘’’The first argument is the unique node name
# The second argument is the function or object that will be called whenever the node is used.’’’
graph_builder.add_node("chatbot", chatbot)

Étape 3 : Définir les arêtes

Étant donné que nous construisons un simple chatbot, nous définissons le nœud chatbot comme point d'entrée et point de sortie du graphe pour indiquer où commencer et où terminer le processus.

# Set entry and finish points
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")

Étape 4 : Compilation et visualisation du graphique

Compilez le graphe pour créer un CompiledGraph et, éventuellement, nous pouvons visualiser la structure du graphe à l'aide du code ci-dessous :

graph = graph_builder.compile()
from IPython.display import Image, display
try:
    display(Image(graph.get_graph().draw_mermaid_png()))
except Exception:
    pass

Étape 5 : Lancer le chatbot

Enfin, nous mettons en œuvre une boucle qui invite continuellement l'utilisateur à saisir des données, les traite dans le graphique et imprime la réponse de l'assistant. La boucle se termine lorsque l'utilisateur tape "quit", "exit", ou "q".

# Run the chatbot
while True:
    user_input = input("User: ")
    if user_input.lower() in ["quit", "exit", "q"]:
        print("Goodbye!")
        break
    for event in graph.stream({"messages": [("user", user_input)]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

Fonctionnalités avancées de LangGraph

Maintenant que nous avons abordé les principes de base, examinons quelques fonctions avancées.

Types de nœuds personnalisés

LangGraph vous permet de créer des types de nœuds personnalisés pour mettre en œuvre une logique d'agent complexe. Cela permet d'assurer la flexibilité et le contrôle du comportement de votre application.

from typing import Annotated
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class MyCustomNode:
    def __init__(self, llm):
        self.llm = llm
    def __call__(self, state):
        # Implement your custom logic here
        # Access the state and perform actions
        messages = state["messages"]
        response = self.llm.invoke(messages)
        return {"messages": [response]}
graph_builder = StateGraph(State)
llm = ChatAnthropic(model="claude-3-haiku-20240307")
custom_node = MyCustomNode(llm)
graph_builder.add_node("custom_node", custom_node)

Nous définissons ici une classe MyCustomNode qui encapsule la logique personnalisée et interagit avec le LLM. Il s'agit d'un moyen plus structuré et plus facile à maintenir pour mettre en œuvre des comportements de nœuds complexes.

Types d'arêtes

LangGraph prend en charge différents types d'arêtes pour gérer les différents modèles de communication entre les nœuds. Un type utile est le bord conditionnel, qui permet de prendre des décisions en fonction des résultats d'un nœud.

Pour créer un bord conditionnel, vous avez besoin de trois éléments :

1. Le nœud en amont : La sortie du nœud détermine l'étape suivante.
2. Une fonction : Cette fonction évalue la sortie du nœud en amont et détermine le nœud suivant à exécuter, en renvoyant une chaîne de caractères représentant la décision.
3. Une cartographie : Ce mappage relie les résultats possibles de la fonction aux nœuds correspondants à exécuter.

Voici un exemple en pseudo-code :

graph.add_conditional_edge(
    "model",
    should_continue,
    {
        "end": END,
        "continue": "tools"
    }
)

Ici, après l'appel du nœud "modèle", nous pouvons soit quitter le graphe ("end") et retourner à l'utilisateur, soit continuer ("continue") et appeler un outil - en fonction de ce que l'utilisateur décide !

Gestion de l'État

LangGraph propose de puissantes techniques de gestion des états, qui incluent l'utilisation de bases de données externes comme SQLite, PostgreSQL et MongoDB, ou de solutions de stockage dans le cloud comme Amazon S3, Google Cloud Storage et Azure Blob Storage pour stocker et récupérer l'état de votre agent, ce qui favorise la fiabilité et l'évolutivité.

Voici un exemple d'utilisation d'une base de données SQLite pour la gestion des états :

from langgraph.checkpoint.sqlite import SqliteSaver
# Connect to the SQLite database
memory = SqliteSaver.from_conn_string(":memory:")
# Compile the graph with the checkpointer
graph = graph_builder.compile(checkpointer=memory)

Gestion des erreurs

LangGraph fournit également des mécanismes de gestion des erreurs :

• Exceptions : Les fonctions des nœuds peuvent soulever des exceptions pour signaler des erreurs au cours de l'exécution. Vous pouvez attraper et gérer ces exceptions afin d'éviter que votre graphique ne s'arrête.
• Mécanismes de réessai : Vous pouvez mettre en œuvre une logique de réessai dans vos nœuds pour gérer les erreurs transitoires, telles que les problèmes de réseau ou les dépassements de délai de l'API.
• Enregistrement : Utilisez la journalisation pour enregistrer les erreurs et suivre l'exécution de votre graphique.

Applications concrètes de LangGraph

LangGraph peut être utilisé pour créer un large éventail d'applications.

Chatbots

LangGraph est idéal pour développer des chatbots sophistiqués capables de traiter un large éventail de demandes d'utilisateurs. En s'appuyant sur plusieurs agents LLM, ces chatbots peuvent traiter des requêtes en langage naturel, fournir des réponses précises et passer de manière transparente d'un sujet de conversation à l'autre. La capacité à gérer l'état et à coordonner les interactions garantit que le chatbot conserve le contexte et offre une expérience cohérente à l'utilisateur.

Agents autonomes

Pour les applications nécessitant une prise de décision autonome, LangGraph permet de créer des agents capables d'exécuter des tâches de manière indépendante sur la base d'entrées utilisateur et d'une logique prédéfinie.

Ces agents peuvent exécuter des flux de travail complexes, interagir avec d'autres systèmes et s'adapter dynamiquement à de nouvelles informations. Le cadre structuré de LangGraph garantit que chaque agent fonctionne de manière efficace, ce qui le rend adapté à des tâches telles que l'assistance automatisée à la clientèle, le traitement des données et la surveillance des systèmes.

Systèmes multi-agents

LangGraph excelle dans la construction d'applications où plusieurs agents collaborent pour atteindre un objectif commun. Par exemple, différents agents peuvent gérer les stocks, traiter les commandes et coordonner les livraisons dans un système de gestion de la chaîne d'approvisionnement. Les capacités de coordination de LangGraph garantissent que chaque agent communique efficacement, partage l'information et prend des décisions de manière synchronisée. Cela permet d'améliorer l'efficacité des opérations et les performances globales du système.

Outils d'automatisation des flux de travail

Avec LangGraph, l'automatisation des processus métier et des flux de travail devient simple. Les agents intelligents peuvent être conçus pour gérer des tâches telles que le traitement de documents, les flux de travail d'approbation et l'analyse de données. En définissant des flux de travail clairs et en exploitant la gestion des états de LangGraph, ces outils peuvent exécuter des séquences d'actions complexes sans intervention humaine, réduisant ainsi les erreurs et augmentant la productivité.

Systèmes de recommandation

Les systèmes de recommandation personnalisés peuvent grandement bénéficier des capacités de LangGraph. En employant plusieurs agents pour analyser le comportement de l'utilisateur, ses préférences et les données contextuelles, ces systèmes peuvent fournir des suggestions personnalisées de produits, de contenus ou de services. La flexibilité de LangGraph permet d'intégrer diverses sources de données et algorithmes, améliorant ainsi la précision et la pertinence des recommandations.

Environnements d'apprentissage personnalisés

Dans les plateformes éducatives, LangGraph peut être utilisé pour créer des environnements d'apprentissage adaptatifs qui répondent aux styles et aux besoins d'apprentissage individuels. Plusieurs agents peuvent évaluer les progrès d'un élève, proposer des exercices personnalisés et offrir un retour d'information en temps réel. La nature évolutive de LangGraph garantit que le système conserve des informations sur les performances et les préférences de chaque apprenant, ce qui permet une expérience éducative plus personnalisée et plus efficace.

Conclusion

LangGraph simplifie considérablement le développement d'applications LLM complexes en fournissant un cadre structuré pour la gestion de l'état et la coordination des interactions entre agents.

Les développements potentiels de LangGraph comprennent l'intégration avec d'autres composants de LangChain, la prise en charge de nouveaux modèles LLM et l'introduction de moteurs d'exécution d'agents plus avancés provenant du monde universitaire.

Si vous souhaitez en savoir plus sur le développement d'applications au sein de l'écosystème LangChain, je vous recommande ce cours sur développer des applications LLM avec LangChain.