Comment utiliser les agents LangChain pour des tâches automatisées puissantes

Name

Lynn Mikami

Published on 30/04/2024

Dans le monde fascinant des modèles linguistiques et de l'automatisation, les agents LangChain se distinguent comme un phare de l'innovation, permettant aux développeurs et aux passionnés de technologie de créer des tâches automatisées sophistiquées qui semblent tout droit sorties d'un roman de science-fiction. Si vous souhaitez plonger dans le monde des agents LangChain mais ne savez pas par où commencer, vous êtes au bon endroit. Ce guide démystifiera le processus, le rendant accessible et simple. Alors, prenez une tasse de café et embarquons ensemble pour ce voyage passionnant.

Comment utiliser les agents LangChain : Démarrage rapide

Pour mieux comprendre le cadre de l'agent, créons un agent qui possède deux outils : un pour rechercher des informations en ligne et un pour rechercher des données spécifiques que nous avons chargées dans un index.

Cela suppose une connaissance des modèles linguistiques massifs et de la recherche. Si vous n'avez pas encore exploré ces sections, il est recommandé de le faire.

Configuration : LangSmith
Par définition, les agents effectuent une séquence d'étapes auto-déterminées et dépendantes de l'entrée avant de renvoyer une sortie visible par l'utilisateur. Cela rend le débogage de ces systèmes particulièrement délicat et l'observabilité particulièrement importante. LangSmith est particulièrement utile dans ces cas.

Lors de la construction avec LangChain, toutes les étapes seront automatiquement tracées dans LangSmith. Pour configurer LangSmith, nous devons simplement définir les variables d'environnement suivantes :

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="<votre-clé-d'API>"

Définition des outils
Nous devons d'abord créer les outils que nous voulons utiliser. Nous utiliserons deux outils : Tavily (pour rechercher en ligne) et ensuite un extracteur sur un index local que nous créerons.

• Tavily
  Nous disposons d'un outil intégré à LangChain pour utiliser facilement le moteur de recherche Tavily comme outil. Veuillez noter que cela nécessite une clé d'API - ils proposent un niveau d'abonnement gratuit, mais si vous n'en avez pas ou si vous ne souhaitez pas en créer une, vous pouvez tout simplement ignorer cette étape.

Une fois que vous avez créé votre clé d'API, vous devrez l'exporter comme ceci :

export TAVILY_API_KEY="..."

from langchain_community.tools.tavily_search import TavilySearchResults
 
search = TavilySearchResults()
 
search.invoke("quel temps fait-il à San Francisco")

• Extracteur
  Nous allons également créer un extracteur sur certaines de nos propres données. Pour une explication plus détaillée de chaque étape ici, consultez cette section.

from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
 
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
 
retriever.get_relevant_documents("comment télécharger un ensemble de données")[0]

Maintenant que nous avons peuplé notre index sur lequel nous effectuerons une recherche, nous pouvons facilement le convertir en un outil (au format requis pour qu'un agent puisse l'utiliser correctement).

from langchain.tools.retriever import create_retriever_tool
 
retriever_tool = create_retriever_tool(
    retriever,
    "recherche_langsmith",
    "Rechercher des informations sur LangSmith. Pour toute question sur LangSmith, vous devez utiliser cet outil !",
)

Outils
Maintenant que nous les avons créés tous les deux, nous pouvons créer une liste d'outils que nous utiliserons par la suite.

tools = [search, retriever_tool]

Comment créer un agent LangChain

Maintenant que nous avons défini les outils, nous pouvons créer l'agent. Nous utiliserons un agent OpenAI Functions - pour plus d'informations sur ce type d'agent, ainsi que d'autres options, consultez ce guide.

Tout d'abord, nous choisissons le modèle LLM que nous voulons utiliser pour guider l'agent.

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

Ensuite, nous choisissons le prompt que nous voulons utiliser pour guider l'agent.

from langchain import hub
 
# Obtenez le prompt à utiliser - vous pouvez le modifier !
prompt = hub.pull("hwchase17/openai-functions-agent")
prompt.messages

Maintenant, nous pouvons initialiser l'agent avec le LLM, le prompt et les outils. L'agent est responsable de la réception des entrées et de la décision des actions à prendre. Importante, l'Agent n'exécute pas ces actions - cela est fait par l'AgentExecutor (étape suivante). Pour plus d'informations sur la façon de penser à ces composants, consultez notre guide conceptuel.

