LangChain ou LangGraph : les officiels vous disent quoi choisir

Le domaine de l'IA générative évolue actuellement rapidement, avec l'apparition de nouveaux cadres et de nouvelles technologies. Par conséquent, les lecteurs doivent être conscients que le contenu présenté dans cet article peut être actuel. Dans cet article, nous allons examiner de plus près les deux cadres dominants pour la construction d'applications LLM, LangChain et LangGraph, et analyser leurs forces et leurs faiblesses pour vous aider à choisir l'outil le plus approprié.

Composants de la fondation LangChain et LangGraph

La compréhension des éléments fondamentaux des deux frameworks peut aider les développeurs à mieux comprendre les différences essentielles dans la manière dont ils gèrent les fonctionnalités de base. Les descriptions suivantes n'énumèrent pas tous les composants de chaque cadre, mais visent à fournir une compréhension claire de leur conception globale.

LangChain

LangChain peut être utilisé de deux manières principales : en tant que chaîne séquentielle de commandes prédéfinies (chaîne) et en tant qu'agent LangChain, qui diffère en termes d'outils et d'organisation. La chaîne utilise un flux de travail linéaire prédéfini, tandis que l'agent agit comme un coordinateur et peut prendre des décisions plus dynamiques (non linéaires).

• ChaîneChaînes : combinaison d'étapes pouvant inclure des appels à des LLM, des agents, des outils, des sources de données externes et du code procédural. Les chaînes peuvent diviser un processus unique en plusieurs chemins sur la base d'un branchement conditionnel logique.
• Agent ou LLML'agent combine le LLM avec des capacités supplémentaires qui lui permettent de raisonner, d'invoquer l'outil et d'essayer d'invoquer l'outil en cas d'échec.
• Outilsont des fonctions de code qui peuvent être appelées dans une chaîne ou déclenchées par un agent pour interagir avec un système externe.
• PromptLes tâches de l'utilisateur : elles comprennent des invites du système (pour indiquer comment le modèle doit accomplir la tâche et les outils disponibles), des informations injectées à partir de sources de données externes (pour fournir plus de contexte au modèle) et des tâches d'entrée de l'utilisateur.

LangGraph

LangGraph adopte une approche différente de la création de flux de travail d'IA. Comme son nom l'indique, il orchestre les flux de travail sous la forme d'un graphe. En raison de sa capacité à s'adapter aux agents d'IA, au code procédural et à d'autres outils, il est mieux adapté aux scénarios d'application complexes pour lesquels les chaînes linéaires, les chaînes de dérivation ou les systèmes d'agents simples ne sont pas suffisants.

• GraphiqueLangGraph prend également en charge les graphes cycliques, qui créent des boucles et des mécanismes de rétroaction permettant d'accéder plusieurs fois à certains nœuds.
• Nœud: Indique une étape dans un flux de travail, tel qu'une requête LLM, un appel API ou l'exécution d'un outil.
• Bord et bord conditionnelArêtes : Les arêtes sont utilisées pour relier les nœuds et définir le flux d'informations de sorte que la sortie d'un nœud soit utilisée comme entrée dans le nœud suivant. Les arêtes conditionnelles permettent à l'information de circuler d'un nœud à l'autre lorsque des conditions spécifiques sont remplies. Le développeur peut personnaliser ces conditions.
• ÉtatL'état est une variable définie par le développeur, un objet TypedDict qui contient toutes les informations nécessaires à l'exécution actuelle du graphe. L'état est une variable définie par le développeur, un objet TypedDict qui contient toutes les informations pertinentes nécessaires à l'exécution actuelle du graphe.LangGraph met automatiquement à jour l'état à chaque noeud.
• Agent ou LLMLe LLM dans le graphe est uniquement responsable de la génération de réponses textuelles aux entrées. L'agent peut décider des chemins à emprunter dans le graphe, mettre à jour l'état du graphe et effectuer d'autres tâches que la simple génération de texte.

En résumé, LangChain est mieux adapté aux invocations linéaires et basées sur des outils, tandis que LangGraph est mieux adapté aux flux de travail complexes, à chemins multiples et à l'IA avec des mécanismes de retour d'information.

Différences entre LangChain et LangGraph dans la manière dont les fonctionnalités de base sont gérées

