Aperçu rapide
Cet article affichera :
Comment utiliser un agent pour renvoyer une sortie structurée dans LangChain
- Installation de frameworks
- Environnement OpenAI
- Création d'un magasin de vecteurs
- Définir le chemin
- Chargement et fractionnement des données
- Créer un retriever
Méthode 1 : combinaison d'un agent avec des magasins de vecteurs
Méthode 2 : utilisation de l'agent comme routeur
Méthode 3 : utilisation de l'agent avec un magasin de vecteurs multi-sauts
Comment utiliser un agent pour renvoyer une sortie structurée dans LangChain ?
Le développeur utilise des agents pour effectuer le routage entre les bases de données contenant les données de formation pour les modèles. Un agent possède le plan du processus complet en stockant toutes les étapes. L'agent dispose des outils nécessaires pour effectuer toutes ces activités afin de mener à bien le processus. L'utilisateur peut également utiliser l'agent pour obtenir des données de différents magasins de données afin de diversifier le modèle.
Pour découvrir le processus de combinaison d'agents et de magasins vectoriels dans LangChain, suivez simplement les étapes répertoriées :
Étape 1 : Installation des frameworks
Tout d'abord, installez le module LangChain et ses dépendances pour combiner les agents et les magasins de vecteurs :
pip installer langchain 
Dans ce guide, nous utilisons la base de données Chroma qui peut stocker des données dans différents emplacements ou tables :
pip installer chromadb 
Pour mieux comprendre les données, divisez les fichiers volumineux en morceaux plus petits à l'aide du tokenizer tiktoken :
pip installer tiktoken 
OpenAI est le module qui peut être utilisé pour construire le grand modèle de langage dans le framework LangChain :
pip installer openai 
Étape 2 : Environnement OpenAI
La prochaine étape ici consiste à mettre en place l'environnement en utilisant la clé API d’OpenAI qui peut être extraite du compte officiel d’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 données du système local vers le collaborateur Google afin de les utiliser à l'avenir :
depuis Google. ET AL importer des dossierstéléchargé = des dossiers. télécharger ( )
Étape 3 : Création d'un magasin de vecteurs
Cette étape configure le premier composant de notre tâche qui est un magasin de vecteurs pour stocker les données téléchargées. La configuration des magasins de vecteurs nécessite les bibliothèques qui peuvent être importées depuis différentes dépendances de LangChain :
depuis chaîne de langue. intégrations . ouvert importer OpenAIEmbeddings#Vector stocke la dépendance pour obtenir la base de données ou le vecteur requis
depuis chaîne de langue. magasins de vecteurs importer Chroma
#Le séparateur de texte est utilisé pour convertir le gros texte en morceaux plus petits
depuis chaîne de langue. texte_splitter importer CaractèreTextSplitter
depuis chaîne de langue. llms importer OpenAI
depuis chaîne de langue. chargeurs_de documents importer WebBaseLoader
depuis chaîne de langue. Chaînes importer RécupérationQA
llm = OpenAI ( température = 0 )
Étape 4 : Définir le chemin
Après avoir importé les bibliothèques, définissez simplement le chemin d'accès aux magasins de vecteurs avant d'y stocker les données :
depuis cheminlib importer Cheminparties_pertinentes = [ ]
pour p dans Chemin ( '.' ) . absolu ( ) . les pièces :
parties_pertinentes. ajouter ( p )
si parties_pertinentes [ - 3 : ] == [ 'langchain' , 'doc' , 'modules' ] :
casser
#Instruction conditionnelle à l'intérieur de la boucle pour définir le chemin de chaque base de données
chemin_doc = str ( Chemin ( *pièces_pertinentes ) / 'état_of_the_union.txt' )
Étape 5 : Chargement et fractionnement des données
Désormais, chargez simplement les données et divisez-les en morceaux plus petits pour améliorer leur lisibilité et leur compréhension. Créez des intégrations des données en convertissant le texte en nombres créant leurs espaces vectoriels et en le stockant dans la base de données Chorma :
depuis chaîne de langage. chargeurs_de documents importer Chargeur de texte#Chargement de l'ensemble de données à partir de son chemin et stockage de ses plus petits morceaux dans la base de données
chargeur = Chargeur de texte ( chemin_doc )
documents = chargeur. charger ( )
texte_splitter = CaractèreTextSplitter ( taille_morceau = 2000 , chunk_overlap = 0 )
des textes = text_splitter. split_documents ( documents )
#Convertissez le texte en nombres et stockez les intégrations dans la base de données
intégrations = OpenAIEmbeddings ( )
recherche de documents = Chroma. à partir de_documents ( des textes , intégrations , nom_collection = 'l'état de l'union' )
Étape 6 : Création d'un Retriever
Pour combiner les magasins d'agents et de vecteurs, il est nécessaire de créer un récupérateur à l'aide de la méthode RetrievalQA() du framework LangChain. Cette méthode de récupération est recommandée pour obtenir des données à partir de magasins de vecteurs en utilisant les agents comme outil pour travailler avec les bases de données :
état_de_union = RécupérationQA. from_chain_type (llm = llm , type_chaîne = 'truc' , retriever = recherche documentaire. as_retriever ( )
)
Chargez un autre ensemble de données pour intégrer l'agent à plusieurs ensembles de données ou magasins de vecteurs :
chargeur = WebBaseLoader ( 'https://beta.ruff.rs/docs/faq/' )Stockez l'ensemble de données ruff dans chromadb après avoir également créé les plus petits morceaux de données avec les vecteurs d'intégration :
documents = chargeur. charger ( )ruff_texts = text_splitter. split_documents ( documents )
ruff_db = Chroma. à partir de_documents ( ruff_texts , intégrations , nom_collection = 'fraise' )
fraise = RécupérationQA. from_chain_type (
llm = llm , type_chaîne = 'truc' , retriever = ruff_db. as_retriever ( )
)
Méthode 1 : combinaison d'un agent avec des magasins de vecteurs
La première méthode consistant à combiner à la fois des agents et des magasins de vecteurs pour extraire des informations est mentionnée ci-dessous :
Étape 1 : configurer les outils
Maintenant que les magasins de vecteurs sont configurés, passons à la construction du deuxième composant de notre processus, à savoir l'agent. Pour créer l'agent pour le processus, importez les bibliothèques en utilisant les dépendances telles que les agents, les outils, etc.
depuis chaîne de langue. agents importer initialiser_agentdepuis chaîne de langue. agents importer Type d'agent
#Obtenir des outils de LangChain pour créer l'agent
depuis chaîne de langue. outils importer Outil de base
depuis chaîne de langue. llms importer OpenAI
#Obtenir LLMMathChain à partir de chaînes pour créer le modèle de langage
depuis chaîne de langue. Chaînes importer LLMMathChain
depuis chaîne de langue. utilitaires importer SerpAPIWrapper
depuis chaîne de langue. agents importer Outil
Configurez les outils à utiliser avec les agents utilisant le système QA ou la récupération configurée précédemment avec le nom et la description des outils :
outils = [Outil (
nom = 'Système d'assurance qualité sur l'état de l'Union' ,
fonction = état_de_union. courir ,
description = 'Fournit des réponses aux questions liées à l'ensemble de données chargé avec une entrée sous forme de question entièrement formée' ,
) ,
Outil (
nom = 'Système d'assurance qualité Ruff' ,
fonction = fraise. courir ,
description = 'Fournit des réponses aux questions sur ruff (un linter python) avec une entrée sous forme de question entièrement formée' ,
) ,
]
Étape 2 : initialiser l'agent
Une fois les outils configurés, définissez simplement l'agent dans l'argument de la méthode initializa_agent(). L'agent que nous utilisons ici est le ZERO_SHOT_REACT_DESCRIPTION avec les outils, llm (modèle de langage) et verbeux :
agent = initialiser_agent (outils , llm , agent = Type d'agent. ZERO_SHOT_REACT_DESCRIPTION , verbeux = Vrai
)
Étape 3 : tester l'agent
Exécutez simplement l'agent en utilisant la méthode run() qui contient la question dans son argument :
agent. courir ('Qu'a dit le président Joe Biden à propos du kanji brown dans le discours'
)
La capture d'écran suivante affiche la réponse extraite des deux magasins de données à l'aide de l'observation stockée dans la mémoire de l'agent :
Méthode 2 : utilisation de l'agent comme routeur
Une autre façon de combiner les deux composants consiste à utiliser l'agent comme routeur. Ce qui suit explique le processus :
Étape 1 : configurer les outils
L'utilisation de l'agent comme routeur signifie que le système RetrievalQA renverra directement la sortie car les outils sont configurés pour renvoyer directement la sortie :
outils = [#configuration des outils requis pour créer l'agent permettant d'obtenir des données à partir des données
Outil (
nom = 'Système d'assurance qualité sur l'état de l'Union' ,
fonction = état_de_union. courir ,
description = 'Fournit des réponses aux questions liées à l'ensemble de données chargé avec une entrée sous forme de question complète' ,
retour_direct = Vrai ,
) ,
Outil (
nom = 'Système d'assurance qualité Ruff' ,
fonction = fraise. courir ,
description = 'Fournit des réponses aux questions sur ruff (un linter python) avec une entrée sous forme de question complète' ,
retour_direct = Vrai ,
) ,
]
Étape 2 : initialiser et tester l'agent
Après avoir configuré les outils, définissez simplement l'agent qui peut être utilisé uniquement comme routeur à l'aide de la méthode initialize_agent() :
agent = initialiser_agent (outils , llm , agent = Type d'agent. ZERO_SHOT_REACT_DESCRIPTION , verbeux = Vrai
)
Testez l'agent en donnant la question d'entrée dans la méthode agent.run() en exécutant la commande suivante :
agent. courir ('Qu'a dit le président Joe Biden à propos du kanji brown dans le discours'
)
Sortir
La capture d'écran de sortie montre que l'agent a simplement renvoyé la réponse à la question à partir de l'ensemble de données extrait par le système RetrievalQA :
Méthode 3 : utilisation de l'agent avec un magasin de vecteurs multi-sauts
La troisième méthode dans laquelle les développeurs peuvent combiner à la fois les magasins d'agents et de vecteurs concerne les requêtes de magasin de vecteurs multi-sauts. La section suivante explique le processus complet :
Étape 1 : configurer les outils
La première étape est, comme d'habitude, la configuration des outils utilisés pour créer les agents permettant d'extraire les données des magasins de données :
outils = [Outil (
nom = 'Système d'assurance qualité sur l'état de l'Union' ,
fonction = état_de_union. courir ,
description = 'Fournit des réponses aux questions liées à l'ensemble de données chargé avec une entrée sous forme de question entièrement formée, ne faisant référence à aucun pronom de la conversation précédente' ,
) ,
Outil (
nom = 'Système d'assurance qualité Ruff' ,
fonction = fraise. courir ,
description = 'Fournit des réponses aux questions liées à l'ensemble de données chargé avec une entrée sous forme de question entièrement formée, ne faisant référence à aucun pronom de la conversation précédente' ,
) ,
]
Étape 2 : initialiser et tester l'agent
Après cela, construisez la variable agent à l'aide de la méthode initialize_agent() avec le nom de l'agent :
agent = initialiser_agent (outils , llm , agent = Type d'agent. ZERO_SHOT_REACT_DESCRIPTION , verbeux = Vrai
)
Exécutez l'agent à l'aide de la question à sauts multiples qui contient plusieurs aspects ou fonctionnalités, car le bloc de code suivant contient une telle question :
agent. courir ('Quel outil Ruff utilise-t-il pour exécuter des notebooks Python et l'un des intervenants a-t-il mentionné l'outil dans son discours'
)
Sortir
La capture d'écran suivante suggère que l'agent doit résoudre la question pour comprendre sa complexité. Il a renvoyé la réponse extraite par le système d'assurance qualité des multiples magasins de données que nous avons téléchargés plus tôt dans le processus :
Il s’agit de savoir comment combiner les agents et les magasins vectoriels dans LangChain.
Conclusion
Pour combiner des agents avec les magasins de vecteurs dans LangChain, commencez par l'installation de modules pour configurer l'environnement et charger des ensembles de données. Configurez les magasins de vecteurs pour charger les données en les divisant d'abord en morceaux plus petits, puis créez le modèle de langage à l'aide de la méthode OpenAI(). Configurez l'agent pour l'intégrer au magasin de vecteurs afin d'extraire des données pour différents types de requêtes. Cet article a développé le processus de combinaison d'agents et de magasins vectoriels dans LangChain.