Ce guide illustrera le processus d'utilisation de la mémoire d'entité dans LangChain.
Comment utiliser la mémoire d’entité dans LangChain ?
L'entité est utilisée pour conserver les faits clés stockés dans la mémoire afin de les extraire lorsque l'humain le demande à l'aide des requêtes/invites. Pour apprendre le processus d'utilisation de la mémoire d'entité dans LangChain, visitez simplement le guide suivant :
Étape 1 : Installer les modules
Tout d'abord, installez le module LangChain à l'aide de la commande pip pour obtenir ses dépendances :
pip installer langchain
Après cela, installez le module OpenAI pour obtenir ses bibliothèques permettant de créer des LLM et des modèles de discussion :
pip installer openai
Configurer l'environnement OpenAI en utilisant la clé API qui peut être extraite du compte OpenAI :
importer toi
importer obtenir un laissez-passer
toi . environ [ 'OPENAI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API OpenAI : » )
Étape 2 : Utilisation de la mémoire d'entité
Pour utiliser la mémoire de l'entité, importez les bibliothèques requises pour créer le LLM à l'aide de la méthode OpenAI() :
depuis chaîne de langage. llms importer OpenAIdepuis chaîne de langage. mémoire importer ConversationEntityMémoire
llm = OpenAI ( température = 0 )
Après cela, définissez le mémoire variable à l'aide de la méthode ConversationEntityMemory() pour entraîner le modèle à l'aide des variables d'entrée et de sortie :
mémoire = ConversationEntityMémoire ( llm = llm )_saisir = { 'saisir' : 'Joe are Root a réalisé un projet' }
mémoire. load_memory_variables ( _saisir )
mémoire. sauvegarder_contexte (
_saisir ,
{ 'sortir' : ' Génial ! De quel genre de projet s'agit-il ? ' }
)
Maintenant, testez la mémoire à l'aide de la requête/invite dans le saisir variable en appelant la méthode load_memory_variables() :
mémoire. load_memory_variables ( { 'saisir' : 'qui est Root' } ) 
Maintenant, donnez quelques informations supplémentaires afin que le modèle puisse ajouter quelques entités supplémentaires dans la mémoire :
mémoire = ConversationEntityMémoire ( llm = llm , return_messages = Vrai )_saisir = { 'saisir' : 'Joe are Root a réalisé un projet' }
mémoire. load_memory_variables ( _saisir )
mémoire. sauvegarder_contexte (
_saisir ,
{ 'sortir' : ' Génial ! De quel genre de projet s'agit-il ? ' }
)
Exécutez le code suivant pour obtenir la sortie en utilisant les entités stockées dans la mémoire. C'est possible grâce au saisir contenant l'invite :
mémoire. load_memory_variables ( { 'saisir' : 'qui est Joe' } ) 
Étape 3 : Utilisation de la mémoire d'entité dans une chaîne
Pour utiliser la mémoire de l'entité après avoir construit une chaîne, importez simplement les bibliothèques requises à l'aide du bloc de code suivant :
depuis chaîne de langage. Chaînes importer Chaîne de conversationsdepuis chaîne de langage. mémoire importer ConversationEntityMémoire
depuis chaîne de langage. mémoire . rapide importer ENTITY_MEMORY_CONVERSATION_TEMPLATE
depuis pydantique importer Modèle de base
depuis dactylographie importer Liste , Dicté , N'importe lequel
Construisez le modèle de conversation à l'aide de la méthode ConversationChain() en utilisant les arguments tels que llm :
conversation = Chaîne de conversations (llm = llm ,
verbeux = Vrai ,
rapide = ENTITY_MEMORY_CONVERSATION_TEMPLATE ,
mémoire = ConversationEntityMémoire ( llm = llm )
)
Appelez la méthode conversation.predict() avec l'entrée initialisée avec l'invite ou la requête :
conversation. prédire ( saisir = 'Joe are Root a réalisé un projet' ) 
Maintenant, obtenez la sortie séparée pour chaque entité décrivant les informations la concernant :
conversation. mémoire . entité_store . magasin 
Utilisez la sortie du modèle pour fournir l'entrée afin que le modèle puisse stocker plus d'informations sur ces entités :
conversation. prédire ( saisir = 'Ils essaient d'ajouter des structures de mémoire plus complexes à Langchain' ) 
Après avoir donné les informations stockées dans la mémoire, posez simplement la question pour extraire les informations spécifiques sur les entités :
conversation. prédire ( saisir = 'Que savez-vous de Joe et Root' ) 
Étape 4 : tester la mémoire stockée
L'utilisateur peut inspecter directement les magasins de mémoire pour obtenir les informations qui y sont stockées à l'aide du code suivant :
depuis imprimer importer imprimerimprimer ( conversation. mémoire . entité_store . magasin )
Fournissez plus d'informations à stocker dans la mémoire, car plus d'informations donnent des résultats plus précis :
conversation. prédire ( saisir = 'Root a fondé une entreprise appelée HJRS' ) 
Extrayez les informations de la mémoire après avoir ajouté plus d'informations sur les entités :
depuis imprimer importer imprimerimprimer ( conversation. mémoire . entité_store . magasin )
La mémoire contient des informations sur plusieurs entités telles que HJRS, Joe, LangChain et Root :
Extrayez maintenant les informations sur une entité spécifique à l'aide de la requête ou de l'invite définie dans la variable d'entrée :
conversation. prédire ( saisir = 'Que savez-vous de Root' ) 
Il s’agit d’utiliser la mémoire d’entité à l’aide du framework LangChain.
Conclusion
Pour utiliser la mémoire d'entité dans LangChain, installez simplement les modules requis pour importer les bibliothèques nécessaires à la création de modèles après avoir configuré l'environnement OpenAI. Après cela, créez le modèle LLM et stockez les entités dans la mémoire en fournissant des informations sur les entités. L'utilisateur peut également extraire des informations à l'aide de ces entités et construire ces mémoires dans des chaînes contenant des informations agitées sur les entités. Cet article a expliqué le processus d'utilisation de la mémoire d'entité dans LangChain.