#
Création d’un RAG pour converser avec les invités

Alfred, votre agent de confiance, se prépare pour le gala le plus extravagant du siècle. Pour s’assurer que l’événement se déroule sans encombre, il a besoin d’un accès rapide à des informations à jour sur chaque invité. Aidons le en créant un outil RAG alimenté par notre jeu de données personnalisé.

##
Pourquoi un RAG pour un gala ?

Imaginez Alfred se mêlant aux invités, ayant besoin de se rappeler des détails spécifiques sur chaque personne à tout moment. Un LLM traditionnel pourrait avoir du mal avec cette tâche parce que :

1. La liste des invités est spécifique à votre événement et ne fait pas partie des données d’entraînement du modèle
2. Les informations sur les invités peuvent changer ou être mises à jour fréquemment
3. Alfred doit récupérer des détails précis comme les adresses email

C’est là que le RAG brille ! En combinant un système de récupération avec un LLM, Alfred peut accéder à des informations précises et à jour sur vos invités à la demande.

Vous pouvez choisir n’importe lequel des frameworks couverts dans le cours pour ce cas d’usage. Sélectionnez votre option préférée dans les onglets de code.

##
Configuration de notre application

Dans cette unité, nous développerons notre agent au sein d’un Space, sous la forme d’un projet Python structuré. Cette approche nous aide à maintenir un code propre et modulaire en organisant différentes fonctionnalités dans des fichiers séparés. De plus, cela permet un cas d’usage plus réaliste où vous déploieriez l’application pour une utilisation publique.

###
Structure du projet

- `tools.py` – Fournit des outils auxiliaires pour l’agent.
- `retriever.py` – Implémente les fonctions de récupération pour soutenir l’accès à la connaissance.
- `app.py` – Intègre tous les composants dans un agent entièrement fonctionnel, que nous finaliserons dans la dernière partie de cette unité.

Pour une référence pratique, consultez ce Space sur un RAG agentique. N’hésitez pas à le cloner et à expérimenter !

Vous pouvez tester directement l’agent ci-dessous :

##
Aperçu du jeu de données

Notre jeu de données `agents-course/unit3-invitees` contient les champs suivants pour chaque invité :

- Name : Nom complet de l’invité
- Relation : Comment l’invité est lié à l’hôte
- Description : Une brève biographie ou des faits intéressants sur l’invité
- Email Address : Informations de contact pour envoyer des invitations ou des suivis

Voici un aperçu du jeu de données :

Dans un scénario réel, ce jeu de données pourrait être étendu pour inclure les préférences alimentaires, les intérêts pour les cadeaux, les sujets de conversation à éviter, et d'autres détails utiles pour un hôte.

##
Construction d’un outil pour un livre d’or

Nous allons créer un outil personnalisé qu’Alfred peut utiliser pour récupérer rapidement les informations sur les invités pendant le gala. Décomposons cela en trois étapes gérables :

1. Charger et préparer le jeu de données
2. Créer l’outil de récupération
3. Intégrer l’outil à Alfred

Commençons par charger et préparer le jeu de données !

###
Étape 1 : Charger et préparer le jeu de données

Tout d’abord, nous devons transformer nos données brutes sur les invités en un format optimisé pour la récupération.

smolagents
llama-index
langgraph

Nous utiliserons la bibliothèque `datasets` d’Hugging Face pour charger le jeu de données et le convertir en une liste d’objets `Document` du module `langchain.docstore.document`.

    import datasets
    from langchain_core.documents import Document

    # Charger le jeu de données
    guest_dataset = datasets.load_dataset("agents-course/unit3-invitees", split="train")

    # Convertir les entrées du jeu de données en objets Document
    docs = [
        Document(
            page_content="\n".join([
                f"Name: {guest['name']}",
                f"Relation: {guest['relation']}",
                f"Description: {guest['description']}",
                f"Email: {guest['email']}"
            ]),
            metadata={"name": guest["name"]}
        )
        for guest in guest_dataset
    ]

Dans le code ci-dessus, nous :

- Chargeons le jeu de données
- Convertissons chaque entrée d’invité en un objet `Document` avec du contenu formaté
- Stockons les objets `Document` dans une liste

Cela signifie que nous avons toutes nos données bien disponibles pour pouvoir commencer à configurer notre récupération.

###
Étape 2 : Créer l’outil de récupération

Maintenant, créons un outil personnalisé qu’Alfred peut utiliser pour rechercher dans nos informations sur les invités.

smolagents
llama-index
langgraph

Nous utiliserons le `BM25Retriever` du module `langchain_community.retrievers` pour créer un outil de récupération.

