# RAG : donner ses documents à un modèle, pas à pas

> Découpage, plongements, recherche vectorielle et réordonnancement : la chaîne d'un RAG expliquée, puis un exemple complet en Python avec Ollama en local.

- Niveau : Nerd
- Thème : IA locale
- Durée : 25 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/rag/

Un modèle de langage ne connaît ni vos contrats, ni vos notes internes, ni la documentation de votre logiciel. Le RAG (*retrieval-augmented generation*, génération augmentée par la recherche) règle ce problème sans toucher au modèle : avant chaque réponse, un programme cherche dans vos documents les passages qui parlent de la question, puis les colle dans la demande. Le modèle répond en s'appuyant sur ces extraits, et peut les citer.

L'idée vient d'un article de chercheurs de Facebook AI publié en 2020 (Lewis et ses coauteurs), qui associait un modèle de génération à un index de Wikipédia interrogé par un moteur de recherche neuronal. Le principe n'a pas bougé depuis.

## À quoi ça sert

- **Interroger une documentation interne** : règlement, procédures, fiches produits, tickets de support. La réponse cite le document d'où elle vient, ce qui permet de la vérifier.
- **Garder ses données chez soi** : avec un modèle local, ni les documents ni les questions ne quittent la machine.
- **Suivre des documents qui changent** : on réindexe un fichier modifié en quelques secondes, alors qu'un modèle affiné devrait être réentraîné.

> Bon à savoir : un RAG n'est pas toujours nécessaire. Anthropic rappelle qu'en dessous d'environ 200 000 jetons (quelques centaines de pages), on peut placer toute la base dans la demande, et que la mise en cache des consignes rend cette méthode rapide et peu chère. Le guide sur le cache et les coûts de l'API détaille ce calcul.

## Comment ça marche

