Comment développer un système de recherche basé sur RAG et le connecter au CMS Drupal

Introduction

Dans le monde d’aujourd’hui axé sur l’information, fournir des résultats de recherche précis et contextuellement pertinents constitue un défi crucial. C’est ici RAG (génération augmentée par récupération) les systèmes brillent, combinant la puissance des approches basées sur la récupération avec des modèles de génération avancés pour améliorer la précision et la pertinence de la recherche.

Dans ce blog, nous explorerons comment créer un système de recherche robuste basé sur RAG à l’aide d’un Base de données vectorielles-une technologie de pointe conçue pour gérer des données de grande dimension telles que les intégrations de modèles d’apprentissage automatique. Nous montrerons également comment intégrer ce système de recherche avancée de manière transparente avec CMS Drupalune plateforme de gestion de contenu populaire, garantissant une expérience utilisateur fluide tant pour les développeurs que pour les utilisateurs finaux.

À la fin de ce guide, vous aurez un aperçu de :

• Les principes fondamentaux des systèmes de recherche basés sur RAG et leurs avantages.
• Comment fonctionnent les bases de données vectorielles et pourquoi elles sont idéales pour RAG.
• Intégration étape par étape d’un système RAG avec Drupal CMS pour optimiser la découverte de contenu.

Qu’est-ce qu’un système RAG ?

UN Génération augmentée par récupération (RAG) utilise deux composants principaux :

1. Composant de récupération : récupère les documents ou les données pertinents à partir d’un ensemble de données en fonction d’une requête.
2. Composant de génération : utilise les documents récupérés pour générer une réponse contextuellement précise et pertinente.

Pourquoi utiliser Qdrant ?

Qdrant est une base de données vectorielles open source conçue pour la recherche en temps réel et les applications évolutives. Il est optimisé pour gérer des données à grande échelle avec des performances élevées et offre des fonctionnalités telles que :

• Recherche de similarité vectorielle à grande vitesse
• Évolutivité et distribution
• Capacités avancées de filtrage et d’interrogation

Intégration de Qdrant à un système RAG :

Étape 1 : Configuration de Qdrant

• Installation: Suivez le Installation de Qdrant guide pour configurer Qdrant sur votre serveur.
• Configuration: configurez Qdrant en fonction de vos besoins, tels que le nombre de partitions et de répliques pour les configurations distribuées.

Étape 2 : Préparez vos données

Pour rendre votre système RAG accessible, vous pouvez envelopper ses fonctionnalités dans une API REST basée sur Flask. Flask est léger, facile à utiliser et idéal pour déployer des API.

Structure de l’API
Nous allons créer deux points de terminaison :

• API de flux : Accepte les données, génère des intégrations et les télécharge sur Qdrant.
• Demandez à l’API : Accepte une requête utilisateur, récupère le contexte pertinent de Qdrant et renvoie une réponse générée par l’IA.

Voici comment implémenter l’API Flask (main.py) :

from fastapi import FastAPI, Body, HTTPException
from pydantic import BaseModel, ValidationError
from fastapi import FastAPI, Request
import logging
from vector_db_manager import QdrantManager
from config import Config
import numpy as np
from knowledge_graph import neo4j
from data_chunk_manager import DataChunkManager

logging.basicConfig(level=logging.DEBUG)

app = FastAPI()
app_logger = logging.getLogger(__name__)

# function to chunk the data
def add_docs(
        data: str,
):
    chunk_manager = DataChunkManager()
    document = chunk_manager.create_document([data])
    embeddings = chunk_manager.generate_embeddings(document)
    embeddings_array = np.array(embeddings)
    embeddings_shape = embeddings_array.shape
    vector_size = embeddings_shape[1]
    if vector_size > 0 : 
        qdrant_manager = QdrantManager(collection_name=Config.collection_name, vector_size=vector_size)
        doc_uuids = qdrant_manager.upload_documents(embeddings, document)
    else :
        app_logger.logger.info("Unable to create the embeddings. The embeddings array is empty or malformed.")
    return doc_uuids

def find_docs(query):
    chunk_manager = DataChunkManager()
    query_embeddings = chunk_manager.query_embeddings(query)
    qdrant_manager = QdrantManager()
    query_context = qdrant_manager.search_query(query_embeddings)
    #create prompt
    query_prompts = chunk_manager.create_prompt(query_context,query)
    AI_answer = qdrant_manager.get_ai_response(query_prompts)
    return AI_answer

class FeedData(BaseModel):
    data: str
class SearchData(BaseModel):
    data: str

