Cet article démontrera le processus d'utilisation du récupérateur de documents parent dans LangChain.
Comment utiliser un outil de récupération de documents parents dans LangChain ?
Le récupérateur de documents parent dans LangChain peut être utilisé en divisant les documents en morceaux plus petits afin qu'ils ne perdent pas leur sens au moment de l'intégration. Le document parent peut être considéré comme le document entier ou le plus gros morceau à partir duquel les plus petits morceaux sont extraits.
Pour découvrir le processus d'utilisation du récupérateur de documents parent dans LangChain, consultez simplement ce guide :
Étape 1 : Installer les modules
Tout d'abord, commencez à utiliser le récupérateur de documents parent en installant le framework LangChain à l'aide de la commande pip :
pip installer langchain
Installez le module de base de données Chroma pour enregistrer les intégrations du document et en récupérer les données :
pip installer chromadb
Pour installer tiktoken qui est un tokenizer qui récupère les tokens du document en créant de petits morceaux :
pip installer tiktoken 
Obtenez le module OpenAI en exécutant la commande suivante sur le notebook Python pour obtenir ses dépendances et bibliothèques :
pip installer openai 
Étape 2 : Configuration de l'environnement et téléchargement des données
La prochaine étape consiste à mettre en place l'environnement en utilisant la clé API du compte OpenAI :
importer toiimporter obtenir un laissez-passer
toi . environ [ 'OPENAI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API OpenAI : » )
Maintenant, téléchargez les documents depuis le système local après avoir importé la bibliothèque de fichiers, puis appelez la méthode upload() :
depuis Google. ET AL importer des dossierstéléchargé = des dossiers. télécharger ( )
Étape 3 : Importer des bibliothèques
L'étape suivante contient le code pour importer les bibliothèques requises pour utiliser les récupérateurs de documents parents à l'aide du framework LangChain :
depuis chaîne de langue. récupérateurs importer ParentDocumentRetrieverdepuis chaîne de langue. magasins de vecteurs importer Chroma
depuis chaîne de langue. intégrations importer OpenAIEmbeddings
depuis chaîne de langage. texte_splitter importer RécursifCharacterTextSplitter
depuis chaîne de langage. stockage importer DansMemoryStore
depuis chaîne de langage. chargeurs_de documents importer Chargeur de texte
Chargez le document pour construire le récupérateur en utilisant les méthodes TextLoader() avec le chemin des fichiers :
chargeurs = [Chargeur de texte ( 'Données.txt' ) ,
Chargeur de texte ( 'état_of_the_union.txt' ) ,
]
documents = [ ]
pour je dans chargeurs :
Étape 4 : Récupération de documents complets
Une fois les documents/fichiers chargés dans le modèle, créez simplement les intégrations des documents et stockez-les dans les magasins de vecteurs :
enfant_splitter = RécursifCharacterTextSplitter ( taille_morceau = 400 )magasin de vecteurs = Chroma (
nom_collection = 'documents_complets' ,
fonction_intégration = OpenAIEmbeddings ( )
)
magasin = DansMemoryStore ( )
retriever = ParentDocumentRetriever (
magasin de vecteurs = magasin de vecteurs ,
docstore = magasin ,
enfant_splitter = enfant_splitter ,
)
Maintenant, appelez la méthode add_documents() en utilisant le récupérateur pour amener le récupérateur aux documents :
retriever. add_documents ( documents , identifiants = Aucun )Le code suivant extrait les intégrations des documents qui ont été stockés dans la base de données pour les fichiers téléchargés :
liste ( magasin. rendement_keys ( ) ) 
Après avoir obtenu les intégrations des documents, appelez la méthode similarity_search() avec la requête pour obtenir les petits morceaux du document :
sub_docs = magasin vectoriel. similarité_recherche ( 'justice breyer' )Appelez la méthode print() pour afficher les fragments appelés dans le code précédent en fonction de la requête :
imprimer ( sub_docs [ 0 ] . Contenu de la page ) 
Appelez la fonction complete the retriever() pour obtenir tous les jetons stockés dans la base de données en utilisant le code suivant :
récupéré_docs = retriever. get_relevant_documents ( 'justice breyer' )L'impression de tous les documents prendrait énormément de temps et de puissance de traitement, alors récupérez simplement la longueur des documents récupérés précédemment :
seulement ( récupéré_docs [ 0 ] . Contenu de la page ) 
Étape 5 : Récupération de morceaux plus gros
Cette étape ne prendra pas tout le document ; cependant, cela prendrait un plus gros tamia du document et en récupérerait un plus petit morceau :
parent_splitter = RécursifCharacterTextSplitter ( taille_morceau = 2000 )enfant_splitter = RécursifCharacterTextSplitter ( taille_morceau = 400 )
magasin de vecteurs = Chroma ( nom_collection = 'split_parents' , fonction_intégration = OpenAIEmbeddings ( ) )
magasin = DansMemoryStore ( )
Configurez le récupérateur pour obtenir le plus petit jeton de l'énorme pool de données stockées dans le ' magasin de vecteurs 'variable :
retriever = ParentDocumentRetriever (magasin de vecteurs = magasin de vecteurs ,
docstore = magasin ,
enfant_splitter = enfant_splitter ,
parent_splitter = parent_splitter ,
)
Appelez le récupérateur pour obtenir les plus gros morceaux des magasins de vecteurs en utilisant le documents variable dans l'argument de la fonction :
retriever. add_documents ( documents )Obtenez la longueur de ces documents auprès du documents variable via la commande ci-dessous :
seulement ( liste ( magasin. rendement_keys ( ) ) ) 
Obtenez simplement un plus petit morceau d'un plus gros, car la capture d'écran précédente montre qu'il y a 23 documents stockés dans le magasin de vecteurs. La requête est utilisée pour obtenir les données pertinentes à l'aide du similarité_recherche() méthode pour récupérer les données du magasin de vecteurs :
sub_docs = magasin vectoriel. similarité_recherche ( 'justice breyer' )Imprimez les plus petits morceaux en utilisant la requête mentionnée dans le code précédent pour les afficher à l'écran :
imprimer ( sub_docs [ 0 ] . Contenu de la page ) 
Maintenant, utilisez le récupérateur sur l'ensemble de données complet stocké dans la base de données en utilisant la requête comme argument de la fonction :
récupéré_docs = retriever. get_relevant_documents ( 'justice breyer' )Obtenez la longueur des morceaux complets créés et stockés dans la base de données :
seulement ( récupéré_docs [ 0 ] . Contenu de la page ) 
Nous ne pouvons pas afficher tous les fragments, mais le premier fragment avec le numéro d'index 0 est affiché à l'aide du code suivant :
imprimer ( récupéré_docs [ 0 ] . Contenu de la page 
Il s’agit du processus d’utilisation du récupérateur de documents parent dans LangChain.
Conclusion
Pour utiliser le récupérateur de documents parent dans LangChain, installez simplement les modules et configurez l'environnement OpenAI à l'aide de sa clé API. Après cela, importez les bibliothèques requises depuis LangChain pour utiliser le récupérateur de documents parent, puis chargez les documents pour le modèle. L'utilisateur peut utiliser les documents parents comme le document entier ou comme un gros morceau et obtenir un plus petit morceau à l'aide de la requête. Cet article a expliqué le processus d'utilisation du récupérateur de documents parent dans LangChain.