Aperçu rapide
Cet article démontrera ce qui suit :
- Comment ajouter de la mémoire à un agent et à ses outils dans LangChain
- Étape 1 : Installation des frameworks
- Étape 2 : configuration des environnements
- Étape 3 : Importer des bibliothèques
- Étape 4 : ajout de ReadOnlyMemory
- Étape 5 : Configuration des outils
- Étape 6 : Création de l'agent
- Méthode 1 : utilisation de ReadOnlyMemory
- Méthode 2 : utilisation de la même mémoire pour l'agent et les outils
- Conclusion
Comment ajouter de la mémoire à un agent et à ses outils dans LangChain ?
L'ajout de mémoire aux agents et aux outils leur permet de mieux travailler avec la possibilité d'utiliser l'historique de discussion du modèle. Grâce à la mémoire, l'agent peut décider efficacement quel outil déployer et quand. Il est préférable d’utiliser le « Lecture seuleMémoire ' pour les agents et les outils afin qu'ils ne puissent pas le modifier. Pour découvrir le processus d'ajout de mémoire aux agents et aux outils dans LangChain, suivez les étapes répertoriées :
Étape 1 : Installation des frameworks
Tout d'abord, installez le langchain-expérimental module pour obtenir ses dépendances pour créer des modèles de langage et des outils pour l'agent. LangChain experimental est le module qui obtient les dépendances pour créer des modèles principalement utilisés pour les expériences et les tests :
pip installer langchain - expérimental
Obtenir le résultats de recherche Google modules avec les dépendances OpenAI pour obtenir les réponses les plus pertinentes sur Internet :
pip installer openai google - recherche - résultats
Étape 2 : configuration des environnements
Pour construire le modèle qui obtient des réponses sur Internet, il est nécessaire de configurer les environnements à l'aide du OpenAI et SerpAPI clés:
importer toi
importer obtenir un laissez-passer
toi. environ [ 'OPENAI_API_KEY' ] = passe-passe. obtenir un laissez-passer ( « Clé API OpenAI : » )
toi. environ [ 'SERPAPI_API_KEY' ] = passe-passe. obtenir un laissez-passer ( « Clé API Serpapi : » )
Étape 3 : Importer des bibliothèques
Après avoir configuré les environnements, importez les bibliothèques pour créer les outils pour l'agent et la mémoire supplémentaire à intégrer avec eux. Le code suivant utilise les agents, la mémoire, les llms, les chaînes, les invites et les utilitaires pour obtenir les bibliothèques requises :
de Langchain. agents importer AgentZéroShot , Outil , AgentExécuteurde Langchain. mémoire importer ConversationBufferMémoire , Lecture seuleMémoire partagée
de Langchain. llms importer OpenAI
#obtenir la bibliothèque pour construire la chaîne en utilisant LangChain
de Langchain. Chaînes importer LLMChaîne
de Langchain. instructions importer Modèle d'invite
#obtenir la bibliothèque pour obtenir des informations sur Internet
de Langchain. utilitaires importer SerpAPIWrapper
Étape 4 : ajout de ReadOnlyMemory
Configurez le modèle pour que l'agent puisse commencer à effectuer des tâches dès que l'utilisateur fournit l'entrée. Après cela, ajoutez le « ConversationBufferMemory() » pour stocker l'historique des discussions du modèle et initialiser le « Lecture seule Mémoire » pour les agents et ses outils :
modèle = '' 'Il s'agit d'une conversation entre un humain et un robot :{historique_chat}
#définir la structure pour extraire le résumé précis et facile
Résumez le chat pour {input} :
' ''
rapide = Modèle d'invite ( variables_d'entrée = [ 'saisir' , 'historique_de chat' ] , modèle = modèle )
mémoire = ConversationBufferMémoire ( clé_mémoire = 'historique_de chat' )
mémoire en lecture seule = Lecture seuleMémoire partagée ( mémoire = mémoire )
#chaîne récapitulative pour intégrer tous les composants pour obtenir le résumé de la conversation
résumé_chain = LLMChaîne (
llm = OpenAI ( ) ,
rapide = rapide ,
verbeux = Vrai ,
mémoire = mémoire en lecture seule ,
)
Étape 5 : Configuration des outils
Maintenant, configurez des outils tels que la recherche et le résumé pour obtenir la réponse sur Internet ainsi que le résumé du chat :
recherche = SerpAPIWrapper ( )outils = [
Outil (
nom = 'Recherche' ,
fonction = recherche. courir ,
description = 'des réponses appropriées aux requêtes ciblées sur les événements récents' ,
) ,
Outil (
nom = 'Résumé' ,
fonction = résumé_chain. courir ,
description = 'utile pour résumer le chat et l'entrée dans cet outil doit être une chaîne, représentant qui lira ce résumé' ,
) ,
]
Étape 6 : Création de l'agent
Configurez l'agent dès que les outils sont prêts à effectuer les tâches requises et à extraire les réponses d'Internet. Le ' préfixe La variable ' est exécutée avant que les agents n'attribuent une tâche aux outils et le ' suffixe » est exécuté après que les outils ont extrait la réponse :
préfixe = '' « Discutez avec un humain en répondant du mieux que vous pouvez aux questions suivantes en accédant aux outils suivants : » ''suffixe = '' 'Commencer!'
#structure pour l'agent pour commencer à utiliser les outils tout en utilisant la mémoire
{ chat_historique }
Question : { saisir }
{ agent_scratchpad } '' '
invite = ZeroShotAgent.create_prompt(
#configurer des modèles d'invite pour comprendre le contexte de la question
outils,
préfixe=préfixe,
suffixe=suffixe,
input_variables=[' saisir ', ' chat_historique ', ' agent_scratchpad '],
)
Méthode 1 : utilisation de ReadOnlyMemory
Une fois que l'agent est configuré pour exécuter les outils, le modèle avec ReadOnlyMemory est le préféré façon de construire et d'exécuter les chaînes pour récupérer les réponses et le processus est le suivant :
Étape 1 : Construire la chaîne
La première étape de cette méthode consiste à construire la chaîne et l'exécuteur pour le 'ZéroShotAgent()' avec ses arguments. Le «LLMChain()» est utilisé pour établir la connexion entre toutes les discussions du modèle de langage à l'aide des arguments llm et prompt. L'agent utilise llm_chain, tools et verbose comme argument et construit agent_chain pour exécuter les deux agents et ses outils avec la mémoire :
llm_chain = LLMChaîne ( llm = OpenAI ( température = 0 ) , rapide = rapide )agent = AgentZéroShot ( llm_chain = llm_chain , outils = outils , verbeux = Vrai )
agent_chain = AgentExécuteur. from_agent_and_tools (
agent = agent , outils = outils , verbeux = Vrai , mémoire = mémoire
)
Étape 2 : tester la chaîne
Appeler le agent_chain en utilisant la méthode run() pour poser la question depuis Internet :
agent_chain. courir ( saisir = 'Qu'est-ce que LangChain' )L'agent a extrait la réponse sur Internet à l'aide des outils de recherche :
L'utilisateur peut poser la question de suivi peu claire pour tester la mémoire attachée à l'agent :
agent_chain. courir ( saisir = 'Qui l'a développé ?' )L'agent a utilisé le chat précédent pour comprendre le contexte des questions et a récupéré les réponses comme indiqué dans la capture d'écran suivante :
L’agent utilise l’outil (summary_chain) pour extraire une synthèse de toutes les réponses extraites précédemment en utilisant la mémoire de l’agent :
agent_chain. courir (saisir = 'Merci ! Résumez la conversation, pour mes 5 ans'
)
Sortir
Le résumé des questions posées précédemment a été affiché pour un enfant de 5 ans dans la capture d'écran suivante :
Étape 3 : tester la mémoire
Imprimez la mémoire tampon pour extraire les discussions qui y sont stockées en utilisant le code suivant :
imprimer ( agent_chain. mémoire . tampon )Les chats dans le bon ordre sans aucune modification ont été affichés dans l'extrait suivant :
Méthode 2 : utilisation de la même mémoire pour l'agent et les outils
La deuxième méthode non recommandée par la plateforme consiste à utiliser la mémoire tampon à la fois pour les agents et les outils. Les outils peuvent modifier les discussions stockées dans la mémoire, ce qui peut renvoyer de faux résultats dans les grandes conversations :
Étape 1 : Construire la chaîne
Utilisation du code complet du modèle pour créer les outils et les chaînes pour les agents avec un petit changement car ReadOnlyMemory n'est pas ajouté cette fois :
modèle = '' 'Il s'agit d'une conversation entre un humain et un robot :{historique_chat}
Rédigez un résumé de la conversation pour {input} :
' ''
#construire la structure du chat interface en utilisant le modèle d'invite en ajoutant la mémoire avec la chaîne
rapide = Modèle d'invite ( variables_d'entrée = [ 'saisir' , 'historique_de chat' ] , modèle = modèle )
mémoire = ConversationBufferMémoire ( clé_mémoire = 'historique_de chat' )
résumé_chain = LLMChaîne (
llm = OpenAI ( ) ,
rapide = rapide ,
verbeux = Vrai ,
mémoire = mémoire ,
)
#construire les outils ( recherche et résumé ) pour configuration des agents
recherche = SerpAPIWrapper ( )
outils = [
Outil (
nom = 'Recherche' ,
fonction = recherche. courir ,
description = 'des réponses appropriées aux requêtes ciblées sur les événements récents' ,
) ,
Outil (
nom = 'Résumé' ,
fonction = résumé_chain. courir ,
description = 'utile pour obtenir le résumé du chat et nécessite la saisie de la chaîne dans cet outil représentant qui lira ce résumé' ,
) ,
]
#expliquer les étapes pour l'agent doit utiliser les outils pour extraire des informations pour la discussion
préfixe = '' ' Discutez avec un humain et répondez aux requêtes de la meilleure façon possible en accédant aux outils suivants :' ''
suffixe = '' 'Commencer!'
#structure pour l'agent pour commencer à utiliser les outils tout en utilisant la mémoire
{ chat_historique }
Question : { saisir }
{ agent_scratchpad } '' '
invite = ZeroShotAgent.create_prompt(
#configurer des modèles d'invite pour comprendre le contexte de la question
outils,
préfixe=préfixe,
suffixe=suffixe,
input_variables=[' saisir ', ' chat_historique ', ' agent_scratchpad '],
)
#intégrer tous les composants lors de la construction de l'exécuteur de l'agent
llm_chain = LLMChain(llm=OpenAI(température=0), invite=invite)
agent = ZeroShotAgent (llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools(
agent=agent, outils=outils, verbeux=Vrai, mémoire=mémoire
)
Étape 2 : tester la chaîne
Exécutez le code suivant :
agent_chain. courir ( saisir = 'Qu'est-ce que LangChain' )La réponse est affichée et stockée avec succès dans la mémoire :
Posez la question de suivi sans donner beaucoup de contexte :
agent_chain. courir ( saisir = 'Qui l'a développé ?' )L'agent utilise la mémoire pour comprendre la question en la transformant puis imprime la réponse :
Récupérez le résumé du chat en utilisant la mémoire attachée à l'agent :
agent_chain. courir (saisir = 'Merci ! Résumez la conversation, pour mes 5 ans'
)
Sortir
Le résumé a été extrait avec succès, et jusqu'à présent, tout semble être pareil mais le changement intervient à l'étape suivante :
Étape 3 : tester la mémoire
Extraire les messages de chat de la mémoire à l'aide du code suivant :
imprimer ( agent_chain. mémoire . tampon )L'outil a modifié l'historique en ajoutant une autre question qui n'était pas posée initialement. Cela se produit lorsque le modèle comprend la question à l'aide d'un se poser la question question. L’outil pense à tort qu’elle est demandée par l’utilisateur et la traite comme une requête distincte. Cela ajoute donc également cette question supplémentaire à la mémoire qui est ensuite utilisée pour obtenir le contexte de la conversation :
C'est tout pour le moment.
Conclusion
Pour ajouter de la mémoire à la fois à un agent et à ses outils dans LangChain, installez les modules pour obtenir leurs dépendances et importez-en des bibliothèques. Après cela, créez la mémoire de conversation, le modèle de langage, les outils et l'agent pour ajouter la mémoire. Le méthode recommandée pour ajouter de la mémoire, utilisez ReadOnlyMemory à l'agent et à ses outils pour stocker l'historique des discussions. L'utilisateur peut également utiliser le mémoire conversationnelle pour les agents et les outils. Mais ils obtiennent confus parfois et changer les discussions dans la mémoire.