Construis un moteur de RAG (Recherche Documentaire Augmentée) avec Python

Apprends à connecter un LLM à tes propres documents

Tu as déjà utilisé ChatGPT ou Claude pour poser des questions générales. Mais que faire quand tu veux interroger tes propres documents — un PDF de cours, une base de connaissances interne, ou ta collection de notes ?

C’est exactement le problème que résout le RAG (Retrieval-Augmented Generation). Dans cet article, tu vas construire pas à pas un moteur de RAG complet avec Python, en utilisant des modèles open-source et une base vectorielle. À la fin, tu pourras poser des questions en langage naturel à n’importe lequel de tes documents.

Qu’est-ce que le RAG ?

Le RAG, c’est un pattern qui combine recherche documentaire et génération de texte. Concrètement :

• Tu découpes tes documents en petits morceaux (segments)
• Tu convertis chaque morceau en un vecteur (une représentation mathématique du sens)
• Tu stockes ces vecteurs dans une base vectorielle
• Quand un utilisateur pose une question, tu cherches les vecteurs les plus proches
• Tu envoies les morceaux trouvés + la question à un LLM, qui génère une réponse contextuelle

L’avantage ? Pas besoin de fine-tuner un modèle. Tu changes les documents, le comportement change. C’est modulaire, rapide à mettre en place, et très efficace.

Prérequis

Pour suivre ce tutoriel, installe les bibliothèques suivantes :

pip install chromadb sentence-transformers langchain langchain-community pypdf

Si tu débutes avec Python et que tout ça te semble flou, découvre notre formation Python — on part de zéro, jusqu’à coder tes propres projets IA.

Étape 1 : Charger et découper un document PDF

Commençons par charger un fichier PDF. Pour l’exemple, prenons un rapport ou un article que tu souhaites interroger.

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Charge le PDF
loader = PyPDFLoader("mon_document.pdf")
documents = loader.load()

# Découpe en segments de 1000 caractères
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = splitter.split_documents(documents)
print(f"Nombre de segments : {len(chunks)}")
print(f"Premier segment : {chunks[0].page_content[:100]}...")

Le chunk_overlap de 200 caractères garantit qu’un morceau d’information coupé en deux ne soit pas perdu — la fin d’un segment chevauche le début du suivant.

Étape 2 : Créer les embeddings avec Sentence Transformers

Les embeddings sont le cœur du RAG. Ce sont des vecteurs (listes de nombres) qui capturent le sens des phrases. Deux phrases similaires auront des vecteurs proches.

On utilise sentence-transformers, un framework open-source avec des modèles pré-entraînés :

from sentence_transformers import SentenceTransformer

# Modèle français performant et léger
model = SentenceTransformer("dangvantuan/sentence-camembert-large")

# Convertir un texte en vecteur
texte = "Qu'est-ce que le RAG en intelligence artificielle ?"
vecteur = model.encode(texte)

print(f"Dimension du vecteur : {len(vecteur)}")
print(f"Premières valeurs : {vecteur[:5]}")

💡 Astuce : Tu peux utiliser un modèle multilingue (comme intfloat/multilingual-e5-small) si tes documents sont en anglais ET en français.

Étape 3 : Stocker les vecteurs dans ChromaDB

Maintenant qu’on a les vecteurs, il faut les stocker pour pouvoir les chercher rapidement. On utilise ChromaDB, une base vectorielle légère qui tourne en local :

import chromadb
from chromadb.config import Settings

# Initialise la base vectorielle
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./rag_db"
))

# Crée une collection
collection = client.create_collection(name="mes_documents")

# Ajoute les segments avec leurs vecteurs
for i, chunk in enumerate(chunks):
    vecteur = model.encode(chunk.page_content).tolist()
    collection.add(
        embeddings=[vecteur],
        documents=[chunk.page_content],
        metadatas=[{"source": chunk.metadata.get("source", "inconnu")}],
        ids=[f"chunk_{i}"]
    )

print("✅ Base vectorielle créée avec succès !")

Chaque segment est stocké avec :

• Son embedding (le vecteur)
• Le texte original
• Des métadonnées (source, date, etc.)

Étape 4 : Rechercher les documents pertinents

Quand un utilisateur pose une question, on la convertit en vecteur, puis on cherche les N segments les plus proches dans la base :

def recherche_documents(question, k=3):
    """Trouve les k segments les plus pertinents pour une question."""
    vecteur_question = model.encode(question).tolist()
    
    resultats = collection.query(
        query_embeddings=[vecteur_question],
        n_results=k
    )
    
    return resultats["documents"][0]

question = "Quels sont les avantages du RAG ?"
docs = recherche_documents(question)

print("\n📄 Documents trouvés :")
for i, doc in enumerate(docs):
    print(f"\n--- Résultat {i+1} ---")
    print(doc[:200])

La fonction collection.query() calcule automatiquement la similarité cosinus entre le vecteur de la question et tous les vecteurs stockés. Elle retourne les K plus proches voisins — c’est ultra-rapide, même avec des millions de segments.

Étape 5 : Générer une réponse avec un LLM

Dernière étape : envoyer les documents trouvés à un LLM pour générer une réponse contextuelle.

On peut utiliser OpenAI, ou un modèle local via Ollama :

from langchain_openai import ChatOpenAI

def repondre_question(question, documents):
    """Génère une réponse basée sur les documents trouvés."""
    
    contexte = "\n\n".join(documents[:3])
    
    prompt = f"""Tu es un assistant spécialisé. Réponds à la question 
uniquement en utilisant les informations ci-dessous.
Si les documents ne contiennent pas la réponse, dis-le poliment.

DOCUMENTS :
{contexte}

QUESTION : {question}

RÉPONSE :"""
    
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
    reponse = llm.invoke(prompt)
    
    return reponse.content

# Test complet
question = "Qu'est-ce que le RAG et comment ça fonctionne ?"
docs = recherche_documents(question)
reponse = repondre_question(question, docs)

print(f"\n🤖 Question : {question}")
print(f"\n💬 Réponse : {reponse}")

🔑 Le secret : en passant les documents dans le contexte du prompt, on évite les hallucinations. Le LLM n’invente pas — il s’appuie sur des faits réels que tu lui fournis.

Aller plus loin

Ce pipeline de base peut être amélioré de plusieurs façons :

• Hybrid search : combine recherche vectorielle et recherche par mots-clés (BM25) pour de meilleurs résultats
• Re-ranking : ajoute un modèle de classement entre la recherche et la génération pour affiner les résultats
• Streaming : affiche la réponse mot par mot comme ChatGPT pour une meilleure UX
• Conversation mémoire : conserve l’historique des échanges pour des questions en follow-up
• Multi-format : supporte PDF, DOCX, HTML, pages web, et même des bases de données SQL

Le RAG est devenu le standard de facto pour tous les projets d’IA documentaire. Pas cher, efficace, sans fine-tuning. Google, Notion, et des centaines de startups l’utilisent en production.

Prêt à maîtriser Python pour l’IA ?

Ce tutoriel suppose que tu sais déjà exécuter du Python, installer des packages et manipuler des fichiers. Si ce n’est pas encore le cas, pas de panique — notre formation Python : les fondamentaux te donne toutes les bases pour coder en Python, du premier script jusqu’à tes premiers projets IA.

Construis ton avenir dans l’IA, une ligne de code à la fois. 🚀