Construire des agents de Langchain pour automatiser les tâches à Python

Les étoiles Github de 90k de Langchain sont toute la crédibilité dont il a besoin - maintenant, c'est le cadre le plus chaud pour créer des applications basées sur LLM. Son ensemble complet d'outils et de composants vous permet de créer des solutions AI de bout en bout en utilisant presque tous les LLM.

Peut-être au cœur des capacités de Langchain sont des agents de Langchain. Ce sont des outils autonomes ou semi-autonomes qui peuvent effectuer des tâches, prendre des décisions et interagir avec d'autres outils et API. Ils représentent un bond en avant significatif dans l'automatisation des workflows complexes avec des LLM.

Dans cet article, vous apprendrez à construire vos propres agents de Langchain qui peuvent effectuer des tâches qui ne sont pas strictement possibles avec les applications de chat d'aujourd'hui comme Chatgpt.

Configuration

Avant d'entrer dans quoi que ce soit, créons notre environnement pour le tutoriel.

Tout d'abord, la création d'un nouvel environnement conda:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Installation des packages de Langchain et quelques autres bibliothèques nécessaires:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Ajout de l'environnement conda nouvellement créé à Jupyter comme noyau:

$ ipython kernel install --user --name=langchain

Création d'un fichier .env pour stocker des secrets tels que les clés d'API:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Récupération de votre clé API OpenAI à partir du fichier .env:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Test que tout fonctionne correctement en interrogeant GPT-3.5 (le modèle de langue par défaut) d'Openai:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Maintenant, nous sommes prêts à commencer.

Que sont les agents de Langchain?

passons un peu de temps à réfléchir au cadre de l'agent. Plus précisément, nous considérerons comment il diffère du paradigme de la chaîne traditionnel et des composants d'un agent. Comprendre pourquoi nous devons choisir une nouvelle façon de créer des applications nous préparera à rédiger le code.

chaînes vs agents

Le trait déterminant des agents est leur capacité à choisir le meilleur ordre d'actions pour résoudre un problème compte tenu d'un ensemble d'outils.

Par exemple, disons que nous avons ce qui suit:

• Une API météo
• MOLE ML POUR LES Recommandations de vêtements
• API Strava pour les routes de vélo
• Base de données des préférences des utilisateurs
• Modèle de reconnaissance d'image
• Modèle de langue (génération de texte)

La résolution de problèmes traditionnelle impliquerait d'utiliser une chaîne d'outils sélectionnés dans la liste:

Chain 1: Recommander des vêtements météorologiques

1. Appelez l'API météo
2. Entrez les données météorologiques dans le modèle de vêtements ML
3. générer des recommandations de vêtements
4. présenter les résultats à l'utilisateur

Chaîne 2: Suggère de route de vélo basée sur la météo

1. Appelez l'API météo
2. Appelez l'API Strava pour les routes populaires
3. Les routes de filtre en fonction des conditions météorologiques
4. présentent des routes appropriées vers l'utilisateur

chaîne 3: Analyseur de photos de tenue

1. recevoir la photo de la tenue de l'utilisateur
2. Utilisez un modèle de reconnaissance d'image pour identifier les articles de vêtements
3. Comparez avec la base de données des préférences des utilisateurs
4. générer des commentaires à l'aide du modèle de génération de texte
5. Présenter l'analyse à l'utilisateur

Chaque chaîne résout un problème spécifique en utilisant une séquence prédéterminée d'étapes et un sous-ensemble des outils disponibles. Ils ne peuvent pas s'adapter au-delà de leur portée définie. Ils nécessitent également trois branches de développement distinctes, ce qui est inefficace en termes de temps et de ressources.

Maintenant, imaginez un système agentique avec accès à tous ces outils. Il serait capable de:

1. Comprendre la requête ou le problème de l'utilisateur (à travers le langage naturel avec un modèle de langue)
2. Évaluer quels outils sont pertinents pour le problème (raisonnement)
3. Créez dynamiquement un flux de travail en utilisant les outils les plus appropriés
4. Exécutez le flux de travail, en effectuant des ajustements en temps réel si nécessaire (agissant)
5. Évaluer le résultat et apprendre des interactions passées

Par exemple, si un utilisateur demande: "Que dois-je porter pour ma balade à vélo aujourd'hui?" L'agent peut vérifier l'API météorologique, analyser les voies de vélo appropriées via Strava, recommander des vêtements appropriés, considérer les préférences passées de l'utilisateur et générer une réponse personnalisée.

L'agent peut:

• gérer une grande variété de problèmes en utilisant le même ensemble d'outils
• Créer des workflows personnalisés pour chaque situation unique
• adapter son approche en fonction du contexte spécifique et des besoins des utilisateurs
• Apprenez des interactions pour améliorer les performances futures