from langchain.agents import create_openai_functions_agent
 
agent = create_openai_functions_agent(llm, tools, prompt)

Enfin, nous combinons l'agent (le cerveau) avec les outils à l'intérieur de l'AgentExecutor (qui appellera et exécutera à plusieurs reprises l'agent et les outils). Pour plus d'informations sur la façon de penser à ces composants, consultez notre guide conceptuel.

from langchain.agents import AgentExecutor
 
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Exécution de l'agent
Nous pouvons maintenant exécuter l'agent sur quelques requêtes ! Notez que pour le moment, ce sont toutes des requêtes sans état (il ne se souviendra pas des interactions précédentes).

agent_executor.invoke({"input": "salut !"})

agent_executor.invoke({"input": "comment langsmith peut-il aider pour les tests ?"})

agent_executor.invoke({"input": "quel temps fait-il à San Francisco ?"})

Ajout de la mémoire Comme mentionné précédemment, cet agent est sans état. Cela signifie qu'il ne se souvient pas des interactions précédentes. Pour lui donner une mémoire, nous devons lui transmettre l'historique du chat précédent. Note : il doit être appelé chat_history en raison de la proposition que nous utilisons. Si nous utilisons une autre proposition, nous pourrions changer le nom de la variable.

# Ici, nous transmettons une liste vide de messages pour chat_history car c'est le premier message dans le chat
agent_executor.invoke({"input": "Salut ! Je m'appelle Bob", "chat_history": []})

from langchain_core.messages import AIMessage, HumanMessage
 
agent_executor.invoke(
    {
        "chat_history": [
            HumanMessage(content="Salut ! Je m'appelle Bob"),
            AIMessage(content="Bonjour Bob ! Comment puis-je t'aider aujourd'hui ?"),
        ],
        "input": "Quel est mon nom ?",
    }
)

Si nous voulons suivre automatiquement ces messages, nous pouvons les envelopper dans un RunnableWithMessageHistory. Pour plus d'informations sur la façon d'utiliser cela, consultez ce guide.

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
 
message_history = ChatMessageHistory()
 
agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    # Ceci est nécessaire car dans la plupart des scénarios du monde réel, un identifiant de session est nécessaire
    # Il n'est pas vraiment utilisé ici car nous utilisons une simple ChatMessageHistory en mémoire
    lambda session_id: message_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)
 
agent_with_chat_history.invoke(
    {"input": "Salut ! Je suis Bob"},
    # Ceci est nécessaire car dans la plupart des scénarios du monde réel, un identifiant de session est nécessaire
    # Il n'est pas vraiment utilisé ici car nous utilisons une simple ChatMessageHistory en mémoire
    config={"configurable": {"session_id": "<foo>"}},
)

Types d'agents LangChain

Types d'agents

Dans le domaine des agents LangChain, la diversité est le mot d'ordre. Ces agents se déclinent en plusieurs variantes, chacune adaptée à des tâches et à des capacités différentes. Explorons le monde nuancé des types d'agents, en décomposant leurs modèles prévus, leur prise en charge de l'historique du chat, des outils à plusieurs entrées, des appels de fonctions parallèles et des paramètres de modèle requis. Comprendre ces catégories vous aidera à choisir l'agent parfait pour vos besoins.

• Outils OpenAI : Un agent de pointe optimisé pour les modèles OpenAI récents (à partir de 1106). Il est conçu pour gérer les interactions de chat, prendre en charge les outils à plusieurs entrées et exécuter des appels de fonctions parallèles, nécessitant les paramètres du modèle 'tools'. Idéal pour ceux qui utilisent les dernières offres d'OpenAI.

• Fonctions OpenAI : Adapté aux modèles OpenAI ou open-source fins qui imitent les capacités d'appel de fonctions d'OpenAI. Il excelle dans les environnements de chat, gère les outils à plusieurs entrées et nécessite les paramètres du modèle 'functions'. Un choix solide pour les modèles adeptes de l'appel de fonctions.

• XML : Cet agent convient aux modèles spécialisés dans XML, tels que ceux d'Anthropic. Il est conçu pour les LLM (non les modèles de chat), prend en charge l'historique du chat et est idéal pour les outils non structurés nécessitant une seule entrée sous forme de chaîne. Choisissez-le lorsque vous travaillez avec des modèles compétents en XML.

