Comment ajouter de la mémoire à l'agent OpenAI Functions dans LangChain ?

OpenAI est une organisation d'intelligence artificielle (IA) créée en 2015 et qui était au départ une organisation à but non lucratif. Microsoft a investi beaucoup de fortune depuis 2020 alors que le traitement du langage naturel (NLP) avec IA est en plein essor avec les chatbots et les modèles de langage.

La création d'agents OpenAI permet aux développeurs d'obtenir des résultats plus lisibles et plus précis sur Internet. Ajouter de la mémoire aux agents leur permet de mieux comprendre le contexte du chat et de stocker également les conversations précédentes dans leur mémoire. Pour apprendre le processus d'ajout de mémoire à l'agent de fonctions OpenAI dans LangChain, suivez simplement les étapes suivantes :

Étape 1 : Installation des frameworks

Tout d'abord, installez les dépendances LangChain à partir du 'langchain-expérimental' framework en utilisant le code suivant :

pip installer langchain - expérimental

Installez le 'résultats de recherche Google' module pour récupérer les résultats de recherche du serveur Google :

pip installer google - recherche - résultats

Installez également le module OpenAI qui peut être utilisé pour créer les modèles de langage dans LangChain :

pip installer openai

Étape 2 : configuration des environnements

Après avoir obtenu les modules, configurez les environnements à l'aide des clés API du OpenAI et SerpAPI comptes:

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 : » )

Exécutez le code ci-dessus pour saisir les clés API permettant d'accéder à la fois à l'environnement et appuyez sur Entrée pour confirmer :

Étape 3 : Importer des bibliothèques

Maintenant que la configuration est terminée, utilisez les dépendances installées depuis LangChain pour importer les bibliothèques requises pour construire la mémoire et les agents :

de Langchain. Chaînes importer LLMMathChain
de Langchain. llms importer OpenAI
#obtenir une bibliothèque pour effectuer une recherche depuis Google sur Internet
de Langchain. utilitaires importer SerpAPIWrapper
de Langchain. utilitaires importer Base de données SQL
de langchain_experimental. SQL importer Chaîne de base de données SQL
#get bibliothèque pour créer des outils pour initialisation de l'agent
de Langchain. agents importer Type d'agent , Outil , initialiser_agent
de Langchain. chat_models importer ChatOpenAI

Étape 4 : Création d'une base de données

Pour continuer ce guide, nous devons créer la base de données et nous connecter à l'agent pour en extraire les réponses. Pour construire la base de données, il est nécessaire de télécharger SQLite en utilisant ceci guide et confirmez l'installation à l'aide de la commande suivante :

sqlite3

Exécuter la commande ci-dessus dans le Terminal Windows affiche la version installée de SQLite (3.43.2) :

Après cela, dirigez-vous simplement vers le répertoire de votre ordinateur où la base de données sera construite et stockée :

CD de bureau
cd ma base de données
sqlite3 Chinook. base de données

L'utilisateur peut simplement télécharger le contenu de la base de données à partir de cet emplacement. lien dans le répertoire et exécutez la commande suivante pour construire la base de données :

. lire Chinook_Sqlite. SQL
SÉLECTIONNER * DE LIMITE Artiste dix ;

La base de données a été construite avec succès et l'utilisateur peut y rechercher des données à l'aide de différentes requêtes :

Étape 5 : Téléchargement de la base de données

Une fois la base de données créée avec succès, téléchargez le '.db' fichier au Google Collaboratory en utilisant le code suivant :

de google. ET AL importer des dossiers
téléchargé = des dossiers. télécharger ( )

Choisissez le fichier dans le système local en cliquant sur le 'Choisir des fichiers' bouton après avoir exécuté le code ci-dessus :

Une fois le fichier téléchargé, copiez simplement le chemin du fichier qui sera utilisé à l'étape suivante :

Étape 6 : Configuration du modèle de langage

Créez le modèle de langage, les chaînes, les outils et les chaînes à l'aide du code suivant :