LangGraph et LangChain se recoupent dans certaines de leurs capacités, mais ils abordent le problème différemment ; LangChain se concentre sur les flux de travail linéaires (via des chaînes) ou sur différents modèles d'agents d'intelligence artificielle, tandis que LangGraph se concentre sur la création de flux de travail plus flexibles, à grain fin, basés sur des processus, qui peuvent incorporer des agents d'intelligence artificielle, des appels d'outils, du code procédural, etc.

En général, LangChain a une courbe d'apprentissage relativement faible parce qu'il offre plus d'abstraction et de configurations prédéfinies, ce qui le rend plus facile à appliquer à des scénarios d'utilisation simples. LangGraph, en revanche, permet une personnalisation plus fine de la conception du flux de travail, ce qui signifie qu'il est moins abstrait et que les développeurs doivent apprendre davantage pour l'utiliser efficacement.

Appel d'outils

LangChain

Dans LangChain, la manière dont un outil est invoqué dépend de l'exécution séquentielle d'une série d'étapes dans la chaîne ou de l'utilisation des seules capacités de l'agent (non définies explicitement dans la chaîne).

• Les outils sont inclus en tant qu'étapes prédéfinies dans la chaîne, ce qui signifie qu'ils ne sont pas nécessairement invoqués de manière dynamique par l'agent, mais qu'il est plutôt décidé quels outils sont invoqués au moment de la conception de la chaîne.
• Lorsque l'agent n'est pas défini dans une chaîne, il dispose d'une plus grande autonomie et peut décider quel outil appeler et à quel moment, sur la base de la liste des outils auxquels il a accès.

Exemple de processus pour l'approche en chaîne :

Voici un exemple du déroulement de la méthode Agent :

LangGraph

Dans LangGraph, un outil est généralement représenté par un nœud sur le graphe. Si le graphe contient un agent, celui-ci est chargé de décider quel outil invoquer, sur la base de sa capacité de raisonnement. Lorsque l'agent sélectionne un outil, le flux de travail passe au nœud d'outil correspondant pour effectuer l'opération de l'outil. Le lien entre l'agent et le nœud d'outil peut contenir une logique conditionnelle, qui ajoute une logique de jugement supplémentaire pour décider de l'exécution ou non d'un outil. De cette manière, le développeur peut avoir un contrôle plus fin. S'il n'y a pas d'agent dans le graphe, l'outil est invoqué d'une manière similaire à une chaîne LangChain, c'est-à-dire que l'outil est exécuté dans le flux de travail sur la base d'une logique conditionnelle prédéfinie.

Contient un exemple de flux de diagrammes pour l'agent :

Exemple de flux d'un diagramme sans agent :

Dialogue sur l'histoire et la mémoire

LangChain

LangChain fournit une couche d'abstraction intégrée pour gérer l'historique et les mémoires des conversations. Il prend en charge la gestion de la mémoire à différents niveaux de granularité, ce qui permet de contrôler la quantité d'informations contenues dans la mémoire. jeton La quantité d'eau est variable, principalement de la manière suivante :

• Historique des conversations de la session complète (Historique des conversations de la session complète)
• Version résumée de l'historique de la conversation
• Mémoire personnalisée (CDM)

En outre, les développeurs peuvent personnaliser le système de mémoire à long terme afin de stocker l'historique des dialogues dans une base de données externe et de retrouver les souvenirs pertinents en cas de besoin.

LangGraph

Dans LangGraph, l'état est responsable de la gestion de la mémoire, qui conserve les informations relatives à l'état en enregistrant les variables définies à chaque instant :

• Dialogue avec l'histoire
• Étapes de la mise en œuvre du mandat
• La dernière sortie du modèle linguistique
• Autres informations importantes

L'état peut être transmis entre les nœuds de façon à ce que chaque nœud ait accès à l'état actuel du système. Cependant, LangGraph lui-même ne fournit pas de mémoire à long terme entre les sessions. Si les développeurs ont besoin de stocker la mémoire de manière persistante, ils peuvent introduire des nœuds spécifiques pour stocker les mémoires et les variables dans une base de données externe afin de pouvoir les récupérer ultérieurement.

Capacité RAG prête à l'emploi

LangChain

LangChain prend en charge de manière native les RAG et fournit un ensemble d'outils sophistiqués pour faciliter l'intégration de RAG dans les applications des développeurs. Par exemple, il fournit

• Chargement des documents
• Analyse de texte
• Intégration de la création
• Stockage vectoriel
• Capacités de récupération (Capacités de récupération)

