Aperçu rapide
Cet article démontrera ce qui suit :
Que sont les agents dans le traitement du langage naturel (PNL)
Premiers pas avec les agents dans LangChain
- Installation de frameworks
- Configurer le modèle de discussion
- Agent de construction
- Appel de l'agent
- Configurer les outils d'agent
- Test de l'agent
Que sont les agents de traitement du langage naturel (PNL) ?
Les agents sont les composants essentiels de l'application en langage naturel et ils utilisent la compréhension du langage naturel (NLU) pour comprendre les requêtes. Ces agents sont des programmes qui agissent comme un modèle conversationnel pour interagir avec des humains en utilisant la séquence de tâches. Les agents utilisent plusieurs outils qui peuvent être appelés par l'agent pour effectuer plusieurs actions ou spécifier la prochaine tâche à effectuer.
Premiers pas avec les agents dans LangChain
Démarrez le processus de création des agents pour avoir une conversation avec des humains en extrayant le résultat à l'aide des agents dans LangChain. Pour découvrir le processus de démarrage avec les agents dans LangChain, suivez simplement les étapes répertoriées ci-dessous :
Étape 1 : Installation des frameworks
Tout d’abord, commencez par le processus d’installation du framework LangChain à l’aide du « pépin ' pour obtenir les dépendances requises pour l'utilisation des agents :
pip installer langchain 
Installez le module OpenAI pour créer le LLM et utilisez-le pour configurer les agents dans LangChain :
pip installer openai 
Configurer l'environnement pour le module OpenAI en utilisant sa clé API depuis le compte en exécutant le code suivant :
importer toiimporter obtenir un laissez-passer
toi . environ [ 'OPENAI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API OpenAI : » )
Étape 2 : Configurer le modèle de discussion
Importez le module ChatOpenAI depuis LangChain pour construire le LLM en utilisant sa fonction :
depuis chaîne de langage. chat_models importer ChatOpenAIllm = ChatOpenAI ( température = 0 )
Importez des outils permettant à l'agent de configurer les tâches ou les actions qui doivent être effectuées par l'agent. Le code suivant utilise la méthode get_word_length() pour obtenir la longueur du mot fourni par l'utilisateur :
depuis chaîne de langage. agents importer outil@ outil
déf get_word_length ( mot: str ) - > int :
'''obtenir la longueur du mot'''
retour seulement ( mot )
outils = [ get_word_length ]
Configurez le modèle ou la structure du modèle de discussion pour créer une interface permettant de discuter :
depuis chaîne de langue. instructions importer Modèle d'invite de chat , MessagesPlaceholderrapide = Modèle d'invite de chat. from_messages ( [
( 'système' , 'Votre assistant est assez étonnant, mais il a besoin d'être amélioré dans le calcul des longueurs' ) ,
( 'utilisateur' , '{saisir}' ) ,
MessagesPlaceholder ( Nom de variable = 'agent_scratchpad' ) ,
] )
Étape 3 : Agent de construction
Importez la bibliothèque d'outils pour construire le LLM avec des outils utilisant les fonctions OpenAI du module LangChain :
depuis chaîne de langage. outils . rendre importer format_tool_to_openai_functionllm_with_tools = llm. lier (
les fonctions = [ format_tool_to_openai_function ( t ) pour t dans outils ]
)
Configurez l'agent à l'aide de l'agent de fonction OpenAI pour utiliser l'analyseur de sortie afin de définir les séquences d'actions/tâches :
depuis chaîne de langue. agents . format_scratchpad importer format_to_openai_functionsdepuis chaîne de langue. agents . analyseurs_de sortie importer OpenAIFunctionsAgentOutputParser
agent = {
'saisir' : lambda x: x [ 'saisir' ] ,
'agent_scratchpad' : lambda x : format_to_openai_functions ( X [ 'étapes_intermédiaires' ] )
} | invite | llm_with_tools | OpenAIFunctionsAgentOutputParser ( )
Étape 4 : Appel de l'agent
L'étape suivante utilise la fonction Invoke() pour appeler l'agent à l'aide des arguments input et Intermediate_steps :
agent. invoquer ( {'saisir' : 'combien de lettres dans le mot bon' ,
'étapes_intermédiaires' : [ ]
} )
Étape 5 : Configurer les outils d'agent
Après cela, importez simplement la bibliothèque AgentFinish pour configurer les étapes_intermédiaires en intégrant toutes les étapes dans une séquence pour terminer l'activité :
depuis chaîne de langage. schéma . agent importer Fin de l'agentétapes_intermédiaires = [ ]
alors que Vrai :
sortir = agent. invoquer ( {
'saisir' : 'lettres en bien' ,
'étapes_intermédiaires' : étapes_intermédiaires
} )
si est une instance ( sortir , Fin de l'agent ) :
résultat final = sortir. valeurs_de retour [ 'sortir' ]
casser
autre :
imprimer ( sortir. outil , sortir. entrée_outil )
outil = {
'get_word_length' : get_word_length
} [ sortir. outil ]
observation = outil. courir ( sortir. entrée_outil )
étapes_intermédiaires. ajouter ( ( sortir , observation ) )
imprimer ( résultat final )
Étape 6 : tester l'agent
Maintenant, exécutez l'agent en appelant la méthode AgentExecutor() après avoir importé sa bibliothèque depuis LangChain :
depuis chaîne de langage. agents importer AgentExécuteuragent_exécuteur = AgentExécuteur ( agent = agent , outils = outils , verbeux = Vrai )
À la fin, appelez agent_executor avec l'argument d'entrée pour saisir la requête pour l'agent :
agent_exécuteur. invoquer ( { 'saisir' : 'combien de lettres dans le mot bon' } )L'agent a affiché la réponse à la question fournie dans l'argument d'entrée après avoir terminé la chaîne :
Il s’agit de démarrer avec les agents du framework LangChain.
Conclusion
Pour démarrer avec les agents dans LangChain, installez simplement les modules requis pour configurer l'environnement à l'aide de la clé API OpenAI. Après cela, configurez le modèle de discussion en définissant le modèle d'invite pour créer l'agent avec la séquence d'étapes intermédiaires. Une fois l'agent configuré, créez simplement les outils en spécifiant les tâches après avoir donné la chaîne d'entrée à l'utilisateur. Ce blog a démontré le processus d'utilisation des agents dans LangChain.