Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Pipeline RAG complet

Lektion 14 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Assembler le tout
  2. Le pipeline complet
  3. Exécution du pipeline
  4. Cinq pistes d’amélioration
  5. Viktiga punkter

Assembler le tout

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 temps de les souder en un seul programme complet, de bout en bout, que tu peux exécuter tel quel puis adapter à tes 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 t’évite de traquer des valeurs codées en dur enfouies dans des fonctions lorsque tu dois ajuster le comportement. Deuxièmement, nous divisons la logique en six fonctions indépendantes, chacune correspondant à 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 t’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 : tu peux 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. Note 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)


# ============================================================
# Step 1: Load Data
# ============================================================
def load_data(url):
    """Load a text document from a URL."""
    print("[1/6] Loading data...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} characters loaded")
    return text


# ============================================================
# Step 2: Create Chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Split text into chunks."""
    print("[2/6] Creating 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 created (avg size: {sum(len(c) for c in chunks) // len(chunks)} chars)")
    return chunks


# ============================================================
# Step 3: Generate Embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Encode chunks into embeddings via mistral-embed."""
    print("[3/6] Generating 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"  -> Batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encoded")

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


# ============================================================
# Step 4: Create FAISS Index
# ============================================================
def create_index(embeddings):
    """Create and populate a FAISS index."""
    print("[4/6] Creating FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vectors, dimension {dimension}")
    return index


# ============================================================
# Step 5: Retrieve Relevant Chunks
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Retrieve the most relevant chunks."""
    print(f"[5/6] Searching for: '{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 retrieved")
    return results


# ============================================================
# Step 6: Generate Answer
# ============================================================
def generate(question, context_chunks):
    """Generate the answer using retrieved context."""
    print("[6/6] Generating answer...")

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

    prompt = f"""Informative context:

{context}

---

Based ONLY on the context above, answer the following question precisely and completely.

Question: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "You are an assistant that answers based on the provided context."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Answer generated ({len(answer)} characters)")
    return answer


# ============================================================
# Main Pipeline
# ============================================================
def main():
    """Run the complete RAG pipeline."""
    # 1. Load
    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. Chunk
    chunks = create_chunks(text)

    # 3. Encode
    embeddings = create_embeddings(chunks)

    # 4. Index
    index = create_index(embeddings)

    # 5+6. Question -> Answer
    questions = [
        "What were the two main things the author worked on before college?",
        "What did the author do during their time at Y Combinator?",
        "What programming language did the author learn first?",
    ]

    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

Enregistre ce code sous le nom rag_pipeline.py, exporte ta clé API dans l’environnement — ne la code jamais en dur dans le fichier, car elle finirait par se retrouver dans un dépôt — puis exécute 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, compare-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 pistes d’amélioration

Ce pipeline est une fondation, pas 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 sauvegarder l’index FAISS et les chunks rendrait les exécutions suivantes quasi instantanées. Le re-ranking est le niveau supérieur : il s’agit de faire 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. Save the index to avoid recalculating
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Add re-ranking
# After FAISS retrieval, use a cross-encoder model
# to re-order results by fine-grained relevance

# 3. Metadata filtering
# Add filters (date, category, author) in addition
# to vector similarity

# 4. Response streaming
# Use client.chat.stream() to display the answer
# as it generates

# 5. Conversation history
# Add previous exchanges to the prompt
# for a contextual RAG chatbot

Viktiga punkter

  • Le pipeline RAG complet se décompose en 6 étapes : charger, découper, encoder, indexer, récupérer, générer.
  • Chaque étape est une fonction indépendante, facile à tester et à remplacer.
  • Utilise temperature=0.1 pour des réponses factuelles.
  • Sauvegarde l’index FAISS et les embeddings pour éviter de recalculer à chaque exécution.
  • Ce pipeline est un point de départ solide à enrichir selon tes besoins.