Les développeurs peuvent utiliser directement les API fournies par LangChain (telles que l'API langchain.document_loaders,langchain.embeddings répondre en chantant langchain.vectorstores) pour mettre en œuvre les flux de travail du RAG.

LangGraph

Dans LangGraph, les RAG doivent être conçus par le développeur et mis en œuvre dans le cadre de la structure du graphe. Par exemple, les développeurs peuvent créer des nœuds distincts pour chaque :

• Analyse des documents
• Calcul d'intégration (Calcul d'intégration)
• Recherche sémantique (extraction)

Ces nœuds peuvent être reliés entre eux par des arêtes normales ou des arêtes conditionnelles, et l'état des nœuds individuels peut être utilisé pour transmettre des informations afin de partager des données entre les différentes étapes du pipeline RAG.

Parallélisme

LangChain

LangChain permet l'exécution en parallèle de plusieurs chaînes ou agents, qui peuvent être exécutés à l'aide de la fonction RunnableParallel pour mettre en œuvre un traitement parallèle de base.

Toutefois, si des calculs parallèles plus avancés ou des appels d'outils asynchrones sont nécessaires, les développeurs devront utiliser des bibliothèques Python telles que asyncio) L'auto-application.

LangGraph

LangGraph prend naturellement en charge l'exécution parallèle des nœuds tant qu'il n'y a pas de dépendances entre ces nœuds (par exemple, la sortie d'un LLM ne peut pas être utilisée comme entrée dans le suivant). Cela signifie que plusieurs agents peuvent s'exécuter simultanément, à condition qu'il ne s'agisse pas de nœuds interdépendants.

Également pris en charge par LangGraph :

• utiliser RunnableParallel Exécution de plusieurs graphiques
• Avec le logiciel Python asyncio Outil d'appel parallèle à la bibliothèque

Logique de réessai et gestion des erreurs

LangChain

La gestion des erreurs de LangChain doit être explicitement définie par le développeur, ce qui peut être fait via :

• Introduction de la logique de réessai dans la chaîne (Retry Logic)
• Gestion des échecs des appels d'outils dans l'agent

LangGraph

LangGraph peut intégrer la logique de gestion des erreurs directement dans le flux de travail en faisant de la gestion des erreurs un nœud distinct.

• Lorsqu'une tâche échoue, vous pouvez passer à un autre nœud de gestion des erreurs ou réessayer au niveau du nœud actuel.
• Les nœuds qui échouent sont réessayés individuellement, plutôt que de réexécuter l'ensemble du flux de travail.
• De cette manière, le diagramme peut poursuivre son exécution à partir du point où il a échoué, sans avoir à repartir de zéro.

Si votre tâche comporte plusieurs étapes et appels d'outils, ce mécanisme de gestion des erreurs peut être très important.

Comment choisir entre LangChain et LangGraph ?

Les développeurs peuvent :

• Utiliser uniquement LangChain
• Utiliser uniquement LangGraph
• Utilisation conjointe de LangChain et LangGraph

Il est également possible de combiner les capacités de structuration de graphes de LangGraph avec d'autres frameworks d'agents tels que AutoGen de Microsoft, par exemple en combinant la fonction AutoGen Agent en tant que nœud de LangGraph.

LangChain et LangGraph ont chacun leurs avantages, et le choix du bon outil peut être déroutant.

Quand choisir LangChain ?

Si les développeurs ont besoin de créer rapidement des flux de travail d'IA, pensez à LangChain dans les situations suivantes :

• tâche linéaireLes flux de travail prédéfinis pour la recherche de documents, la génération de textes, le résumé, etc.
• L'agent d'IA nécessite une prise de décision dynamiquemais ne nécessite pas un contrôle fin des processus complexes.

Quand choisir LangGraph ?

Si le scénario de l'application nécessite un flux de travail non linéaire, LangGraph peut être utilisé dans les situations suivantes :

• La tâche implique une interaction dynamique entre de multiples composants.
• Requiert un jugement conditionnel, une logique de branchement complexe, une gestion des erreurs ou une exécution en parallèle.
• Les développeurs sont prêts à mettre en œuvre eux-mêmes certaines des fonctionnalités non fournies par LangChain.

Quand dois-je utiliser LangChain et LangGraph ensemble ?

Si l'on souhaite tirer parti des capacités d'abstraction de LangChain (par exemple, les composants RAG, les mémoires de dialogue, etc.) et des capacités d'orchestration non linéaire de LangGraph, on peut envisager d'utiliser les deux.

Ensemble, ils peuvent tirer pleinement parti de leurs atouts respectifs pour créer des flux de travail d'IA plus souples et plus puissants.