@app.post("/ask")
def search_startup(SearchData:SearchData):
    query = SearchData.data
    ai_answer = find_docs(query)
    return {"response": ai_answer}

@app.post("/feed/add")
def feed_add(feed_data: FeedData):
    try:
        data = feed_data.data
        ids = add_docs(data=data)
        return {"response": "Document successfully added.", "doc_uuids": ids}
    except ValidationError as e:
        raise HTTPException(status_code=400, detail="Invalid input data.")

if __name__ == "__main__":
    import uvicorn

    #uvicorn.run(app, host="0.0.0.0", port=8000)
    uvicorn.run(app, host=Config.HOST, port=Config.PORT, reload=Config.DEBUG)

Comprendre le découpage et l’intégration dans RAG

Le découpage et l’intégration sont des étapes critiques dans la création d’un système de génération augmentée par récupération (RAG). Ces processus permettent de décomposer des documents volumineux en morceaux gérables et de les transformer en représentations vectorielles pour une recherche efficace de similarité.

Qu’est-ce que le chunking ?

Le découpage consiste à diviser un gros morceau de texte en sections (ou « morceaux ») plus petites et plus faciles à gérer. Cela garantit que :

• Les données restent contextuellement pertinentes.
• Cela évite de dépasser les limites des jetons lors de la génération d’intégrations ou de l’interrogation d’un modèle.
• Il améliore la précision de la récupération en associant les requêtes à des parties spécifiques du document.

Comment fonctionne le découpage

Diviser le texte

• Le texte est divisé en morceaux plus petits en fonction d’une stratégie prédéfinie, telle que les limites des phrases, la longueur des paragraphes ou le nombre de jetons.
• Par exemple, un morceau peut être limité à 500 jetons pour garantir la compatibilité avec des modèles tels que les intégrations OpenAI.

Préserver le contexte

• Un chevauchement entre les morceaux est parfois ajouté pour conserver le contexte entre les sections.

Voici comment implémenter le chunking et l’intégration (data_chunk_manager.py) :

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores.utils import filter_complex_metadata
from sentence_transformers import SentenceTransformer
from config import Config
import openai

class DataChunkManager:

    def __init__(self):
        self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=900, chunk_overlap=150)

    def generate_chunk(self, document):
        chunks = self.text_splitter.split_documents(document)
        chunks = filter_complex_metadata(chunks)

        return chunks

    def create_document(self, text):
        document = self.text_splitter.create_documents(text)
        return document

    def generate_embeddings(self,texts):
        
        openai.api_key = Config.api_key
        model_name = Config.embedding_model
        texts_content  = [doc.page_content for doc in texts]
        response = openai.Embedding.create(
            model=model_name,
            input=texts_content
        )

        embeddings = [item['embedding'] for item in response['data']]
        return embeddings
    
    def query_embeddings(self, query):
        
        model_name=Config.embedding_model
        openai.api_key = Config.api_key

        query_response = openai.Embedding.create(
            model=model_name,
            input=query
        )
        query_embedding = query_response['data'][0]['embedding']
        return query_embedding
   

Étape 3 : Téléchargez les données sur Qdrant et interrogez la base de données :

Télécharger des données sur Qdrant

Utilisez la fonction upload_documents pour :

• Créez un identifiant unique pour chaque morceau.
• Stockez les intégrations vectorielles et le texte associé dans Qdrant.

Lorsqu’une requête utilisateur est reçue

Générez son intégration vectorielle.

• Effectuez une recherche de similarité dans Qdrant à l’aide de search_query.
• Récupérez les morceaux de texte les plus pertinents pour le contexte.

(vecteur_db_manager.py) :

from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient
from qdrant_client.http.models import Distance, VectorParams, PointStruct
import uuid
import openai
from config import Config
import json

collection_name = Config.collection_name
client = QdrantClient(url=Config.qdrant_host)

