Tutoriel Langgraph: Qu'est-ce que Langgraph et comment l'utiliser?

Imaginez que vous construisez une application complexe et multi-agents de grande langue (LLM). C'est excitant, mais cela vient avec des défis: gérer l'état de divers agents, coordonner leurs interactions et gérer efficacement les erreurs. C'est là que Langgraph peut aider.

Langgraph est une bibliothèque de l'écosystème de Langchain conçu pour relever ces défis de front. Langgraph fournit un cadre pour définir, coordonner et exécuter plusieurs agents (ou chaînes) LLM de manière structurée.

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

Si vous voulez en savoir plus sur l'écosystème de Langchain, je recommande cette introduction à Langchain.

Qu'est-ce que Langgraph?

Langgraph nous permet de créer des applications multi-acteurs avec état d'utilisation du LLMS aussi facilement que possible. Il étend les capacités de Langchain, introduisant la capacité de créer et de gérer des graphiques cycliques, qui sont essentiels pour développer des temps d'exécution des agents sophistiqués. Les concepts principaux de Langgraph comprennent: la structure du graphique, la gestion de l'État et la coordination.

Structure du graphique

Imaginez votre application comme un graphique dirigé. Dans Langgraph, chaque nœud représente un agent LLM et les bords 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 au besoin.

Gestion de l'État

L'une des fonctionnalités exceptionnelles de Langgraph est sa gestion automatique de l'état. Cette fonctionnalité nous permet de suivre et de persister des informations sur plusieurs interactions. Alors que les agents effectuent leurs tâches, l'État est mis à jour dynamiquement, garantissant que le système maintient le contexte et répond de manière appropriée aux nouvelles entré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 où plusieurs agents doivent travailler ensemble pour atteindre un objectif commun. En gérant le flux de données et la séquence d'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é ci-dessus, Langgraph offre plusieurs avantages significatifs pour les développeurs travaillant avec des applications LLM complexes. Voici quelques-uns des avantages réels offres de Langgraph.

Développement simplifié

Langgraph résume les complexités associées à la gestion de l'État 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. C'est un changeur de jeu!

flexibilité

Avec Langgraph, les développeurs ont la flexibilité de définir leur propre protocole de logique et de communication d'agent. Cela permet des applications hautement personnalisées adaptées à des cas d'utilisation spécifiques. Que vous ayez besoin d'un chatbot qui peut gérer divers types de demandes utilisateur ou un système multi-agents qui effectue des tâches complexes, Langgraph fournit les outils pour créer exactement ce dont vous avez besoin. Il s'agit de vous donner le pouvoir de créer.

Évolutivité

Langgraph est conçu pour prendre en charge l'exécution d'applications multi-agents à grande échelle. Son architecture robuste peut gérer un volume élevé d'interactions et des workflows complexes, permettant le développement de systèmes évolutifs qui peuvent croître avec vos besoins. Cela le rend adapté aux applications et scénarios au niveau de l'entreprise où les performances et la fiabilité sont essentielles.

Tolérance aux défauts

La fiabilité est une considération de base dans la conception de Langgraph. La bibliothèque comprend des mécanismes pour gérer gracieusement les erreurs, garantissant que votre application peut continuer à fonctionner même lorsque des agents individuels rencontrent des problèmes. Cette tolérance aux défauts est essentielle pour maintenir la stabilité et la robustesse des systèmes multi-agents complexes. La tranquillité d'esprit n'est qu'une fonctionnalité.

Pour commencer 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 dans votre langue. Ce sont généralement des fonctions Python qui effectuent une tâche spécifique, telle que:

• interagir avec un LLM
• appelant un outil ou une API
• effectuer certaines manipulations de données
• réception de l'entrée utilisateur
• Exécution de la logique métier

Dans LangGraph, vous pouvez ajouter des nœuds à l'aide de la syntaxe graphique.add_node (nom, valeur).

Bêtes: les bords 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 bords à l'aide de la syntaxe graphique.add_edge (node1, node2).

État: l'état est un objet central mis à jour dans le temps par les nœuds du graphique. Il gère l'état interne de votre demande et peut être remplacé ou ajouté, selon les exigences de la demande. Cet état peut contenir des choses telles que:

• Historique de la conversation: une liste de messages entre l'agent et l'utilisateur.
• Données contextuelles: informations pertinentes pour la tâche ou l'interaction actuelle.
• Variables internes: drapeaux, comptoirs ou autres variables pour 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éfinissez le Stategraph

Définissez un objet StateGraph pour structurer le chatbot en tant que machine d'état. L'état est un objet de classe défini avec un seul messages clés de la liste de types et utilise la fonction add_messages () pour ajouter de nouveaux messages plutôt que de les écraser.

pip install -U langgraph

Étape 2: Initialisez un LLM et ajoutez-le comme un nœud de chatbot

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

Cette fonction de chatbot est ajoutée comme un nœud nommé "chatbot" au graphique.

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 3: Définir les bords

Puisque nous construisons un chatbot simple, nous définissons le nœud de chatbot comme point d'entrée et final du graphique pour indiquer où démarrer et mettre fin au processus.

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 4: compiler et visualiser le graphique

