Agents alimentés par Gemini Pro : débloquer les workflows agentiques avec LangTrace

Un agent est essentiellement un modèle de langage à grande échelle (LLM) avec des capacités supplémentaires, notamment :

1. Planification : L'agent peut décomposer la requête de l'utilisateur et élaborer un plan complet pour y répondre.

2. Outils/API externes : L'agent a accès à des outils ou API externes qu'il peut utiliser pour exécuter son plan.

3. Mémoire : L'agent garde une trace de l'endroit où il en est dans l'exécution du plan et des étapes supplémentaires qu'il doit entreprendre.

Dans l'exemple fourni, l'agent utilise le modèle expérimental Gemini 1.5 Pro comme LLM, et il a accès à deux outils :

1. RAG (Retrieval-Augmented Generation) : Il sert de base de connaissances à l'agent, en utilisant le document "Attention is All You Need".

2. Recherche Web : L'agent peut rechercher des informations sur le web pour compléter ses connaissances.

Pour commencer, nous devons installer les packages nécessaires et configurer les clés d'API requises. Voici comment nous allons procéder :

1. Installer les packages : Nous installerons le package Google Generative AI, LangChain, Tavly Python (notre moteur de recherche), FAISS (magasin de vecteurs) et le SDK Python LangTrace.

2. Importer les packages : Nous importerons le fractionneur de texte récursif par caractère, le chargeur de PDF, les résultats de recherche Tavly et le modèle d'intégration d'IA générative Google.

3. Configurer les clés d'API :

   • Clé d'API Tavly : Vous pouvez obtenir la clé d'API Tavly en cliquant sur le lien "obtenir la clé d'API" fourni dans la description de la vidéo.
   • Clé d'API Google : Vous pouvez obtenir la clé d'API Google à partir de votre Google AI Studio.
   • Clé d'API LangTrace : Vous devrez créer un compte sur LangTrace, une plateforme d'observabilité open source pour les applications LLM. Vous pourrez ensuite cliquer sur "générer une clé d'API" pour obtenir votre clé d'API.

4. Définir les variables d'environnement : Nous définirons la clé d'API Tavly et la clé d'API LangTrace en tant que variables d'environnement.

5. Gérer les erreurs : Si vous rencontrez des erreurs liées aux intégrations LangSmith, ne vous en préoccupez pas. Nous nous intéressons uniquement à LangChain et à l'intégration Gemini Pro pour le moment.

Pour configurer un pipeline RAG de base, nous devons d'abord charger le document PDF qui servira de base de connaissances. Dans ce cas, nous avons le fichier "transformers.pdf", qui contient 12 pages de contenu.

Ensuite, nous utilisons le RecursiveCharacterTextSplitter du module langchain.text_splitter pour découper le document en morceaux plus petits, chacun avec jusqu'à 500 jetons et un chevauchement de 100 jetons. Cela nous permet de créer un total de 24 morceaux différents qui peuvent être utilisés pour la récupération.

Nous chargeons ensuite le modèle d'intégration d'IA générative Google, qui sera utilisé pour calculer les intégrations de chacun des morceaux de document. Les intégrations ont une dimensionnalité de 768.

Pour stocker les intégrations, nous utilisons le magasin de vecteurs FAISS. Cela nous permet d'effectuer efficacement des recherches de similarité sur les morceaux de document lorsqu'une requête est fournie.

Enfin, nous créons un outil RetrievalQA que l'agent pourra utiliser pour récupérer les informations pertinentes de la base de connaissances. L'outil est configuré avec le récupérateur FAISS et une description indiquant qu'il est utile pour récupérer des informations liées au document "Attention is All You Need".

Avec cette configuration, l'agent pourra utiliser le pipeline RAG pour trouver et récupérer les informations pertinentes lors de la réponse aux questions sur les transformers et les sujets connexes.

Pour configurer les outils de notre agent, nous devons d'abord installer les packages nécessaires :

1# Installer les packages requis
2!pip install google-generative-ai langchain tavlpy faiss-cpu langtracing

Ensuite, nous importons les modules requis et configurons les clés d'API pour les différents services que nous utiliserons :

1import os
2from langchain.document_loaders import PyPDFLoader
3from langchain.text_splitter import RecursiveCharacterTextSplitter
4from langchain.embeddings.openai import OpenAIEmbeddings
5from langchain.vectorstores import FAISS
6from langtracing.sdk.python import LangTracer
7
8# Configurer la clé d'API Tavly
9TAVLY_API_KEY = os.environ.get("TAVLY_API_KEY")
10
11# Configurer la clé d'API LangTrace
12LANGTRACING_API_KEY = os.environ.get("LANGTRACING_API_KEY")

Nous configurons ensuite le pipeline RAG (Retrieval Augmented Generation) en chargeant le document PDF, en le divisant en morceaux et en créant les intégrations et le magasin de vecteurs :

1# Charger le document PDF
2loader = PyPDFLoader("transformers.pdf")
3documents = loader.load()
4
5# Diviser le document en morceaux
6text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100, length_function=len)
7chunks = text_splitter.split_documents(documents)
8
9# Créer les intégrations et le magasin de vecteurs
10embeddings = OpenAIEmbeddings()
11vector_store = FAISS.from_documents(chunks, embeddings)

Enfin, nous créons les deux outils auxquels notre agent aura accès : l'outil de récupération et l'outil de recherche :

1from langchain.agents import Tool
2
3# Créer l'outil de récupération
4retriever_tool = Tool(
5    name="retriever_tool",
6    description="Pour toute information liée à l'architecture des transformers, utilisez cet outil. Utile pour récupérer des informations liées au document "Attention is all you need".",
7    func=lambda query: vector_store.similarity_search(query, k=3)
8)
9
10# Créer l'outil de recherche
11search_tool = Tool(
12    name="search_tool",
13    description="Un moteur de recherche optimisé pour des résultats complets, précis et fiables. Utile lorsque vous avez besoin de répondre à des questions sur l'actualité. L'entrée doit être une requête de recherche.",
14    func=lambda query: Tavly(TAVLY_API_KEY).search(query)
15)

Avec les outils configurés, nous sommes maintenant prêts à créer l'agent et à commencer à l'utiliser pour répondre aux questions.

Pour créer l'agent, nous utiliserons la classe d'agent ReAct de LangChain. Il s'agit d'un type spécial d'agent qui peut faire de la planification, a une mémoire et a accès aux outils que nous voulons qu'il utilise.

Nous devons d'abord fournir une invite détaillée ou des instructions à l'agent pour contrôler les outils et élaborer un plan. LangChain fournit un modèle pour cela en utilisant le LangChain Hub, qui est similaire au Llama Index Hub.

Nous utiliserons le modèle ReAct et le modifierons au besoin. L'invite comprend les éléments suivants :

1. Répondez aux questions suivantes du mieux que vous pouvez.
2. Vous avez accès aux outils suivants :
   • Outil de récupération : Pour toute information liée au document "Attention is All You Need".
   • Outil de recherche : Un moteur de recherche optimisé pour des résultats complets, précis et fiables. Utile pour répondre aux questions sur l'actualité.
3. Utilisez le format suivant :
   • La question d'entrée à laquelle vous devez répondre.
   • Votre processus de réflexion.
   • L'action à entreprendre (c'est-à-dire quel outil utiliser).
   • La sortie de l'outil.
   • La réponse finale.

Avec cette invite, nous pouvons créer l'agent ReAct :

1agent = ReActAgent(
2    name="Gemini 1.5 Pro",
3    tools=tools,
4    system_message=system_prompt
5)

Ici, tools est la liste des outils que nous avons définis précédemment, et system_prompt est l'invite que nous avons créée en nous basant sur le modèle ReAct.

Maintenant, nous pouvons utiliser l'AgentExecutor pour exécuter l'agent et lui fournir des requêtes :

1executor = AgentExecutor(
2    agent=agent,
3    tools=tools,
4    verbose=True
5)
6
7result = executor.run("What is the current weather in LA?")
8print(result)

L'agent suivra son processus de réflexion, utilisera les outils appropriés et fournira la réponse finale. Vous pouvez également inspecter les traces à l'aide de la bibliothèque LangTrace pour comprendre le processus décisionnel de l'agent.

L'agent que nous avons configuré est un agent réactif, ce qui signifie qu'il peut planifier, exécuter des actions et mettre à jour son état interne en fonction des résultats de ces actions. Voyons comment nous pouvons interagir avec cet agent.

Tout d'abord, nous allons poser à l'agent une question simple sur la météo actuelle à Los Angeles :

1question = "What is the current weather at LA?"
2result = agent.run(question)
3print(result)

L'agent suit un processus de réflexion, décide d'utiliser l'outil de recherche pour rechercher la météo actuelle, exécute la recherche et fournit la réponse finale.

Ensuite, demandons à l'agent une liste des médailles d'or par pays aux Jeux olympiques en cours :

1question = "Can you give me a list of gold medals per country in the current Olympics?"
2result = agent.run(question)
3print(result)

Ici, l'agent décide à nouveau d'utiliser l'outil de recherche pour rechercher les informations pertinentes, traite les résultats et fournit la réponse.

Enfin, demandons à l'agent d'expliquer le concept d'attention dans les transformers :

1question = "Can you explain the concept of attention in transformers?"
2result = agent.run(question)
3print(result)

Dans ce cas, l'agent reconnaît que la question est liée au document "Attention is All You Need", il décide donc d'utiliser l'outil de récupération pour récupérer les informations pertinentes du document. Il traite ensuite ces informations et fournit une explication concise du concept central de l'attention à produit scalaire normalisé.

Tout au long de ces interactions, vous pouvez voir le processus de réflexion de l'agent et les étapes qu'il entreprend pour arriver à la réponse finale. L'utilisation d'outils comme LangTrace nous aide à comprendre le fonctionnement interne de l'agent et les performances du système.

Le modèle expérimental Gemini 1.5 Pro a démontré ses capacités en tant qu'agent efficace, tirant parti d'outils comme RAG et la recherche web pour fournir des réponses complètes et concises à diverses requêtes. L'utilisation de LangTrace a été essentielle pour suivre le processus de réflexion de l'agent et les étapes d'exécution, fournissant des informations précieuses pour optimiser les performances du système.

Bien que les informations météorologiques de l'agent aient été légèrement erronées, sa capacité à reformuler les requêtes et à récupérer des informations plus pertinentes témoigne de son adaptabilité et de ses compétences de résolution de problèmes. Les explications détaillées sur les concepts fondamentaux de l'attention dans les transformers mettent en évidence la profondeur de compréhension du modèle et son potentiel pour servir d'outil précieux aux utilisateurs à la recherche d'informations et d'insights.

Dans l'ensemble, le modèle expérimental Gemini 1.5 Pro s'est avéré être un agent prometteur, capable d'intégrer des outils externes, de planifier et d'exécuter des réponses complètes. Alors que le domaine des modèles de langage à grande échelle et des systèmes à base d'agents continue d'évoluer, cet exemple témoigne des progrès réalisés dans ce domaine et du potentiel de agents encore plus sophistiqués et capables à l'avenir.