plateforme RAG open-source

plateforme RAG open-source : transformer vos documents en base de données

Non classé

Tutoriel pas-à-pas PerlIntermédiaire

plateforme RAG open-source : transformer vos documents en base de données

Extraire des informations précises de centaines de fichiers PDF sans lecture manuelle est impossible sans une plateforme RAG open-source performante. Le défi ne réside pas dans la lecture du texte, mais dans sa fragmentation et son indexation sémantique.

Une recherche textuelle classique par mots-clés échoue dès que la sémantique diverge de la syntaxe exacte. Un index Elasticsearch standard nécessite une infrastructure lourde et coûteuse pour gérer des vecteurs de haute dimension.

Ce guide détaille la mise en place d’un pipeline complet, de l’ingestion de documents bruts à une interface de requête sémantique fonctionnelle.

plateforme RAG open-source

🛠️ Prérequis

Le système doit disposer des composants suivants pour garantir la stabilité du pipeline :

  • Python 3.12+ (gestionnaire de paquets pip installé)
  • Ollama version 0.1.45 ou supérieure pour l’exécution locale des LLM
  • Docker 24.0+ pour le déploiement de ChromaDB si utilisation distante
  • Bibliothèques Python : langchain, chromadb, sentence-transformers, pypdf

📚 Comprendre plateforme RAG open-source

Le RAG (Retrieval-Augmented Generation) repose sur trois piliers : l’Embedding, le Vector Store et le LLM. Contrairement à un simple script Perl utilisant des regex pour trouver des motifs, le RAG transforme le texte en vecteurs numériques dans un espace multidimensionnel.

L’Embedding est une fonction mathématique qui projette une chaîne de caractères dans un espace de dimension N (par exemple 768 pour le modèle BERT). Deux phrases sémantiquement proches seront géographiquement proches dans cet espace vectoriel.

Structure du pipeline :
[Document] -> [Chunking] -> [Embedding Model] -> [Vector Store]
                                                       |
[Question] -> [Embedding Model] -> [Similarity Search] <-
       |
       +-> [LLM Prompt] -> [Réponse finale]

Si vous utilisez une approche SQL classique, vous comparez des valeurs exactes. Ici, nous calculons la similarité cosinus entre deux vecteurs.

🐪 Le code — plateforme RAG open-source

Perl
import os
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings

def ingest_documents(directory_path: str, persist_directory: str):
    # Initialisation du splitter avec chevauchement pour éviter la perte de contexte
    text_splitter = RecursiveCharacterTextLearnerSplitter(
        chunk_size=1000,
        chunk_overlap=200
    )
    
    documents = []
    # Chargement de tous les PDF du répertoire
    for filename in os.listdir(directory_path):
        if filename.endswith(".pdf"):
            loader = PyPDFLoader(os.path.join(directory_path, filename))
            documents.extend(loader.load())
    
    # Découpage des documents en morceaux gérables
    chunks = text_splitter.split_documents(documents)
    
    # Utilisation d'un modèle d'embedding léger et local
    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
    
    # Création et persistance de la base de données vectorielle
    vector_db = Chroma.persist( 
        persist_directory=persist_directory, 
        embedding_function=embeddings, 
        documents=chunks
    )
    return vector_db

if __name__ == "__main__":
    ingest_documents("./data", "./chroma_db")

📖 Explication

Dans le premier script, le choix de RecursiveCharacterTextSplitter est délibéré. Contrairement à un simple split sur le caractère newline, ce splitter tente de maintenir les paragraphes et les phrases ensemble en utilisant une hiérarchie de séparateurs. C’est une alternative bien plus robuste que le split de Perl pour la gestion du contexte sémantique.

Le paramètre k: 3 dans le retriever définit le nombre de fragments récupérés. Augmenter ce nombre apporte plus de contexte mais augmente le risque de dépasser la fenêtre de contexte du LLM (context window). Pour Llama3, une valeur entre 3 et 5 est généralement le compromis idéal.

Attention au piège classique : l’utilisation de Chroma.persist(). Dans les versions récentes de ChromaDB, la persistance est souvent automatique à l’écriture, mais expliciter le chemin garantit que vos données ne disparaissent pas à la fin du processus Python.

Documentation officielle Perl

🔄 Second exemple

Perl
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA

def query_rag_platform(query: str, persist_directory: str):
    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
    
    # Chargement de la base vectorielle existante
    vector_db = Chroma(
        persist_directory=persist_directory, 
        embedding_function=embeddings
    )
    
    # Configuration du LLM local via Ollama
    llm = Ollama(model="llama3")
    
    # Création de la chaîne de récupération et de réponse
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vector_db.as_retriever(search_kwargs={"k": 3})
    )
    
    return qa_chain.run(query)

if __name__ == "__main__":
    print(query_rag_platform("Quel est le sujet principal du document ?", "./chroma_db"))

▶️ Exemple d’utilisation

Supposons que vous ayez un document PDF nommé specifications_techniques.pdf détaillant un protocole réseau. Vous lancez l’ingestion, puis vous exécutezne la requête suivante via le script de query.

