LangGraph : un cadre pour la construction et l'exécution d'agents d'intelligence artificielle basé sur la topologie des graphes acycliques dirigés

L'intelligence artificielle (IA) est un domaine en pleine expansion. Les modèles de langage ont évolué pour permettre aux agents d'intelligence artificielle d'effectuer des tâches et de prendre des décisions complexes. Cependant, alors que les compétences de ces agents ne cessent de croître, l'infrastructure qui les soutient peine à suivre.

LangGraph, une bibliothèque révolutionnaire conçue pour révolutionner les fonctions de l'agent d'intelligence artificielle. Construction et exécution Mise en œuvre.

LangGraph présente un nouvel agentConstruction et exécutionParadigme constructif, qui considère les flux de travail des agents comme des structures basées sur une topologie de graphe cyclique.

Qu'est-ce que LangGraph ?

Une proposition de valeur importante de LangChain est la possibilité de créer facilement des chaînes personnalisées. Cependant, LangChain ne dispose pas d'un moyen simple d'introduire des boucles dans ces chaînes. En effet, ces chaînes sont des graphes acycliques dirigés (DAG) - Comme la plupart des cadres d'orchestration de données.

Un modèle commun lorsque les gens construisent des applications LLM complexes est d'introduire des boucles dans le temps d'exécution. Ces boucles s'appuient souvent sur le LLM pour raisonner sur l'action suivante dans la boucle. C'est essentiellement l'équivalent de l'exécution du LLM dans une boucle for. de tels systèmes sont souvent appelés agents.

La forme la plus simple est une boucle à deux étapes :

1. Appeler le LLM pour déterminer l'action à entreprendre ou la réponse à donner à l'utilisateur
2. Effectuer l'opération donnée et revenir à l'étape 1.

Ces étapes sont répétées jusqu'à ce que la réponse finale soit générée. Il s'agit de la boucle qui pilote l'AgentExecutor au cœur de LangChain. C'est une boucle très simple, mais c'est aussi la plus critique parce qu'elle met presque tout le pouvoir de décision et de raisonnement entre les mains du LLM.

Il est important de noter que ce processus nécessite généralement plus de contrôle. Par exemple, obliger l'agent à invoquer d'abord un outil spécifique, mieux contrôler la manière dont l'outil est invoqué, différentes invites en fonction de l'état dans lequel se trouve l'agent, etc.

Il s'agit de processus contrôlés, que LangChain appelle "machines à états".

Ces machines à états ont la capacité de former des boucles, mais une intervention humaine est nécessaire pour construire ces boucles.

LangGraph crée ces machines à états en les spécifiant sous forme de graphes.

LangGraph est construit au-dessus de LangChain et est entièrement compatible avec l'écosystème LangChain.interopérabilité. Il apporte une nouvelle valeur ajoutée principalement en introduisant un moyen facile de créer des diagrammes en boucle. Cela est très utile pour créer des temps d'exécution pour les agents.

Cette approche permet aux agents de présenter des comportements plus variables et plus nuancés que les modèles d'exécution linéaires de leurs prédécesseurs. En utilisant la théorie des graphes, LangGraph offre de nouveaux moyens de développer des systèmes d'agents complexes en réseau.

Figure : un LangGraph pour la génération de code

Exemple : système dynamique de questions-réponses

prendre L'utilisateur peut fournir des informations au modèle étape par étape, plutôt que d'envoyer toutes les informations en une seule fois.

prescription : Utiliser un diagramme cyclique :

1. Permettre au mécanisme d'apprentissage tout au long de la vie de générer des réponses initiales.
2. Si la réponse est incomplète ou si des informations supplémentaires sont nécessaires, générez une nouvelle question et continuez à interroger l'utilisateur.
3. jusqu'à ce que l'utilisateur confirme que le problème a été résolu.

Structure du diagramme de cycle

• NœudsChaque nœud représente une tâche ou une opération spécifique, telle que la génération de textes, la réponse à des questions, le traitement de données, etc.
• BordsLes connexions entre les nœuds indiquent l'ordre d'exécution des tâches, éventuellement avec des jugements conditionnels.
• Chemin de bouclageLes boucles sont formées lorsque la sortie d'un nœud doit être renvoyée au nœud précédent ou lorsqu'elle doit être exécutée de manière répétée.
• Condition d'arrêtLes diagrammes en boucle sont soumis à une certaine condition de terminaison, par exemple lorsque la qualité du résultat répond aux exigences, lorsque la limite du nombre de fois fixé est atteinte ou lorsqu'un signal d'arrêt déclenché de l'extérieur est activé.

Pourquoi utiliser LangGraph ?

• dextérité Les agents d'intelligence artificielle évoluent et les développeurs ont besoin de mieux contrôler le temps d'exécution de l'agent afin de mettre en place des plans d'action personnalisés et des procédures de prise de décision.
• La nature circulaire du raisonnement de l'IA LangGraph : De nombreuses applications LLM complexes reposent sur une exécution cyclique lors de l'utilisation de stratégies telles que le raisonnement en chaîne.
• système multi-intelligence Le système de gestion des intelligences multiples : Les flux de travail multi-intelligences devenant de plus en plus courants, le besoin de systèmes capables de gérer et de coordonner efficacement de multiples intelligences autonomes augmente.