La capacité de Langchain à transformer les modèles de langage - qui, par eux-mêmes, ne produisent que du texte - en moteurs de raisonnement qui peuvent utiliser les ressources à leur disposition pour prendre les mesures appropriées est l'une de ses principales applications. En bref, Langchain permet le développement de forts agents autonomes qui interagissent avec le monde extérieur.

Composants clés

Un agent de Langchain est composé de plusieurs composants, tels que des modèles de chat, des modèles rapides, des outils externes et d'autres constructions connexes. Pour construire des agents réussis, nous devons revoir chaque composant et comprendre leur utilisation.

Modèles de langue et de chat

Il y a beaucoup de pièces mobiles impliquées dans la création d'un agent de Langchain. Le premier et le plus évident est un modèle de langue.

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Les modèles de langue, comme le GPT-3.5 Turbo d'Openai, prennent et générent des chaînes. Ils sont généralement plus âgés et fonctionnent mieux pour répondre aux requêtes utilisateur individuelles.

Les modèles plus récents et plus puissants sont généralement des modèles de chat, qui peuvent prendre une séquence de messages comme entrées et retourner les messages de chat comme sorties (par opposition à l'utilisation de texte brut):

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

En termes différemment, les modèles de chat nous permettent d'avoir des conversations en langage naturel. Dans l'exemple ci-dessus, nous initialisons GPT-4O-MINI avec un message système suivi d'une requête utilisateur. Notez l'utilisation des classes SystemMessage et HumanMessage.

La sortie est un objet de message, qui est le comportement attendu des modèles de chat:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

$ ipython kernel install --user --name=langchain

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

en plus, ils renvoient d'autres métadonnées utiles accessibles avec la note de point:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

La plupart des agents utilisent des modèles de chat en raison de leur base de connaissances mise à jour et de leurs capacités de conversation. Cependant, pour les agents simples sans exigences de mémoire, des modèles de langage comme GPT-3.5 seront suffisants.

Modèles d'invite

Le moyen le plus efficace de demander des modèles de langage ou de chat consiste à utiliser des modèles d'invite. Ils vous permettent de structurer vos requêtes insérer de manière cohérente et dynamiquement, ce qui rend vos interactions avec le modèle plus flexible et réutilisable.

Dans Langchain, il existe de nombreux types de modèles rapides, la classe la plus basique étant PromptTemplate. Il peut être utilisé avec les modèles de langue (texte brut):

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

La classe vous oblige à créer une chaîne avec des espaces réservés pour les variables que vous souhaitez remplacer à l'aide de la notation du support. Ensuite, vous devez passer cette chaîne de modèle à la classe d'interrompre avec les noms des variables, construisant ainsi votre invite.

appeler .invoke () avec des valeurs pour les variables montrera comment votre invite sera transmise à un modèle.

Passer ce modèle d'invite à un modèle de langue nous oblige à le enchaîner à l'aide de l'opérateur de tuyau:

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

L'opérateur de tuyau (|) fait partie du langage d'expression de Langchain (LCEL), conçu pour enchaîner plusieurs composants et outils de Langchain.

type(output)

langchain_core.messages.ai.AIMessage

Lorsque vous utilisez l'opérateur de tuyau sur des objets Langchain, vous créez une instance de classe RunnableSequence. Une séquence runnable représente une chaîne d'objets qui prennent en charge la méthode .invoke (), comme les modèles invites et les modèles de langue / chat.

Maintenant, regardons une autre classe de modèle d'invite pour les modèles de chat:

print(output.content)

Nous avons mentionné que les modèles de chat nécessitent une séquence de messages en entrées. L'entrée initiale est généralement une invite système indiquant au modèle de chat comment se comporter. Ainsi, en utilisant la classe ChatPromptTemplate, nous pouvons facilement créer des modèles de chat avec différentes personnalités:

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

La classe nécessite une liste de messages basés sur les rôles en entrée. Chaque membre de la liste doit être un tuple (rôle, message) avec les espaces réservés variables définis si nécessaire.

Après l'avoir prêt, nous pouvons utiliser le même opérateur de tuyaux pour créer des modèles de chat avec différents comportements:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

outils

Dans une section précédente, nous avons mentionné que les agents peuvent choisir une combinaison d'outils à leur disposition pour résoudre un problème particulier, avec des LLM comme moteurs de raisonnement sous le capot.

Langchain propose des intégrations avec des dizaines d'API et de services populaires pour permettre aux agents d'interagir avec le reste du monde. La plupart d'entre eux sont disponibles dans le package Langchain_community, tandis que certains se trouvent à l'intérieur de Langchain_core.

Par exemple, voici comment vous pouvez utiliser l'outil ARXIV pour récupérer des résumés de papier sur divers sujets:

$ ipython kernel install --user --name=langchain

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Il existe un autre moyen de charger des outils plutôt que de les importer par le nom de leur classe:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Ci-dessus, nous chargeons les outils de générateur d'images ArXIV et DALL-E en même temps en utilisant la fonction Load_Tools (). Les outils chargés de cette fonction ont la même syntaxe d'utilisation:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

La fonction Load_tools vous oblige à connaître les noms de chaîne des classes d'outils, comme l'exemple d'ArxivQuerryRun contre «Arxiv». Vous pouvez vérifier rapidement le nom de chaîne de n'importe quel outil en exécutant la fonction get_all_tool_name:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

type(output)

Notez que load_tools () n'est qu'une fonction raccourci. Lors de la construction d'agents, il est recommandé de charger des outils à l'aide de leur constructeur de classe, ce qui vous permet de les configurer en fonction de leur comportement spécifique.

flux de travail étape par étape de la façon de construire des agents de Langchain

Enfin, dans cette section, nous verrons comment créer des agents de Langchain étape par étape en utilisant les connaissances que nous avons acquises dans les sections précédentes.

Dans les exemples à venir, nous construire un agent capable d'expliquer n'importe quel sujet via trois supports: texte, image ou vidéo. Plus précisément, sur la base de la question posée, l'agent décidera d'expliquer le sujet dans quel format.

Commençons. N'oubliez pas de vérifier comment configurer l'environnement, qui est couvert au début de l'article. 

1. Définition des outils

La première étape après la configuration de notre environnement consiste à définir les outils que nous donnerons à notre agent. Importons-les:

langchain_core.messages.ai.AIMessage

Nous importons cinq classes:

• wikipediaapiwrapper: Pour configurer comment accéder à l'API Wikipedia
• WikipediaQueryrun: pour générer des résumés de page wikipedia
• YouTubesearchTool: pour rechercher des vidéos YouTube sur des sujets
• DalapiWrapper: Pour configurer comment accéder à Dalle Endpoint d'Openai
• openaidalleimageGenerationTool: Pour générer des images à l'aide d'invites

Lorsqu'un utilisateur interroge notre agent, il décidera d'expliquer le sujet à l'aide d'un article Wikipedia au format texte, ou en créant une image à l'aide de Dall-E pour une compréhension visuelle, ou en suggérant des vidéos YouTube pour une compréhension plus profonde.

Initialisons-les, en commençant par l'outil Wikipedia:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Générateur d'images Dalle:

$ ipython kernel install --user --name=langchain

Outil de recherche YouTube:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

prenez particulièrement soin des descriptions des outils. L'agent décidera de quel outil utiliser en fonction de la description que vous fournissez. 

Maintenant, nous allons mettre les outils dans une liste:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Nous pouvons déjà lier cet ensemble d'outils à un modèle de chat sans créer un agent:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

Essayons d'appeler le modèle avec un message simple:

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

La sortie montre qu'aucun des outils liés n'a été utilisé lors de la génération d'une réponse. Maintenant, posons une question spécifique qui obligerait le modèle à regarder au-delà de ses données de formation:

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Nous pouvons voir qu'il n'y a pas de sortie de texte, mais Dalle d'Openai est mentionné. L'outil n'est pas encore appelé; Le modèle suggère simplement que nous l'utilisons. Pour l'appeler réellement - pour prendre des mesures, nous devons créer un agent.

2. Création d'un agent simple

Après avoir défini le modèle et les outils, nous créons l'agent. Langchain propose une interface de fonction CREATE_REACT_AGENT () de haut niveau de son package Langgraph pour créer rapidement des agents React (Raison et ACT):

type(output)

Lors de l'initialisation de l'agent avec un modèle de chat et une liste d'outils, nous passons une invite système pour dire au modèle comment se comporter en général. Il est maintenant prêt à accepter les requêtes:

langchain_core.messages.ai.AIMessage

print(output.content)

Nous avons reçu une réponse probable, qui est une réponse texte simple sans appels d'outils. Maintenant, demandons quelque chose de plus au point:

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

output.dict()

Cette fois, il y a quatre messages. Voyons les noms de classe de message et leur contenu:

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

C'est parti! Le troisième message provient d'un appel à outils, qui est un résumé d'une page Wikipedia sur la photosynthèse. Le dernier message provient du modèle de chat, qui utilise le contenu de l'appel de l'outil lors de la construction de sa réponse.

Créons rapidement une fonction pour modulariser les dernières étapes que nous avons prises:

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

3. Affiner l'invite du système

Maintenant, mettons à jour notre invite système avec des instructions détaillées sur la façon dont l'agent doit se comporter:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Recréons notre agent avec la nouvelle invite du système:

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

type(chain)

génial, basé sur notre message (qui était très instructif :), l'agent a choisi le bon outil pour le travail. Voici l'image générée:

4. Ajout de la mémoire aux agents

En ce moment, notre agent est sans état, ce qui signifie qu'il ne se souvient pas des interactions précédentes:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Le moyen le plus simple d'ajouter l'historique des messages de chat aux agents est d'utiliser la classe Sqlitesaver de Langgraph:

$ ipython kernel install --user --name=langchain

Nous initialisons la mémoire à l'aide de la méthode .From_Conn_string () de la classe Sqlitesaver, qui crée un fichier de base de données. Ensuite, nous passons la mémoire au paramètre CheckPointer de la fonction create_react_agent ().

Maintenant, nous devons créer un dictionnaire de configuration:

$ touch .env
$ vim .env  # Paste your OPENAI key

Le dictionnaire définit un ID de fil pour distinguer une conversation d'une autre et il est transmis à la méthode .invoke () de notre agent. Alors, mettons à jour notre fonction EXECUTE () pour inclure ce comportement:

OPENAI_API_KEY='YOUR_KEY_HERE'

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Maintenant, demandons à l'agent sur les requêtes précédentes:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Comme prévu, l'agent renvoie les messages précédents! Maintenant, nous n'avons besoin que d'une interface utilisateur de chat comme celle de Chatgpt et nous nous sommes obtenus un chatbot personnalisé.

Tendances et développements futurs

Tout au long de l'article, nous avons aperçu où Langchain va en termes d'agents. Jusqu'à très récemment, Langchain avait principalement utilisé la classe AgentExEcutor, mais elle est lentement remplacée par des agents de Langgraph.

Les agents de Langchain purs sont bien pour commencer, mais ils nécessitent plus de lignes de code pour construire le même agent que dans Langgraph. De plus, après un certain point, le cadre d'agentExecutor ne fournira pas la flexibilité que Langgraph a pour construire des agents multi-outils complexes.

C'est pourquoi est le moment idéal pour monter sur la vague et commencer avec Langgraph directement.

Nous recommandons fortement de commencer à utiliser Langsmith, qui est devenu une partie essentielle de l'écosystème de Langchain pour la création d'applications LLM de qualité de production. Voici quelques-uns de ses principaux avantages:

• Débogage: Langsmith fournit des traces détaillées de l'exécution de votre agent, ce qui facilite l'identification et la résolution des problèmes.
• Optimisation des performances: avec Langsmith, vous pouvez analyser l'utilisation des jetons, la latence et d'autres mesures de performance pour optimiser l'efficacité de votre agent.
• Test et évaluation: Langsmith facilite la création et la gestion des ensembles de données de test, vous permettant d'évaluer rigoureusement les performances de votre agent dans une gamme de scénarios.
• Surveillance: Dans les environnements de production, Langsmith offre des capacités de surveillance en temps réel, vous permettant de suivre les performances de votre agent et de détecter rapidement les anomalies.

Voici comment vous pouvez commencer avec Langsmith:

1. Inscrivez-vous à un compte gratuit ici.
2. Définir les variables d'environnement.

Exporter Langchain_tracing_v2 = "true"

Exporter Langchain_API_KEY = "..."

et vous êtes prêt à partir! Lorsque vous commencez à interroger les modèles de langue / chat, Langsmith commence à enregistrer diverses mesures sur chaque exécution:

Conclusion

Dans cet article, nous avons exploré ce qui rend les agents de Langchain distincts des chaînes et les éléments constitutifs importants utilisés pour les construire. Nous avons d'abord introduit ce que sont les agents et comment ils diffèrent des constructions de chaîne les plus traditionnelles concernant la flexibilité et la capacité de prendre des décisions.

Ensuite, nous avons examiné les composants clés que vous devez connaître afin de créer un agent: modèles de chat, outils et modèles d'invite. Enfin, nous avons parcouru deux exemples démontrant comment construire des agents simples et avancés. Le traitement du langage naturel se développe en permanence et les agents de Langchain sont à l'avant-garde de cette progression, ouvrant la voie à une famille encore plus intelligente et polyvalente de l'IA.

Voici quelques ressources connexes pour augmenter votre Langchain:

• Developing LLM Applications avec Langchain Course
• Une introduction à l'ingénierie rapide avec Langchain
• Comment créer des applications LLM avec le tutoriel Langchain
• Construire un modèle GPT avec des capacités de navigation à l'aide de Langchain Tools
• Langchain vs Llamaindex: une comparaison détaillée

Merci d'avoir lu!

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!