# Commande lancée en console
python query_script.py "Quelle est la latence maximale autorisée par le protocole ?"

# Sortie console attendue
[INFO] Chargement des vecteurs depuis ./chroma_db...
[INFO] Recherche de fragments sémantiquement proches...
[RESULTAT] Le protocole spécifié impose une latence maximale de 50ms pour les paquets de contrôle. Cette limite est critique pour éviter le timeout des sessions.

🚀 Cas d’usage avancés

1. **Analyse de logs système** : Vous pouvez injecter des fichiers de logs de 500 Mo dans votre plateforme RAG open-source. En utilisant un chunking par ligne, vous permettez au LLM de diagnostiquer des erreurs complexes en corrélant des timestamps éloignés. chunks = text_splitter.create_documents(log_lines).

2. **Audit de conformité juridique** : Intégrez des contrats PDF. Le pipeline peut comparer une clause spécifique avec une base de régulations pré-indexée. Cela permet de détecter les écarts de conformité en quelques secondes.

3. **Documentation technique dynamique** : Connectez votre pipeline à un dépôt Git. À chaque commit, un trigger lance l’ingestion. Votre plateforme RAG open-source reste synchronisée avec l’état réel de votre code sans intervention humaine.

🐛 Erreurs courantes

⚠️ Mismatch de dimension d'embedding

L’erreur survient si vous tentez de charger une base créée avec un modèle (ex: 768d) avec un nouveau modèle (ex: 384d).

✗ Mauvais

embeddings = HuggingFaceEmbedmente(model_name="base")
✓ Correct

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") # Doit être identique à l'ingestion

⚠️ Context Window Overflow

Envoyer trop de fragments (k trop élevé) sature la mémoire du LLM.

✗ Mauvais

retriever=vector_db.as_retriever(search_kwargs={"k": 50})
✓ Correct

retriever=vector_db.as_retriever(search_kwargs={"k": 5})

⚠️ Fichiers PDF corrompus ou images

Le loader ne trouve aucun texte car le PDF est une simple image sans OCR.

✗ Mauvais

loader = PyPDFLoader("scan_sans_texte.pdf")
✓ Correct

loader = PyPDFLoader("document_avec_texte_extractible.pdf") # Utiliser Tesseract avant si nécessaire

⚠️ Chemin de persistance incorrect

La base est créée dans un dossier temporaire et perdue au redémarrage.

✗ Mauvais

vector_db = Chroma(embedding_function=embeddings)
✓ Correct

vector_ostream = Chroma(persist_directory="./data_db", embedding_function=embeddings)

✅ Bonnes pratiques

Pour maintenir une plateforme RAG open-source de niveau production, suivez ces règles :

  • Optimisation du Chunking : Testez systématiquement différentes tailles de chunks. Un chunk trop petit manque de contexte, un chunk trop grand dilue l’information.
  • Enrichissement des métadonnées : Lors de l’ingestion, ajoutez le nom du fichier et la page dans les métadonnées de chaque chunk pour permettre un traçage précis des sources.
  • Évaluation par RAGAS : Ne vous fiez pas uniquement à votre intuition. Utilisez des frameworks comme RAGAS pour mesurer la fidélité et la pertinence des réponses.
  • Gestion de la mémoire : Si vous utilisez Ollama en local, limitez le nombre de modèles chargés simultanément pour éviter le swapping sur disque.
  • Sécurité des données : Puisque la plateforme RAG open-source tourne en local, assurez-vous que les vecteurs ne sont pas exposés via une API non authentifiée.
Points clés

  • Le RAG transforme le texte brut en vecteurs mathématiques exploitables.
  • L'utilisation de Python 3.12 et LangChain est le standard actuel pour ce pipeline.
  • Le découpage (chunking) avec overlap est crucial pour la continuité sémantique.
  • ChromaDB permet une persistance locale simple sans serveur complexe.
  • Ollama fournit une solution de déploiement local pour les modèles Llama3.
  • La similarité cosinus est le moteur de la recherche de fragments.
  • Le dimensionnement du paramètre 'k' impacte directement la précision et la latence.
  • L'ingestion doit être automatisée pour maintenir la fraîcheur des données.

📚 Sur le même blog

🔗 Le même sujet sur nos autres blogs

📝 Conclusion

La mise en place d’une plateforme RAG open-source est un excellent moyen de reprendre le contrôle sur ses données sans dépendre de services cloud propriétaires. La maîtrise du pipeline d’ingestion et du paramétrage du splitter est le facteur déterminant de la réussite technique. Pour approfondir la manipulation des structures de données complexes, consultez la documentation Perl officielle. Un index vectoriel bien dimensionné vaut mieux qu’un modèle de langage géant mal alimenté.

3 réflexions sur « plateforme RAG open-source : transformer vos documents en base de données »

  1. Ping : plateforme RAG open-source : transformer des documents en base de données vectorielle - PythIA, du python
  2. Ping : terminal Caddy AI : Guide de survie pour workflows automatisés - Perlia, du Perl
  3. Ping : plateforme RAG open-source : transformer vos docs en base de données - Rubia, du Ruby

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *