Salt la conținutul principal
Română— Alege o limbă
Meniu

Pipeline RAG complet

Lecția 14 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Assemblage de l’ensemble
  2. Le pipeline complet
  3. Exécution du pipeline
  4. Cinq axes d’amélioration
  5. Puncte cheie

Assemblage de l’ensemble

Les leçons précédentes ont couvert chaque maillon de la chaîne séparément : chargement, découpage, encodage, indexation, récupération et génération. Il est maintenant temps de souder ces éléments en un programme complet, de bout en bout, que vous pouvez exécuter tel quel puis adapter à vos propres documents. Ce script tient dans un seul fichier et ne nécessite que quatre dépendances.

pip install mistralai faiss-cpu numpy requests

Le pipeline complet

Deux choix de conception structurent ce code. Premièrement, nous regroupons toute la configuration en haut du fichier : les modèles, la taille des chunks, la taille des lots et TOP_K sont des constantes nommées. Cela vous évite de traquer des valeurs codées en dur enfouies dans les fonctions lorsque vous devez ajuster le comportement. Deuxièmement, nous divisons la logique en six fonctions indépendantes, correspondant chacune à une étape et affichant sa progression sous la forme [n/6]. Cette trace n’est pas décorative : lorsque le pipeline échoue ou renvoie une réponse étrange, elle vous indique immédiatement si le problème se situe au niveau du chargement, du découpage ou de la récupération. Chaque fonction est également remplaçable de manière isolée : vous pouvez intégrer un chargeur PDF pour load_data sans toucher au reste.

La fonction main enchaîne les étapes, puis interroge le corpus avec trois questions sur l’essai de Paul Graham utilisé comme jeu de données de démonstration. Notez que la récupération et la génération s’exécutent dans la boucle, tandis que l’indexation n’a lieu qu’une seule fois au préalable : ré-encoder l’intégralité du corpus pour chaque question serait absurde en termes de coût et de latence.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Configuration
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Étape 1 : Chargement des données
# ============================================================
def load_data(url):
    """Charge un document texte depuis une URL."""
    print("[1/6] Chargement des données...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} caractères chargés")
    return text


# ============================================================
# Étape 2 : Création des chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Découpe le texte en chunks."""
    print("[2/6] Création des chunks...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> {len(chunks)} chunks créés (taille moyenne : {sum(len(c) for c in chunks) // len(chunks)} caractères)")
    return chunks


# ============================================================
# Étape 3 : Génération des embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Encode les chunks en embeddings via mistral-embed."""
    print("[3/6] Génération des embeddings...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Lot {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encodé")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Matrice : {embeddings.shape}")
    return embeddings


# ============================================================
# Étape 4 : Création de l'index FAISS
# ============================================================
def create_index(embeddings):
    """Crée et remplit un index FAISS."""
    print("[4/6] Création de l'index FAISS...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index : {index.ntotal} vecteurs, dimension {dimension}")
    return index


# ============================================================
# Étape 5 : Récupération des chunks pertinents
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Récupère les chunks les plus pertinents."""
    print(f"[5/6] Recherche pour : '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> {len(results)} chunks récupérés")
    return results


# ============================================================
# Étape 6 : Génération de la réponse
# ============================================================
def generate(question, context_chunks):
    """Génère la réponse en utilisant le contexte récupéré."""
    print("[6/6] Génération de la réponse...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Contexte informatif :

{context}

---

En vous basant UNIQUEMENT sur le contexte ci-dessus, répondez à la question suivante de manière précise et complète.

Question : {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Vous êtes un assistant qui répond en se basant sur le contexte fourni."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Réponse générée ({len(answer)} caractères)")
    return answer


# ============================================================
# Pipeline principal
# ============================================================
def main():
    """Exécute le pipeline RAG complet."""
    # 1. Chargement
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Découpage
    chunks = create_chunks(text)

    # 3. Encodage
    embeddings = create_embeddings(chunks)

    # 4. Indexation
    index = create_index(embeddings)

    # 5+6. Question -> Réponse
    questions = [
        "Quelles sont les deux principales choses sur lesquelles l'auteur a travaillé avant l'université ?",
        "Qu'a fait l'auteur durant son temps chez Y Combinator ?",
        "Quel langage de programmation l'auteur a-t-il appris en premier ?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nQ : {question}")
        print(f"A : {answer}")


if __name__ == "__main__":
    main()

Exécution du pipeline

Enregistrez ce code sous le nom rag_pipeline.py, exportez votre clé API dans l’environnement — ne la codez jamais en dur dans le fichier, car elle finirait par se retrouver dans un dépôt — puis exécutez le script. La sortie détaille les six étapes, puis traite les trois questions avec leurs réponses. Si une réponse semble hors sujet, comparez-la aux chunks affichés à l’étape 5 avant d’incriminer le modèle de génération.

export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py

Cinq axes d’amélioration

Ce pipeline constitue une fondation, non un produit fini, et chacune de ses limites pointe vers une prochaine étape. La plus immédiate est la persistance : dans sa forme actuelle, le script ré-encode l’intégralité du corpus à chaque exécution, alors que la sauvegarde de l’index FAISS et des chunks rendrait les exécutions suivantes quasi instantanées. Le re-ranking représente le niveau supérieur, faisant passer les résultats FAISS through un cross-encodeur qui juge la pertinence bien plus finement que la seule distance vectorielle. Le filtrage par métadonnées répond à un autre besoin : contraindre la recherche par date, catégorie ou auteur, en plus de la similarité. Deux dernières améliorations se concentrent sur l’expérience utilisateur : le streaming, qui affiche la réponse au fur et à mesure de sa génération plutôt qu’après plusieurs secondes de silence, et l’historique de conversation, qui permet aux utilisateurs de poser des questions de suivi comme „qu’en est-il de la version 2 ?“ sans reformuler toute leur question.

# 1. Sauvegarder l'index pour éviter le recalcul
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Ajouter le re-ranking
# Après la récupération FAISS, utiliser un modèle cross-encodeur
# pour réordonner les résultats selon une pertinence fine

# 3. Filtrage par métadonnées
# Ajouter des filtres (date, catégorie, auteur) en plus
# de la similarité vectorielle

# 4. Streaming de la réponse
# Utiliser client.chat.stream() pour afficher la réponse
# au fur et à mesure de sa génération

# 5. Historique de conversation
# Ajouter les échanges précédents au prompt
# pour un chatbot RAG contextuel

Puncte cheie

  • Le pipeline RAG complet se décompose en 6 étapes : chargement, découpage, encodage, indexation, récupération, génération
  • Chaque étape est une fonction indépendante, facile à tester et à remplacer
  • Utilisez temperature=0.1 pour des réponses factuelles
  • Sauvegardez l’index FAISS et les embeddings pour éviter de tout recalculer à chaque exécution
  • Ce pipeline est un point de départ solide à enrichir selon vos besoins