• Chat structuré : Un agent polyvalent qui brille dans les applications basées sur le chat et prend en charge les outils avec plusieurs entrées. Il n'a pas besoin de paramètres supplémentaires du modèle, ce qui en fait une excellente option pour les projets nécessitant des interactions d'outils complexes.

• Chat JSON : Adapté aux modèles qui excellent dans JSON, cet agent convient aux applications de chat. Il facilite le travail avec des modèles compatibles avec JSON, simplifiant le développement d'applications basées sur le chat.

• ReAct : Simpliste mais efficace, cet agent est conçu pour les applications LLM basiques. C'est un excellent point de départ pour les modèles simples nécessitant une mise en œuvre directe.

• Auto-questions avec recherche : Idéal pour les modèles simples avec un seul outil de recherche, cet agent est parfait pour les projets nécessitant un ensemble d'outils concis et ciblé.

Chaque type d'agent apporte son propre ensemble de forces, il est donc essentiel de faire correspondre l'agent aux exigences spécifiques de votre projet. Que vous ayez besoin du support de l'historique du chat, d'outils à plusieurs entrées ou d'appels de fonctions parallèles, il y a un agent adapté pour répondre à ces besoins. Tenez compte de la complexité de vos tâches, des capacités du modèle linguistique choisi et de la nature des interactions que votre application gérera. En alignant ces facteurs avec le bon type d'agent, vous pourrez exploiter tout le potentiel des agents LangChain dans vos projets, ouvrant la voie à des solutions novatrices et à des flux de travail rationalisés.

Approfondissant les subtilités des agents LangChain, ce guide vise à fournir une compréhension approfondie et des applications pratiques des différents types d'agents. En explorant des exemples de codes et de scénarios détaillés, vous acquerrez des connaissances sur la sélection et la mise en œuvre de l'agent le plus adapté aux besoins de votre projet. Plongeons au cœur des agents LangChain, en mettant en évidence leurs caractéristiques et leurs capacités uniques à travers des exemples.

Agents LangChain n°1 : Agent Outils OpenAI

L'agent Outils OpenAI est conçu pour fonctionner de manière transparente avec les modèles OpenAI les plus récents, facilitant l'exécution de plusieurs fonctions ou "outils" simultanément. Cet agent est particulièrement utile lorsque votre application nécessite d'interagir avec plusieurs API externes ou d'effectuer plusieurs tâches en parallèle, réduisant ainsi le temps de traitement global.

Code d'exemple :

# Importer les bibliothèques et les outils nécessaires
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
 
# Initialiser l'outil de recherche Tavily
outils = [TavilySearchResults(max_results=1)]
 
# Récupérer la proposition et configurer le LLM
proposition = hub.pull("hwchase17/agent-outils-openai")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0)
 
# Créer l'agent Outils OpenAI
agent_outils_openai = create_openai_tools_agent(
    agent=AgentExecutor(llm),
    proposition=proposition,
    outils=outils,
)
 
agent = create_openai_tools_agent(llm, tools, prompt)
 
# Exécutez l'agent avec une entrée d'exemple
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "qu'est-ce que LangChain?"})
print(response)

Dans cet exemple, la fonction create_openai_tools_agent construit un agent capable d'utiliser le modèle OpenAI pour décider intelligemment quand invoquer un ou plusieurs outils en fonction de l'entrée. L'outil Tavily Search est utilisé ici pour démontrer les capacités de recherche sur le web.

Agents LangChain n°2 : Agent OpenAI Functions

L'agent OpenAI Functions est le plus adapté pour les tâches où le modèle doit décider s'il faut appeler une fonction et laquelle en fonction de l'entrée. Bien qu'il soit similaire à l'agent Tools, il est spécialement conçu pour les scénarios où l'appel de fonctions est central à la tâche, OpenAI ayant déconseillé cette approche au profit des outils pour les modèles plus récents.

Code d'exemple :

# Configuration de l'agent OpenAI Functions
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
 
# Initialisation des outils et choix de LLM
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106")
 
# Construction et exécution de l'agent OpenAI Functions
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "qu'est-ce que LangChain?"})
print(response)

