RAG — Retrieval-Augmented Generation

Section 11.4.15 : RAG — Retrieval-Augmented Generation

🎯 Objectif pédagogique

Comprendre et implémenter le RAG (Retrieval-Augmented Generation) : technique permettant aux LLMs de répondre en s'appuyant sur VOS données. Vous serez capable de construire un système RAG qui consulte une base de connaissances avant de répondre.

Le problème : les LLMs ne connaissent pas VOS données

Marc demande à GPT-4o : "Quelles sont les offres d'emploi sur le site de TechCorp ?" GPT ne sait pas — il n'a pas accès au site TechCorp. Le RAG résout ce problème en récupérant les données pertinentes avant de générer la réponse.

Architecture RAG

Pipeline RAG :

1. INDEXATION (une fois, au démarrage) :
   Documents → Découper en chunks → Embeddings → Base vectorielle
   
   "Guide Python" (50 pages)
   → [chunk1: "Les listes en Python...", chunk2: "Les dictionnaires...", ...]
   → [embedding1: [0.12, -0.34, ...], embedding2: [0.56, 0.78, ...], ...]
   → Stockés dans ChromaDB / Pinecone / FAISS

2. RETRIEVAL (à chaque question) :
   Question utilisateur → Embedding → Recherche par similarité → Top K chunks
   
   "Comment créer une liste ?" 
   → embedding: [0.11, -0.35, ...]
   → cosine_similarity → Top 3 chunks les plus proches

3. GENERATION (avec contexte) :
   System prompt + Chunks pertinents + Question → LLM → Réponse sourcée

Implémentation complète avec ChromaDB

# pip install chromadb openai python-dotenv

import chromadb
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
openai_client = OpenAI()
chroma_client = chromadb.PersistentClient(path="./chroma_db")

# ═══ ÉTAPE 1 : Indexation ═══

def chunk_text(text, chunk_size=500, overlap=50):
    """Découper un texte en chunks avec overlap."""
    words = text.split()
    chunks = []
    
    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        if chunk:
            chunks.append(chunk)
    
    return chunks

def get_embedding(text):
    """Obtenir l'embedding d'un texte via OpenAI."""
    response = openai_client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def index_documents(documents, collection_name="career_docs"):
    """Indexer des documents dans ChromaDB."""
    collection = chroma_client.get_or_create_collection(
        name=collection_name,
        metadata=\{"hnsw:space": "cosine"\}
    )
    
    all_chunks = []
    all_ids = []
    all_metadatas = []
    
    for doc_id, doc in enumerate(documents):
        chunks = chunk_text(doc["content"])
        for i, chunk in enumerate(chunks):
            all_chunks.append(chunk)
            all_ids.append(f"doc\{doc_id\}_chunk\{i\}")
            all_metadatas.append(\{"source": doc["title"], "chunk_index": i\})
    
    # ChromaDB calcule les embeddings automatiquement via OpenAI
    collection.add(
        documents=all_chunks,
        ids=all_ids,
        metadatas=all_metadatas
    )
    
    print(f"Indexé \{len(all_chunks)\} chunks depuis \{len(documents)\} documents.")
    return collection

# Indexer des documents
documents = [
    \{
        "title": "Guide reconversion Data Analyst",
        "content": """La reconversion vers le métier de Data Analyst est l'une des 
        plus populaires en 2025. Les compétences essentielles sont Python, SQL, 
        et la visualisation de données avec Tableau ou Power BI. Un background 
        en finance ou comptabilité est un atout majeur car l'analyse de données 
        financières est très demandée. Le salaire moyen en France est de 42-55k€ 
        pour un junior, et 55-75k€ pour un senior..."""
    \},
    \{
        "title": "Préparation entretien technique Data",
        "content": """Les entretiens Data Analyst comportent généralement : 
        1) Un test technique SQL (jointures, window functions, agrégations).
        2) Un cas pratique Python (pandas, nettoyage de données).
        3) Une présentation de dashboard (storytelling data).
        Les questions classiques : 'Décrivez un projet où vous avez utilisé les données
        pour prendre une décision business'..."""
    \}
]

collection = index_documents(documents)

Retrieval — Recherche par similarité

# ═══ ÉTAPE 2 : Retrieval ═══

def retrieve_relevant_chunks(query, collection_name="career_docs", n_results=3):
    """Trouver les chunks les plus pertinents pour une question."""
    collection = chroma_client.get_collection(collection_name)
    
    results = collection.query(
        query_texts=[query],
        n_results=n_results
    )
    
    chunks = []
    for i, doc in enumerate(results["documents"][0]):
        source = results["metadatas"][0][i]["source"]
        chunks.append(\{"text": doc, "source": source\})
    
    return chunks

# Test
chunks = retrieve_relevant_chunks("Quel est le salaire d'un Data Analyst ?")
for chunk in chunks:
    print(f"[\{chunk['source']\}] \{chunk['text'][:100]\}...")

Génération augmentée — La réponse finale

# ═══ ÉTAPE 3 : Generation ═══

def rag_answer(question, collection_name="career_docs"):
    """Pipeline RAG complet : Retrieve + Generate."""
    
    # 1. Retrieval
    chunks = retrieve_relevant_chunks(question, collection_name)
    
    if not chunks:
        return "Je n'ai pas trouvé d'information pertinente dans la base de connaissances."
    
    # 2. Construire le contexte
    context = "\n\n".join([
        f"[Source: \{c['source']\}]\n\{c['text']\}" for c in chunks
    ])
    
    # 3. Génération
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            \{"role": "system", "content": """Tu es un assistant de carrière. 
Réponds UNIQUEMENT en te basant sur le contexte fourni.
Si l'info n'est pas dans le contexte, dis "Je n'ai pas cette information dans ma base."
Cite tes sources entre crochets [Source: xxx]."""\},
            \{"role": "user", "content": f"""Contexte :
\{context\}

Question : \{question\}

Réponds en te basant sur le contexte ci-dessus."""\}
        ],
        temperature=0.3
    )
    
    return response.choices[0].message.content

# Utilisation
answer = rag_answer("Comment me préparer pour un entretien Data Analyst ?")
print(answer)
# → Réponse basée sur les documents indexés, avec citations !

RAG vs Fine-tuning

🏋️ Exercice pratique (30 minutes)

1. →Installez ChromaDB : pip install chromadb
2. →Indexez 3 documents texte (votre CV, une FAQ, un guide)
3. →Implémentez le pipeline RAG complet
4. →Testez avec 5 questions — les réponses citent-elles les bonnes sources ?
5. →Testez une question hors-scope — le chatbot gère-t-il correctement ?