Compiler le graphique pour créer un objet compilé, et éventuellement, nous pouvons visualiser la structure du graphique à l'aide du code ci-dessous:

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

Étape 5: Exécutez le chatbot

Enfin, nous implémentons une boucle pour inviter en continu l'utilisateur pour l'entrée, le traiter via le graphique et imprimer la réponse de l'assistant. La boucle sort lorsque l'utilisateur tape "quit", "quitter" ou "q".

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

Caractéristiques de Langgraph avancé

Maintenant que nous avons couvert les bases, jetons un coup d'œil à certaines fonctionnalités avancées.

Types de nœuds personnalisés

Langgraph vous permet de créer des types de nœuds personnalisés pour implémenter la logique d'agent complexe. Cela offre une flexibilité et un contrôle sur le comportement de votre application.

# 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)

Ici, nous définissons une classe MyCustomNode qui résume la logique personnalisée et interagit avec le LLM. Cela fournit une manière plus structurée et maintenable de mettre en œuvre des comportements de nœuds complexes.

Types de bord

Langgraph prend en charge différents types de bords pour gérer divers modèles de communication entre les nœuds. Un type utile est le bord conditionnel, qui permet la prise de décision en fonction de la sortie d'un nœud.

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

1. Le nœud en amont: la sortie du nœud décide de 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, renvoyant une chaîne qui représente la décision.
3. un mappage: ce mappage relie les résultats possibles de la fonction aux nœuds correspondants à exécuter.

Voici un exemple de pseudocode:

pip install -U langgraph

Ici, une fois le nœud "modèle" appelé, nous pouvons soit quitter le graphique ("fin") et revenir à l'utilisateur, soit continuer ("continuer") et appeler un outil - détendre 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 des solutions de stockage cloud comme Amazon S3, Google Cloud Storage et Azure Blob Storage pour stocker et récupérer l'état de votre agent, permettre la fiabilité et l'évolutivité.

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

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)

Gestion des erreurs

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

• Exceptions: les fonctions de nœud peuvent augmenter les exceptions aux erreurs de signal pendant l'exécution. Vous pouvez attraper et gérer ces exceptions pour empêcher votre graphique de s'écraser.
• Mécanismes de réessayer: vous pouvez implémenter la logique de réessayer dans vos nœuds pour gérer les erreurs transitoires, telles que les problèmes de réseau ou les délais d'api.
• Logging: utilisez la journalisation pour enregistrer les erreurs et suivre l'exécution de votre graphique.

Applications du monde réel de Langgraph

Langgraph peut être utilisé pour construire un large éventail d'applications.

chatbots

Langgraph est idéal pour développer des chatbots sophistiqués qui peuvent gérer un large éventail de demandes utilisateur. En tirant parti de plusieurs agents LLM, ces chatbots peuvent traiter les requêtes en langage naturel, fournir des réponses précises et basculer de manière transparente entre différents sujets de conversation. La capacité de gérer les interactions étatiques et coordonnées garantit que le chatbot maintient le contexte et offre une expérience utilisateur cohérente.

Agents autonomes

Pour les applications nécessitant une prise de décision autonome, Langgraph permet la création d'agents qui peuvent effectuer des tâches indépendamment en fonction des entrées utilisateur et de la logique prédéfinie.

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

Systèmes multi-agents

Langgraph excelle dans la création d'applications où plusieurs agents collaborent pour atteindre un objectif commun. Par exemple, différents agents peuvent gérer l'inventaire, 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, partageant des informations et prenant des décisions de manière synchronisée. Cela conduit à des opérations plus efficaces et à une meilleure performance globale du système.

Outils d'automatisation du flux de travail

avec Langgraph, l'automatisation des processus commerciaux et des workflows devient simple. Les agents intelligents peuvent être conçus pour gérer les tâches telles que le traitement des documents, les workflows d'approbation et l'analyse des données. En définissant des flux de travail clairs et en tirant parti de la gestion de l'État de Langgraph, ces outils peuvent exécuter des séquences complexes d'actions sans intervention humaine, en réduisant les erreurs et en 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 utilisant plusieurs agents pour analyser le comportement des utilisateurs, les préférences et les données contextuelles, ces systèmes peuvent fournir des suggestions sur mesure pour les produits, le contenu ou les services. La flexibilité de Langgraph permet d'intégrer diverses sources de données et algorithmes, améliorant 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 besoins d'apprentissage individuels. Plusieurs agents peuvent évaluer les progrès d'un étudiant, fournir des exercices personnalisés et offrir des commentaires en temps réel. La nature avec état de Langgraph garantit que le système conserve des informations sur les performances et les préférences de chaque apprenant, permettant une expérience éducative plus personnalisée et efficace.

Conclusion

Langgraph simplifie de manière significative le développement d'applications LLM complexes en fournissant un cadre structuré pour gérer les interactions d'état et de coordination des agents.

Les développements potentiels de Langgraph incluent l'intégration avec d'autres composants de Langchain, le support pour les nouveaux modèles LLM et l'introduction d'agents plus avancés des temps universitaires.

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!