Création de RAG à l'aide de TrueFoundry et MongoDB Atlas

Présentation

La génération augmentée par extraction (RAG) combine les atouts des systèmes de récupération et des modèles génératifs pour produire des résultats hautement pertinents et sensibles au contexte. Il interroge des sources de connaissances externes, telles que des bases de données ou des index de recherche, pour récupérer des informations pertinentes, qui sont ensuite affinées par un modèle génératif.

Pourquoi RAG ?

1. Très sorties pertinentes et sensibles au contexte.
2. En incorporant des connaissances dynamiques et actualisées, les systèmes RAG surmontent les limites du préentraînement statique dans les modèles génératifs, ce qui les rend très efficaces pour des applications telles que la réponse à des questions, les tâches à forte intensité de connaissances et la génération de contenu personnalisé.
3. Le modulaire La nature du RAG permet une optimisation à la fois aux étapes de récupération et de génération, ce qui permet une plus grande flexibilité et évolutivité dans la conception du système.

Cognita par TrueFoundry : simplification du RAG pour des applications évolutives

Malgré son potentiel, la mise en œuvre du RAG peut s'avérer complexe, impliquant la sélection de modèles, l'organisation des données et les meilleures pratiques. Les outils existants simplifient le prototypage mais ne proposent pas de modèle open source pour un déploiement évolutif. Entrez Cognita.

Cognita est un framework RAG open source qui simplifie la création et le déploiement d'applications évolutives. En divisant RAG en étapes modulaires, il garantit une maintenance facile, une interopérabilité avec d'autres outils d'IA, une personnalisation et une conformité. Cognita concilie adaptabilité et convivialité tout en restant évolutif pour les avancées futures.

Avantages de Cognita

1. Un référentiel central réutilisable d'analyseurs, de chargeurs, d'intégrateurs et de récupérateurs.
2. Possibilité pour les utilisateurs non techniques de jouer avec l'interface utilisateur - Téléchargez des documents et exécutez QnA à l'aide de modules conçus par l'équipe de développement.
3. Entièrement piloté par API, ce qui permet l'intégration avec d'autres systèmes.
4. Grands modèles de langage (LLM) pour une interaction facile avec des modèles génératifs tels que le GPT d'OpenAI, les modèles Hugging Face ou d'autres API LLM.
5. Intégrations prédéfinies pour vous connecter facilement à Pinecone, Weaviate, ChromaDB ou MongoDB Atlas Vector Search.

Pourquoi MongoDB pour RAG ?

En utilisant MongoDB car une base de données vectorielles pour votre application Retrieval-Augmented Generation (RAG) peut être bénéfique en fonction de vos besoins. Voici pourquoi MongoDB pourrait être un bon choix :

1. Support de recherche vectorielle native

MongoDB prend en charge indexation vectorielle grâce à son Atlas Vector Search. Cela permet des recherches de similarité efficaces sur des données de grande dimension, ce qui est au cœur des flux de travail RAG. Principaux avantages :

• Intégration avec le langage de requête de MongoDB: combine la recherche vectorielle avec les requêtes traditionnelles, ce qui permet une composition de requêtes plus flexible et plus puissante.
• Recherche performante: Utilise des algorithmes du voisin le plus proche approximatif (ANN) tels que HNSW (Hierarchical Navigable Small World) pour une récupération vectorielle évolutive et rapide.

2. Gestion unifiée des données

Les applications RAG nécessitent souvent de gérer les deux, données non structurées (texte et intégrations, par exemple) et données structurées (par exemple, métadonnées, préférences utilisateur).

MongoDB, en tant que base de données de documents, vous permet de stocker les intégrations ainsi que les métadonnées associées dans un seul enregistrement. Par exemple :

{
  "embedding": [0.1, 0.2, 0.3, ...],
  "text": "This is a sample document.",
  "metadata": {
    "source": "document_1",
    "timestamp": "2024-12-06T10:00:00Z"
  }
}

Cela permet d'éviter la complexité liée à la gestion des intégrations dans un système distinct.

3. Flexibilité et évolutivité

Conception sans schéma: La flexibilité des schémas de MongoDB permet d'itérer facilement sur votre modèle de données au fur et à mesure de l'évolution de votre application RAG.

Mise à l'échelle horizontale: la fonction de partitionnement de MongoDB permet de gérer de grands ensembles de données et de les adapter à l'évolution de votre application.

Fonctionnalités natives du cloud: MongoDB Atlas fournit des services entièrement gérés, notamment la mise à l'échelle, les sauvegardes et la surveillance.

Implémentation de RAG avec cognita + MongoDB

Étape 1 : Configuration de MongoDB

Pour un didacticiel vidéo expliquant comment obtenir votre cluster MongoDB Atlas gratuit, cliquez ici.

1. Créez un compte MongoDB Atlas en vous rendant sur le S'inscrire page si vous n'avez pas encore de compte.

2. Pour configurer un cluster dans l'onglet Aperçu, cliquez sur « Créer », sélectionnez le cluster selon vos besoins et cliquez sur « Créer un déploiement ».

3. Pour ajouter les authentifications requises, dans la fenêtre « Connexion au cluster », créez un utilisateur de base de données.
4. Connectez-vous avec le pilote MongoDB
   • Choisissez la version python
   • La chaîne de connexion contiendra votre nom d'utilisateur et votre mot de passe. Copiez la chaîne de connexion. Cela serait utilisé à l'étape suivante.

Étape 2 : Configuration de Cognita pour utiliser MongoDB