Cet exemple met en évidence comment configurer et utiliser l'agent OpenAI Functions, en utilisant Tavily Search comme outil pour démontrer la capacité de l'agent à invoquer des fonctions spécifiques en fonction des requêtes des utilisateurs.

Agents LangChain n°3 : Agent XML

L'agent XML est optimisé pour les modèles qui sont compétents dans la génération et l'interprétation de structures XML. Ce type d'agent est avantageux lorsqu'il s'agit de travailler avec des données structurées ou lorsque l'interaction avec le modèle bénéficie du format structuré de XML.

Code d'exemple :

# Initialisation de l'agent XML
from langchain import hub
from langchain.agents import AgentExecutor, create_xml_agent
from langchain_community.chat_models import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
 
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/xml-agent-convo")
llm = ChatAnthropic(model="claude-2")
 
# Création et exécution de l'agent XML
agent = create_xml_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "qu'est-ce que LangChain?"})
print(response)

Cette configuration met en avant l'utilisation d'un agent XML avec Claude-2, un modèle Anthropic connu pour sa compétence avec XML. Le format XML offre une manière structurée de communiquer entre l'agent et le modèle, facilitant la manipulation de données complexes.

Agents LangChain n°4 : Agent Chat JSON

L'agent Chat JSON utilise le format JSON pour ses sorties, ce qui le rend adapté aux applications nécessitant des données de réponse structurées. Cet agent est idéal pour les modèles de chat qui excellent dans le traitement et la génération de structures JSON.

Code d'exemple :

# Configuration de l'agent Chat JSON
from langchain import hub
from langchain.agents import AgentExecutor, create_json_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
 
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/react-chat-json")
llm = ChatOpenAI()
 
# Création et exécution de l'agent Chat JSON
agent = create_json_chat_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
response = agent_executor.invoke({"input": "qu'est-ce que LangChain?"})
print(response)

Ici, l'agent Chat JSON est utilisé pour traiter une entrée et générer une réponse structurée en JSON, en utilisant l'outil Tavily Search pour des capacités de recherche sur le web. Cet agent est particulièrement utile dans les scénarios où une réponse structurée est requise pour un traitement ultérieur ou pour une interaction plus structurée avec l'utilisateur.

Agents LangChain n°5 : Agent Chat Structuré

L'Agent Chat Structuré excelle dans les scénarios qui impliquent des outils multi-entrées, permettant des interactions complexes qui nécessitent plus qu'une simple chaîne de caractères en entrée. Cet agent est conçu pour faciliter des flux de travail complexes où plusieurs paramètres doivent être pris en compte pour chaque invocation d'outil.

Code d'exemple :

# Initialisation de l'Agent Chat Structuré
from langchain import hub
from langchain.agents import AgentExecutor, create_structured_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
 
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/structured-chat-agent")
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")
 
# Construction et exécution de l'Agent Chat Structuré
agent = create_structured_chat_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
response = agent_executor.invoke({"input": "qu'est-ce que LangChain?"})
print(response)

Cet exemple illustre l'utilisation d'un Agent Chat Structuré pour interagir efficacement avec des outils multi-entrées. En spécifiant une instruction détaillée et en sélectionnant un modèle de langue approprié, cet agent peut gérer de manière transparente des requêtes et des interactions complexes avec les outils. En comprenant les distinctions et les capacités de ces agents LangChain, les développeurs peuvent adapter au mieux leurs applications pour exploiter pleinement le potentiel des modèles de langage et des tâches automatisées. Que votre application nécessite des appels de fonction simples, le traitement de données structurées ou des interactions complexes avec plusieurs outils, il existe un agent LangChain adapté à vos besoins. Avec ces exemples comme base, vous êtes bien équipé pour entreprendre la construction d'applications plus intelligentes, plus efficaces et plus réactives.

Conclusion

En conclusion, les agents LangChain offrent une boîte à outils polyvalente et puissante aux développeurs qui souhaitent intégrer des fonctionnalités avancées de modèle de langage dans leurs applications. En comprenant les subtilités de chaque type d'agent - des agents Outils et Fonctions OpenAI aux agents XML, JSON Chat et Structured Chat - vous pouvez choisir le bon outil pour les besoins spécifiques de votre projet. Ces agents peuvent gérer un large éventail de tâches, des appels de fonction simples aux interactions complexes impliquant plusieurs entrées et formats de données structurées.