Le `BM25Retriever` est un excellent point de départ pour la récupération, mais pour une recherche sémantique plus avancée, vous pourriez considérer l'utilisation de récupérateurs basés sur des embeddings comme ceux de sentence-transformers.

    from smolagents import Tool
    from langchain_community.retrievers import BM25Retriever

    class GuestInfoRetrieverTool(Tool):
        name = "guest_info_retriever"
        description = "Récupère des informations détaillées sur les invités du gala basées sur leur nom ou relation."
        inputs = {
            "query": {
                "type": "string",
                "description": "Le nom ou la relation de l'invité sur lequel vous voulez des informations."
            }
        }
        output_type = "string"

        def __init__(self, docs):
            self.is_initialized = False
            self.retriever = BM25Retriever.from_documents(docs)

        def forward(self, query: str):
            results = self.retriever.get_relevant_documents(query)
            if results:
                return "\n\n".join([doc.page_content for doc in results[:3]])
            else:
                return "Aucune information d'invité correspondante trouvée."

    # Initialiser l'outil
    guest_info_tool = GuestInfoRetrieverTool(docs)

Comprenons cet outil étape par étape :

- Le `name` et la `description` aident l’agent à comprendre quand et comment utiliser cet outil
- Les `inputs` définissent quels paramètres l’outil attend (dans ce cas, une requête de recherche)
- Nous utilisons un `BM25Retriever`, qui est un algorithme de récupération de texte puissant qui ne nécessite pas d’embeddings
- La méthode `forward` traite la requête et retourne les informations d’invité les plus pertinentes

###
Étape 3 : Intégrer l’outil avec Alfred

Enfin, assemblons le tout en créant notre agent et en l’équipant de notre outil personnalisé :

smolagents
llama-index
langgraph

    from smolagents import CodeAgent, InferenceClientModel

    # Initialiser le modèle Hugging Face
    model = InferenceClientModel()

    # Créer Alfred, notre agent de gala, avec l'outil d'informations sur les invités
    alfred = CodeAgent(tools=[guest_info_tool], model=model)

    # Exemple de requête qu'Alfred pourrait recevoir pendant le gala
    response = alfred.run("Parlez-moi de notre invitée nommée 'Lady Ada Lovelace'.")

    print("🎩 Réponse d'Alfred :")
    print(response)

Sortie attendue :

    🎩 Réponse d'Alfred :
    Basé sur les informations que j'ai récupérées, Lady Ada Lovelace est une mathématicienne estimée et une amie. Elle est renommée pour son travail pionnier en mathématiques et en informatique, souvent célébrée comme la première programmeuse informatique en raison de son travail sur la machine analytique de Charles Babbage. Son adresse email est ada.lovelace@example.com.

Ce qui se passe dans cette étape finale :

- Nous initialisons un modèle Hugging Face en utilisant la classe `InferenceClientModel`
- Nous créons notre agent (Alfred) comme un `CodeAgent`, qui peut exécuter du code Python pour résoudre des problèmes
- Nous demandons à Alfred de récupérer des informations sur une invitée nommée “Lady Ada Lovelace”

##
Exemple d’interaction

Pendant le gala, une conversation pourrait se dérouler comme ceci :

Vous : “Alfred, qui est ce monsieur qui parle à l’ambassadeur ?”

Alfred : recherche rapidement dans la base de données des invités “C’est le Dr. Nikola Tesla, monsieur. C’est un vieil ami de votre période à l’université. Il vient récemment de breveter un nouveau système de transmission d’énergie sans fil et serait ravi d’en discuter avec vous. N’oubliez pas qu’il est passionné par les pigeons, donc cela pourrait faire une bonne conversation.”

    {
        "name": "Dr. Nikola Tesla",
        "relation": "vieil ami des jours d'université",
        "description": "Le Dr. Nikola Tesla est un vieil ami de votre période à l'université. Il vient récemment de breveter un nouveau système de transmission d'énergie sans fil et serait ravi d'en discuter avec vous. N'oubliez pas qu'il est passionné par les pigeons, donc cela pourrait faire une bonne conversation.",
        "email": "nikola.tesla@gmail.com"
    }

##
Aller plus loin

Maintenant qu’Alfred peut récupérer des informations sur les invités, considérez comment vous pourriez améliorer ce système :

1. Améliorer le récupérateur pour utiliser un algorithme plus sophistiqué comme ceux disponibles dans `sentence-transformers`
2. Implémenter une mémoire de conversation pour qu’Alfred se souvienne des interactions précédentes
3. Combiner avec la recherche web pour obtenir les dernières informations sur les invités inconnus
4. Intégrer plusieurs index pour obtenir des informations plus complètes à partir de sources vérifiées

Maintenant Alfred est entièrement équipé pour gérer sans effort les questions sur les invités, s’assurant que votre gala soit mémorisé comme l’événement le plus sophistiqué et délicieux du siècle !

Essayez d'étendre l'outil de récupération pour aussi retourner des amorces de conversation basées sur les intérêts ou l'arrière-plan de chaque invité. Comment modifieriez-vous l'outil pour accomplir cela ?

Quand vous avez terminé, implémentez votre outil de récupération d’invités dans le fichier `retriever.py` du Space.

< > Update on GitHub