1. Clonez le référentiel github cognita : https://github.com/truefoundry/cognita/tree/main
2. Avant de démarrer les services, nous devons configurer les fournisseurs de modèles dont nous aurions besoin pour intégrer et générer des réponses. Pour commencer, copiez models_config.sample.yaml dans models_config.yaml.

cp models_config.sample.yaml models_config.yaml

3. Créez une collection mongo db dans la base de données nouvellement créée, dites « cognita ». Il s'agit de la collection dans laquelle tous les morceaux seront stockés et utilisés dans le processus de récupération.
4. Le fichier de composition utilise le fichier compose.env pour les variables d'environnement. Vous pouvez le modifier selon vos besoins.
5. Modifiez la clé « VECTOR_DB_CONFIG » dans le fichier d'environnement. Cette configuration sera utilisée dans le processus d'amorçage pour garantir que MongoDB sera utilisé comme magasin vectoriel tout au long de l'exécution. La chaîne de connexion pour la base de données mongo sera utilisée ici. Voici un exemple de ce à quoi cela ressemblerait :

VECTOR_DB_CONFIG=' {"provider » :"mongo », « url » :"mongodb+srv : //username : password@clustername.mongodb.net/? retryWrites=true&w=majority&appname=cluster0", « config » : {"database_name » : « cognita"}} '

6. Par défaut, la configuration active les fournisseurs locaux qui ont besoin d'Infinity et d'un serveur Ollama pour exécuter l'intégration et les LLM localement. Toutefois, si vous possédez une clé d'API OpenAI, vous pouvez supprimer les commentaires du fournisseur openai dans models_config.yaml et mettre à jour OPENAI_API_KEY dans compose.env. Vous pouvez maintenant exécuter la commande suivante pour démarrer les services :

docker-compose --env-file compose.env --profile ollama --profile infinity up

7. Le fichier de composition lancera les services suivants
   • cognita-db - Instance Postgres utilisée pour stocker les métadonnées des collections et des sources de données.
   • cognita-backend - Utilisé pour démarrer le serveur principal FastAPI pour Cognita.
   • cognita-frontend - Utilisé pour démarrer l'interface de Cognita.
8. Une fois les services opérationnels, vous pouvez accéder au frontend à l'adresse http://localhost:5001.

Étape 3 : configurer une collecte de données dans Cognita

Une fois que vous avez configuré cognita, les étapes suivantes vous montreront comment utiliser l'interface utilisateur pour interroger des documents :

1. Créer une source de données

• Cliquez sur l'onglet Sources de données
• Cliquez sur + Nouvelle source de données
• Le type de source de données peut être un fichier provenant d'un répertoire local, une URL Web, une URL github ou fournissant le nom de domaine complet de l'artefact Truefoundry. Par exemple : si Localdir est sélectionné, téléchargez des fichiers depuis votre machine et cliquez sur Soumettre.
• La liste des sources de données créées sera disponible dans l'onglet Sources de données.

2. Créer une collection

• Cliquez sur l'onglet Collections

• Cliquez sur + Nouvelle collection

• Entrez le nom de la collection
• Sélectionnez le modèle d'intégration
• Ajoutez la source de données créée précédemment et la configuration nécessaire
• Cliquez sur Traiter pour créer la collection et indexer les données

3. Lors de la création d'une nouvelle collection, voici ce qui se passe dans les coulisses

• Créez une nouvelle collection dans la base de données MongoDB configurée. Par exemple, si le nom de la base de données est « cognita », cette étape crée une collection avec le nom d'entrée donné dans la base de données cognita de mondo db.
• Lors de la création d'une collection, un index de recherche vectorielle est créé à l'aide de l'extrait de code suivant :

from pymongo.operations import SearchIndexModel

search_index_model = SearchIndexModel(
            definition={
                "fields": [
                    {
                        "type": "vector",
                        "path": "embedding",
                        "numDimensions": self.get_embedding_dimensions(embeddings),
                        "similarity": "cosine",
                    }
                ]
            },
            name="vector_search_index",
            type="vectorSearch",
        )

        # Create the search index
        result = self.db[collection_name].create_search_index(model=search_index_model)

Cela garantit que la collection nouvellement créée est prête pour les requêtes de recherche vectorielle. Notez que la création d'un index sur MongoDB peut prendre jusqu'à une minute.

4. Dès que vous créez la collection, l'ingestion des données commence. Vous pouvez consulter son statut en sélectionnant votre collection dans l'onglet Collections. Cette étape est chargée d'analyser vos fichiers, de les découper et de les ajouter à votre MongoDB. Vous pouvez également ajouter des sources de données supplémentaires ultérieurement et les indexer dans la collection. Passez à l'étape suivante une fois que le statut est « Terminé ».

Étape 4 : Trouvez la configuration adaptée à votre application

1. Dans l'onglet DocSQA, utilisez le terrain de jeu de Cognita pour jouer avec les différents paramètres afin de déterminer ce qui convient le mieux à votre application. Vous pouvez en essayer différentes :
   • Techniques de récupération
   • Modèles LLM, températures, etc.
   • invite LLM
   • Modèles d'intégration
2. Quel que soit le paramètre qui convient le mieux à votre application, cliquez sur « Créer une application » pour cela et un point de terminaison d'API sera déployé pour votre application. Vous pouvez accéder à l'onglet « Applications » pour voir toutes vos applications déployées.

Conclusion

Ce didacticiel explique comment créer une application RAG prête pour la production à l'aide de Cognita et MongoDB en seulement 10 minutes. La synergie entre l'adaptabilité et la facilité d'utilisation de Cognita et le modèle de document flexible de MongoDB avec recherche vectorielle constitue une base solide pour la création d'applications d'IA avancées.