llm = ChatOpenAI ( température = 0 , modèle = 'gpt-3.5-turbo-0613' )
recherche = SerpAPIWrapper ( )
llm_math_chain = LLMMathChain. de_llm ( llm = llm , verbeux = Vrai )
base de données = Base de données SQL. de_uri ( 'sqlite:///../../../../../content/Chinook.db' )
db_chain = SQLDatabaseChaîne. de_llm ( llm , base de données , verbeux = Vrai )
outils = [
Outil (
nom = 'Recherche' ,
fonction = recherche. courir ,
description = 'Posez les questions ciblées pour obtenir des réponses aux questions sur les affaires récentes' ,
) ,
Outil (
nom = 'Calculatrice' ,
fonction = llm_math_chain. courir ,
description = 'utile pour répondre/résoudre des problèmes mathématiques' ,
) ,
Outil (
nom = 'FooBar-DB' ,
fonction = db_chain. courir ,
description = 'utile pour répondre aux questions sur FooBar et la saisie doit se faire sous la forme d'une question contenant le contexte complet' ,
) ,
]

Le llm La variable contient les configurations du modèle de langage utilisant la méthode ChatOpenAI() avec le nom du modèle.
La recherche La variable contient la méthode SerpAPIWrapper() pour créer les outils pour l'agent.
Construire le llm_math_chain pour obtenir les réponses liées au domaine Mathématiques en utilisant la méthode LLMMathChain().
La variable db contient le chemin du fichier contenant le contenu de la base de données. L'utilisateur doit modifier uniquement la dernière partie qui est « contenu/Chinook.db » du chemin en gardant le 'sqlite:///../../../../../' le même.
Construisez une autre chaîne pour répondre aux requêtes de la base de données en utilisant le db_chain variable.
Configurer des outils comme recherche , calculatrice , et FooBar-DB pour rechercher la réponse, répondre aux questions mathématiques et aux requêtes de la base de données respectivement :

Étape 7 : Ajout de mémoire

Après avoir configuré les fonctions OpenAI, créez et ajoutez simplement la mémoire à l'agent :

de Langchain. instructions importer MessagesPlaceholder
de Langchain. mémoire importer ConversationBufferMémoire

agent_kwargs = {
'messages_extra_prompt' : [ MessagesPlaceholder ( Nom de variable = 'mémoire' ) ] ,
}
mémoire = ConversationBufferMémoire ( clé_mémoire = 'mémoire' , return_messages = Vrai )

Étape 8 : initialisation de l'agent

Le dernier composant à construire et à initialiser est l'agent, contenant tous les composants comme llm , outil , OPENAI_FUNCTIONS , et d'autres à utiliser dans ce processus :

agent = initialiser_agent (
outils ,
llm ,
agent = Type d'agent. OPENAI_FUNCTIONS ,
verbeux = Vrai ,
agent_kwargs = agent_kwargs ,
mémoire = mémoire ,
)

Étape 9 : tester l'agent

Enfin, testez l'agent en lançant le chat à l'aide du bouton « Salut ' message:

agent. courir ( 'Salut' )

Ajoutez des informations à la mémoire en exécutant l'agent avec :

agent. courir ( 'Je m'appelle John Snow' )

Maintenant, testez la mémoire en posant la question sur le chat précédent :

agent. courir ( 'quel est mon nom' )

L'agent a répondu avec le nom extrait de la mémoire, la mémoire fonctionne donc correctement avec l'agent :

C'est tout pour le moment.

Conclusion

Pour ajouter de la mémoire à l'agent de fonctions OpenAI dans LangChain, installez les modules pour obtenir les dépendances pour importer les bibliothèques. Après cela, créez simplement la base de données et téléchargez-la sur le notebook Python afin qu'elle puisse être utilisée avec le modèle. Configurez le modèle, les outils, les chaînes et la base de données avant de les ajouter à l'agent et initialisez-le. Avant de tester la mémoire, créez la mémoire à l'aide de ConversationalBufferMemory() et ajoutez-la à l'agent avant de la tester. Ce guide a expliqué comment ajouter de la mémoire à l'agent de fonctions OpenAI dans LangChain.

Comment ajouter de la mémoire à l'agent OpenAI Functions dans LangChain ?

Aperçu rapide