class QdrantManager:
    def __init__(self, collection_name=Config.collection_name, vector_size=Config.vector_size_ai_model, url=Config.qdrant_host):
        self.client = QdrantClient(url=url)
        self.collection_name = collection_name
        self.vector_size = vector_size
        self._ensure_collection_exists()
    def _ensure_collection_exists(self):
        try:
            self.client.get_collection(self.collection_name)
            print(f"Collection '{self.collection_name}' already exists.")
        except:
            self.client.create_collection(
                collection_name=self.collection_name,
                vectors_config=VectorParams(size=self.vector_size, distance=Distance.COSINE)
            )
            print(f"Collection '{self.collection_name}' created successfully.")

    def upload_documents(self, embeddings, texts):

        texts_content = [doc.page_content for doc in texts]
        payloads = [{'text': text} for text in texts_content]
        uploaded_ids = []
        for embedding, payload in zip(embeddings, payloads):
            unique_id = str(uuid.uuid4())
            self.client.upsert(
                collection_name=self.collection_name,
                points=[
                    PointStruct(
                        id=unique_id,
                        vector=embedding,
                        payload=payload
                    )
                ]
            )
            uploaded_ids.append(unique_id)
        print("Documents and embeddings uploaded successfully.")
        return json.dumps(uploaded_ids)

    def search_query(self, query_embedding, limit=3):
        search_results = self.client.search(
            collection_name=self.collection_name,
            query_vector=query_embedding,
            limit=limit
        )
        # Retrieve and concatenate the contexts from the search results
        retrieved_context = "\n\n".join([result.payload['text'] for result in search_results])
        return retrieved_context

    def get_ai_response(self,prompt: str, max_tokens: int = 150, temperature: float = 0.2) -> str:
        if Config.api_key:
            openai.api_key = Config.api_key
        else:
            raise ValueError("API key must be provided")

        model = Config.ai_model
        response = openai.ChatCompletion.create(
            model=model,
            messages=[
                {"role": "user", "content": prompt}
            ],
            max_tokens=max_tokens,
            temperature=temperature,
            top_p=1,
            n=1
        )

        # Extract the answer from the response
        answer = response['choices'][0]['message']['content'].strip()
        return answer 

Étape 4 : Testez votre flux de travail RAG

• Ajouter des données : Utilisez le /alimenter/ajouter API pour télécharger des documents.
• Posez des questions : Utilisez le /demander API pour interroger le système et recevoir des réponses générées par l’IA.

Étape 5 : Intégration de l’API RAG avec Drupal

L’intégration de votre système de génération augmentée de récupération (RAG) avec Drupal vous permet de tirer parti de ses capacités de gestion de contenu tout en l’améliorant avec une récupération intelligente et une génération de réponses. En connectant votre API Flask à une instance Drupal, vous pouvez activer les requêtes dynamiques et l’amélioration du contenu directement depuis votre système RAG.

Modifiez ou créez le fichier rag_integration.module dans votre dossier de module personnalisé

<?php use Drupal\Core\Entity\EntityInterface; /** * Implements hook_entity_presave(). */ function rag_integration_entity_presave(EntityInterface $entity) { // Check if the entity is of type 'node' and the content type is 'article'. if ($entity->getEntityTypeId() === 'node' && $entity->bundle() === 'article') {
    // Extract the body field value.
    $body = $entity->get('body')->value;

    // Ensure the body is not empty before calling the API.
    if (!empty($body)) {
      // Call the /feed/add API.
      $flask_api_url="http://:/feed/add";
      $client = \Drupal::httpClient();

      try {
        $response = $client->post($flask_api_url, [
          'json' => ['data' => $body],
        ]);
        $result = json_decode($response->getBody(), TRUE);

        // Optionally, log the response or handle errors.
        if (isset($result['response'])) {
          \Drupal::logger('rag_integration')->info('Content added to RAG: @response', ['@response' => $result['response']]);
        } else {
          \Drupal::logger('rag_integration')->error('Failed to add content to RAG.');
        }
      } catch (\Exception $e) {
        \Drupal::logger('rag_integration')->error('Error calling /feed/add API: @message', ['@message' => $e->getMessage()]);
      }
    }
  }
}

De même, nous pouvons créer une page dans Drupal et utiliser l’API /ask pour récupérer la réponse de Qdrant DB,

Architecture RAG

RAG (Retrieval-Augmented Generation) intègre la récupération d’informations à la génération de langage, permettant à l’IA de récupérer des données pertinentes à partir de sources externes et de générer des réponses précises et riches en contexte. Il combine un modèle de récupération pour la récupération de connaissances et un modèle de générateur pour la création de réponses.

Architecture RAG

Conclusion

L’intégration d’un système de génération de récupération augmentée (RAG) avec les API Flask et Drupal permet une ingestion de contenu transparente, une recherche sémantique et une augmentation de contenu dynamique. En tirant parti d’outils tels que Qdrant, LangChain et Drupal, nous avons créé un système efficace pour une récupération de données améliorée et des expériences utilisateur personnalisées, permettant une diffusion de contenu évolutive basée sur l’IA.

VOUS TROUVEZ CECI UTILE ? PARTAGEZ-LE