![Les deux temps d'un RAG : l'indexation, faite une fois, puis la recherche et la réponse, refaites à chaque question.](https://quelleia.com/guides/rag/chaine-rag.svg)

*Les deux temps d'un RAG : l'indexation, faite une fois, puis la recherche et la réponse, refaites à chaque question.*

La chaîne se coupe en deux temps.

**L'indexation**, faite une fois puis à chaque changement de document :

1. **Le découpage.** Chaque document est coupé en morceaux (*chunks*). Anthropic conseille des morceaux de quelques centaines de jetons au plus. Trop gros, un morceau mélange plusieurs sujets ; trop petit, il perd son contexte.
2. **Les plongements.** Un modèle spécialisé transforme chaque morceau en vecteur, une liste de quelques centaines de nombres qui résume son sens. Deux textes proches par le sens donnent des vecteurs proches. Le guide sur les plongements explique ce calcul en détail.
3. **L'index.** On range les morceaux et leurs vecteurs : un simple fichier JSON suffit pour quelques milliers de morceaux, une base vectorielle devient utile au-delà.

**La réponse**, refaite à chaque question :

1. **La recherche.** La question passe par le même modèle de plongement. On calcule sa proximité (le cosinus) avec chaque vecteur de l'index et on garde les k plus proches.
2. **Le réordonnancement.** Un second modèle relit chaque paire « question, passage » et la note. Il est plus lent que la recherche vectorielle, mais bien plus fin, d'où son usage sur une courte liste.
3. **La génération.** Le modèle de langage reçoit une consigne, les meilleurs extraits numérotés et la question. On lui demande de répondre à partir des seuls extraits et de les citer.

Anthropic a mesuré l'effet de chaque brique sur ses propres jeux de test : en ajoutant à la recherche vectorielle une recherche par mots-clés (BM25), un contexte ajouté à chaque morceau, puis un réordonnancement, la part des recherches qui ratent le bon passage dans les 20 premiers résultats est passée de 5,7 % à 1,9 %.

## Mise en œuvre pas à pas

L'exemple tourne sur n'importe quel ordinateur où Ollama est installé, sans aucune bibliothèque Python à ajouter. Il interroge quatre petites notes internes d'une entreprise fictive (télétravail, notes de frais, congés, matériel).

1. Téléchargez un modèle de plongement et un modèle de discussion. Prenez le second parmi ceux qui tiennent dans votre mémoire (liste en fin de guide) ; l'exemple utilise `gemma4:26b`.

```bash
ollama pull nomic-embed-text
ollama pull gemma4:26b
```

2. Créez un dossier `docs/` avec vos fichiers Markdown. Le script attend un titre en première ligne, puis des paragraphes séparés par une ligne vide. Exemple, `docs/frais.md` :

```markdown
# Notes de frais

Les notes de frais se saisissent dans l'application Dépenses au plus tard 30 jours après la dépense.

Un repas d'affaires est remboursé jusqu'à 35 euros par personne, sur présentation du justificatif.

Les trajets en train se réservent en seconde classe, sauf pour un trajet de plus de quatre heures.
```

3. Enregistrez le script sous `rag.py`, à côté du dossier `docs/` :

```python
"""RAG minimal avec Ollama : découpage, plongements, recherche, réordonnancement, réponse.
Aucune dépendance : Python 3.10 ou plus et un serveur Ollama sur http://localhost:11434."""
import json, math, sys, urllib.request
from pathlib import Path

OLLAMA = "http://localhost:11434"
EMBED = "nomic-embed-text"      # modèle de plongements (ollama pull nomic-embed-text)
LLM = "gemma4:26b"              # modèle qui répond (n'importe quel modèle de discussion)
INDEX = Path("index.json")


def appel(route, donnees):
    req = urllib.request.Request(f"{OLLAMA}{route}", data=json.dumps(donnees).encode(),
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.load(r)


def plonge(textes, prefixe):
    # nomic-embed-text attend un préfixe de tâche : search_document pour les documents, search_query pour la question.
    r = appel("/api/embed", {"model": EMBED, "input": [f"{prefixe}: {t}" for t in textes]})
    return r["embeddings"]


def decoupe(fichier):
    # Un morceau par paragraphe, précédé du titre du document pour garder le contexte.
    lignes = fichier.read_text(encoding="utf-8").strip().split("\n\n")
    titre = lignes[0].lstrip("# ").strip()
    return [{"source": fichier.name, "texte": f"{titre}. {p.strip()}"} for p in lignes[1:]]


def indexe(dossier):
    morceaux = [m for f in sorted(Path(dossier).glob("*.md")) for m in decoupe(f)]
    vecteurs = plonge([m["texte"] for m in morceaux], "search_document")
    for m, v in zip(morceaux, vecteurs):
        m["vecteur"] = v
    INDEX.write_text(json.dumps(morceaux), encoding="utf-8")
    print(f"{len(morceaux)} morceaux indexés")


def cosinus(a, b):
    # /api/embed rend des vecteurs de longueur 1 : le produit scalaire suffit, la division est là par prudence.
    return sum(x * y for x, y in zip(a, b)) / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))


def reordonne(question, candidats):
    # Le modèle note chaque passage de 0 à 10 ; la réponse est contrainte par un schéma JSON.
    schema = {"type": "object", "properties": {"note": {"type": "integer"}}, "required": ["note"]}
    for c in candidats:
        r = appel("/api/chat", {"model": LLM, "stream": False, "format": schema, "think": False,
                                "options": {"temperature": 0},
                                "messages": [{"role": "user", "content":
                                    f"Question : {question}\nPassage : {c['texte']}\n"
                                    "Note de 0 à 10 l'utilité du passage pour répondre à la question."}]})
        c["note"] = json.loads(r["message"]["content"])["note"]
    return sorted(candidats, key=lambda c: (c["note"], c["score"]), reverse=True)


def demande(question, k=4, garde=2):
    morceaux = json.loads(INDEX.read_text(encoding="utf-8"))
    q = plonge([question], "search_query")[0]
    for m in morceaux:
        m["score"] = cosinus(q, m["vecteur"])
    candidats = sorted(morceaux, key=lambda m: m["score"], reverse=True)[:k]
    print("Recherche vectorielle :")
    for c in candidats:
        print(f"  {c['score']:.3f}  {c['source']:<15} {c['texte'][:52]}…")
    retenus = reordonne(question, candidats)[:garde]
    print("Après réordonnancement :", ", ".join(f"{c['source']} ({c['note']}/10)" for c in retenus))
    contexte = "\n".join(f"[{i + 1}] ({c['source']}) {c['texte']}" for i, c in enumerate(retenus))
    r = appel("/api/chat", {"model": LLM, "stream": False, "think": False, "options": {"temperature": 0},
                            "messages": [
                                {"role": "system", "content": "Réponds en français, en une ou deux phrases, "
                                 "uniquement d'après les extraits fournis, et cite-les par leur numéro. "
                                 "Si les extraits ne contiennent pas la réponse, dis-le."},
                                {"role": "user", "content": f"Extraits :\n{contexte}\n\nQuestion : {question}"}]})
    print("Réponse :", r["message"]["content"].strip())


if __name__ == "__main__":
    if sys.argv[1] == "indexe":
        indexe(sys.argv[2])
    else:
        demande(" ".join(sys.argv[2:]))
```

4. Indexez, puis posez une question :

```bash
python3 rag.py indexe docs
python3 rag.py demande "Combien me rembourse-t-on pour un déjeuner avec un client ?"
```

Voici ce que le script a affiché sur le mini-PC de QUELLE IA :

![Terminal : python3 rag.py indexe docs affiche 12 morceaux indexés ; puis la recherche vectorielle classe quatre morceaux avec des scores de 0,608 à 0,600, frais.md en tête ; le réordonnancement donne 10 sur 10 à frais.md et 0 à conges.md ; la réponse indique qu'un repas d'affaires est remboursé jusqu'à 35 euros par personne sur justificatif, avec la source [1].](https://quelleia.com/guides/rag/terminal-rag.webp)

*Sortie réelle du script de ce guide sur le mini-PC Linux de QUELLE IA, le 17 novembre 2026 (Ollama 0.21.1, nomic-embed-text pour les plongements, gemma4:26b pour la réponse).*

La sortie montre l'intérêt du réordonnancement. Les quatre scores de la recherche vectorielle tiennent entre 0,600 et 0,608 : le modèle de plongement distingue mal ces phrases en français, et la bonne note de frais ne passe en tête que de très peu. La notation par le modèle de langage tranche nettement (10 sur 10 contre 0), et la réponse cite le bon extrait.

> Bon à savoir : le réordonnancement de l'exemple appelle le modèle de discussion une fois par passage, ce qui reste lent. Un vrai modèle de réordonnancement, comme bge-reranker-v2-m3, fait le même travail bien plus vite. Ollama n'a pas de route pour ces modèles ; le serveur de llama.cpp en propose une (`/v1/rerank`), à lancer avec l'option `--reranking`.

## Les pièges

- **Un modèle de plongement anglais sur des textes français.** La fiche de nomic-embed-text ne parle d'aucune autre langue que l'anglais, et la sortie ci-dessus montre des scores très serrés en français. Pour du français, essayez un modèle multilingue : embeddinggemma (Google, entraîné sur plus de 100 langues selon sa fiche Ollama) ou bge-m3 (plus de 100 langues). Mesurez sur vos propres questions avant de choisir.
- **Changer de modèle de plongement sans tout réindexer.** Les vecteurs de deux modèles ne se comparent pas. La documentation d'Ollama le rappelle : le même modèle sert à indexer et à interroger.
- **Oublier les préfixes.** nomic-embed-text exige `search_document:` devant les documents et `search_query:` devant la question, d'après sa fiche. Sans eux, la recherche se dégrade sans message d'erreur.
- **Une fenêtre trop courte pour le modèle de plongement.** Ollama sert nomic-embed-text avec une fenêtre de 2 048 jetons, alors que le modèle en accepte 8 192. Un morceau plus long est tronqué en silence (option `truncate`, active par défaut).
- **Des morceaux sans contexte.** Un paragraphe isolé (« Le plafond est de 35 euros ») ne dit plus de quoi il parle. Le script ajoute le titre du document à chaque morceau ; Anthropic va plus loin en faisant écrire par un modèle une phrase de contexte par morceau.
- **Une réponse qui sort des extraits.** Rien n'empêche le modèle d'inventer. La consigne qui l'oblige à citer et à dire « je ne sais pas » aide, et la citation permet au lecteur de vérifier.

## Coût et matériel

En local, le coût se mesure en mémoire. nomic-embed-text pèse 274 Mo, presque rien à côté du modèle qui répond. Voici les mieux classés qui tiennent dans 32 Go.

**Les meilleurs modèles pour une machine de 32 Go**

1. [Qwen 3.8 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (allégée à 4 bits, 18,6 Go)
2. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (allégée à 4 bits, 21,4 Go)
3. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (allégée à 4 bits, 19,2 Go)
4. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (allégée à 4 bits, 20,7 Go)
5. [Gemma 4 26B A4B](https://quelleia.com/modeles/gemma-4-26b-a4b/) : score 73,1 (allégée à 4 bits, 17,9 Go)

Mémoire utile retenue : 30 Go, celle des machines suivies de 32 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
[Quel modèle sur ma machine](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

Avec une API payante, l'indexation coûte une fois le prix des plongements de tous vos documents, puis chaque question coûte le plongement de la question, plus les jetons d'entrée des extraits et de la consigne, plus la réponse. Le réordonnancement par un modèle de langage, tel que dans l'exemple, multiplie les appels : sur une API, préférez un modèle de réordonnancement dédié.

## Pour aller plus loin

- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Ollama](https://quelleia.com/logitheque/ollama/)
- [Llama cpp](https://quelleia.com/logitheque/llama-cpp/)
- [Glossaire](https://quelleia.com/glossaire/)
- [Plongements (embeddings) : ranger des textes par leur sens](https://quelleia.com/guides/embeddings.md) (guide, expert)
- [Fenêtre de contexte : ce que veut dire « 1 million de jetons »](https://quelleia.com/guides/fenetre-de-contexte.md) (guide, débutant)
- [Réduire la facture d'une API d'IA : cache, lots, modèle, effort](https://quelleia.com/guides/cache-et-couts-de-l-api.md) (guide, expert)
- [Affiner un modèle : LoRA, QLoRA et quand ça vaut le coup](https://quelleia.com/guides/affiner-un-modele.md) (guide, nerd)

## Sources

- https://arxiv.org/abs/2005.11401 (lue le 17 novembre 2026)
- https://www.anthropic.com/engineering/contextual-retrieval (lue le 17 novembre 2026)
- https://docs.ollama.com/capabilities/embeddings (lue le 17 novembre 2026)
- https://docs.ollama.com/api/embed (lue le 17 novembre 2026)
- https://docs.ollama.com/capabilities/structured-outputs (lue le 17 novembre 2026)
- https://huggingface.co/nomic-ai/nomic-embed-text-v1.5 (lue le 17 novembre 2026)
- https://ollama.com/library/nomic-embed-text (lue le 17 novembre 2026)
- https://ollama.com/library/embeddinggemma (lue le 17 novembre 2026)
- https://ollama.com/library/bge-m3 (lue le 17 novembre 2026)
- https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md (lue le 17 novembre 2026)