Utilisez le code pour voir comment fonctionne LangGraph

La fonctionnalité de LangGraph repose sur quelques éléments de base :

• Nœuds. Il s'agit d'outils pour les fonctions ou les agents.
• Bords. Définir des chemins pour l'exécution et le flux de données dans le système d'agents, en reliant les nœuds.
• StateGraph. LangGraph permet de conserver des données persistantes entre les cycles d'exécution en gérant et en mettant à jour des objets d'état, les données circulant entre les nœuds.

Figure : Flux de travail de base de LangGraph

Graphique d'état

StateGraph est une classe qui représente un graphique. Vous créez un graphe en passant la classe state pour initialiser cette classe. La définition de l'état représente un objet d'état central qui est mis à jour au fil du temps. Cet état est mis à jour par les nœuds du graphe, qui renvoient des opérations sur les attributs de cet état sous la forme de magasins clé-valeur.

import os  # 导入操作系统模块
os.environ['OpenAI_API_KEY'] = 'hk-iwtbi1e427'
from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
class State(TypedDict):
    # messages 的类型为“list”。Annotated中的“add_messages” 定义了如何更新messages
    # 在本例中，messages是追加到list中的，而不是覆盖
    messages: Annotated[list, add_messages]
# 创建StateGraph的实例，传入State类
graph_builder = StateGraph(State)

Nœuds

Créer un StateGraph Ensuite, vous pouvez utiliser la fonction graph.add_node(name, value) Syntaxe pour ajouter des nœuds. name L'argument est une chaîne de caractères qui représente le nom du nœud. value L'argument est une fonction ou un LCEL exécutable qui sera appelé.

Cette fonction /LCEL accepte une fonction qui est la même que State a un dictionnaire de la même forme que l'entrée et produit un dictionnaire qui utilise la méthode State pour mettre à jour le dictionnaire.

from langchain_openai import ChatOpenAI  # 从langchain_openai模块导入ChatOpenAI
llm = ChatOpenAI(  # 创建ChatOpenAI的实例
    model="gpt-4o-mini",  # 指定模型
    temperature=0,  # 设置温度
    base_url="https://api.openai-hk.com/v1"# 设置基础URL
)
def chatbot(state: State):# 定义chatbot函数，接受State类型的参数
    """
    处理聊天机器人请求并返回消息。
    参数:
    state (State): 包含消息的状态。
    返回:
    dict: 机器人生成的消息的字典。
    """
    return {"messages": [llm.invoke(state["messages"])]}  # 返回包含消息的字典
# 第一个参数是节点name
# 第二个参数是被调用的函数或对象
graph_builder.add_node("chatbot", chatbot)  # 向图中添加节点，节点名称为"chatbot"

Bords

Indique que l'un des nœuds est toujours appelé après l'autre

# 添加从START到"chatbot"的边
graph_builder.add_edge(START, "chatbot")  
# 添加从"chatbot"到END的边
graph_builder.add_edge("chatbot", END)  

Compiler Compiler

Après avoir défini notre graphe, nous pouvons le compiler pour qu'il soit exécutable ! Exposer les mêmes méthodes que LangChain ( .invoke (math.) genre .stream (math.) genre .astream_log etc.), ce qui permet de l'appeler de la même manière qu'une chaîne.

graph = graph_builder.compile()  # 编译图

être en mouvement

def stream_graph_updates(user_input: str):  # 定义stream_graph_updates函数，接受用户输入
    """
    使用user_input流式更新图的消息。
    参数:
    user_input (str): 用户输入的消息。
    返回:
    None
    """
    # 遍历图的流事件，传入用户消息以获取模型的响应
    for event in graph.stream({"messages": [("user", user_input)]}):  # 遍历图的流事件
        for value in event.values():  # 遍历事件的值
            print("Assistant:", value["messages"][-1].content)  # 打印助手的最后一条消息
whileTrue:
    try:
        user_input = input("User: ")  # 获取用户输入
        if user_input.lower() in ["quit", "exit", "q"]:  # 检查用户是否想退出
            print("Goodbye!")
            break# 退出循环
        # 调用stream_graph_updates函数处理用户输入
        stream_graph_updates(user_input)
    except:  # 捕获异常
        # fallback if input() is not available
        user_input = "What do you know about LangGraph?"# 设置默认用户输入
        print("User: " + user_input)  # 打印用户输入
        stream_graph_updates(user_input)  # 调用stream_graph_updates函数处理默认输入
        break# 退出循环

Visualisation "diagramme" (facultatif)

Visualiser des "diagrammes" dans l'environnement Jupyter Notebook

effet d'exploitation

Les structures telles que LangGraph deviennent de plus en plus importantes au fur et à mesure que l'IA évolue.

Au fur et à mesure que les développeurs se familiarisent avec les fonctionnalités de LangGraph, on peut s'attendre à voir apparaître des agents d'intelligence artificielle plus avancés, capables d'effectuer des tâches plus complexes.

En résumé, LangGraph représente une avancée significative dans le développement des agents d'intelligence artificielle. Il permet aux développeurs de repousser les limites de ce qui est possible avec les agents d'IA en éliminant les défauts des systèmes précédents et en fournissant un cadre flexible, basé sur les graphes, pour la construction et l'exécution des agents.