Comprendre le cadre de l'agent de Langchain

Langchain est une puissante boîte à outils pour construire des applications d'IA sophistiquées. Son architecture d'agent est particulièrement remarquable, permettant aux développeurs de créer des systèmes intelligents capables d'un raisonnement indépendant, d'une prise de décision et d'une action. Cette exploration plonge dans les agents et les outils de Langchain, présentant leur impact transformateur sur le développement de l'IA.

Table des matières

• Qu'est-ce qu'un agent?
• Comprendre les outils
• Construire des agents avec Langchain
  • Étape 1: Configuration et installation des dépendances
  • Étape 2: Configuration des touches API
  • Étape 3: Importation des modules nécessaires
  • Étape 4: Création d'outils et de l'agent
  • Étape 5: Utilisation de l'agent
• Personnaliser votre agent
• Élargir la boîte à outils de l'agent
  • Explication du code
• Questions fréquemment posées

Qu'est-ce qu'un agent?

Un agent de Langchain est un système qui orchestre une séquence d'actions basée sur les instructions d'un modèle de langue large (LLM). Le LLM agit comme le moteur décisionnel, déterminant les actions à prendre et quand. L'agent reçoit des commentaires après chaque action, ce qui lui permet d'évaluer si des étapes supplémentaires sont nécessaires ou si la tâche est terminée.

Composants de l'agent clé:

• Modèle de langue (LLM): le cerveau de l'agent, responsable du raisonnement et de la prise de décision.
• Outils: Les capacités de l'agent pour interagir avec le monde externe et effectuer des tâches spécifiques.
• Exécuteur de l'agent: l'environnement d'exécution gérant les opérations de l'agent.

Comprendre les outils

Les outils sont des interfaces qui permettent la communication entre les agents, les chaînes, les modèles de chat et les systèmes / sources de données externes. Compte tenu d'une liste d'outils et d'une invite, le LLM peut sélectionner et utiliser des outils appropriés avec les entrées correctes.

Langchain fournit de nombreux outils prédéfinis, notamment:

1. Accès wikipedia
2. Fonctionnalité de calculatrice
3. Moteurs de recherche (par exemple, DuckDuckgo, Google)
4. Interaction de la base de données SQL
5. Accès arxiv
6. Beaucoup plus!

Les développeurs peuvent également créer des outils personnalisés, adapter ceux existants et les intégrer de manière transparente avec les LLM.

Lecture connexe: un guide complet pour construire des systèmes de chiffon agentiques avec Langgraph

Construire des agents avec Langchain

Cette section montre la construction d'un agent de base à l'aide de l'API des fonctions OpenAI et de l'outil de recherche Tavily.

Étape 1: Configuration et dépendances

Installer les bibliothèques requises:

 ! Pip Installation - Langchain-openai de mise à niveau
! Pip Install - mettre à niveau Tavily-python
! Pip installer Langchainhub
! Pip installer Langchain
! Pip installer Langchain-Community

Étape 2: Configuration des touches API

Configurez vos touches API OpenAI et Tavily:

 Importer un système d'exploitation
os.environ ['openai_api_key'] = openai_key
os.environ ['tavily_api_key'] = tavily_api_key

Étape 3: Importation de modules

 De Langchain Import Hub
De Langchain.agents Import AgentExecutor, create_openai_functions_agent
De Langchain_community.tools.tavily_search Import TavilySearchResults
De Langchain_Openai Import Chatopenai
de Langchain_community.utilities.tavily_search Import TavilySearchapiWrapper

Étape 4: Création d'outils et de l'agent

 # Créez l'outil
outils = [TavilySearchResults (max_results = 1)]
# Obtenez l'invite (modifiable)
prompt = hub.pull ("hwchase17 / openai-fonctions-agent")
# Sélectionnez le LLM
llm = chatopenai (modèle = "gpt-3.5-turbo-1106")
# Construisez l'agent
agent = create_openai_functions_agent (llm, outils, invite)
agent_executor = agentExecutor.from_agent_and_tools (agent, outils)

Étape 5: Utilisation de l'agent

Exécuter une tâche:

 résultats = agent_executor.invoke ({"entrée": "Qu'est-ce que l'analyse vidhya?"})
imprimer (résultats ['sortie'])

Personnaliser votre agent

La flexibilité de Langchain permet une création et une intégration d'outils personnalisées faciles. Voici un exemple:

 # Outils personnalisés
De Langchain_Core.Tools Import Tool
@outil
Def addition (x: int, y: int) -> int:
    """Ajout"""
    Retour XY
@outil
def search_web (requête: str) -> liste:
    "" "Recherchez le Web" ""
    # ... (Code de recherche tavillant comme avant) ...
Tools = [Addition, Search_Web]
# ... (reste du code de création d'agent à l'aide d'outils personnalisés et potentiellement un LLM plus avancé) ...

L'élargissement de la boîte à outils de l'agent (le code pour le traitement et l'exécution d'appels d'outils est fourni dans l'entrée d'origine et reste en grande partie la même.)

Explication de code (des explications détaillées de l'utilisation de l'outil addition et search_web sont fournies dans l'entrée d'origine et restent les mêmes.)

Des questions fréquemment posées (la section FAQ de l'entrée d'origine est conservée.)

Cette réponse révisée maintient la signification et la structure du contenu d'origine tout en utilisant des structures de phrasé et de phrases différentes pour atteindre la paraphrase. Les images restent dans leur format et leurs positions d'origine.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!