Accueil / Articles

Comment RAG permet à un LLM d’accéder à vos données privées : fragments, vecteurs, prompts

Comprendre la génération augmentée par la récupération, de l’ingestion à la requête, à l’aide d’un petit exemple en Node.js, de trois modes de défaillance courants ainsi que d’un tableau comparant RAG et l’ajustement fin.

Éditeur : REACTAPP.TOP8 min de lecture1766 mots

Sources: RAG Explained: How Applications Give AI Access to Their Own Data

Les modèles de langage écrivent du code, expliquent des sujets complexes et rédigent des essais, mais ils se bloquent face à tout ce qui est privé. Si l’on interroge un modèle standard sur le plan stratégique d’un produit interne, une base de données clients ou les tickets de support d’hier, il avoue son ignorance ou, pire encore, produit une fabrication crédible. Cette fausse confiance est appelée hallucination.

On suppose souvent que pour enseigner des données privées à un modèle, il suffit de le fine-tuner, c’est-à-dire de réentraîner ses poids à l’aide de jeux de données personnalisés. Pour un accès simple aux données en production, le fine-tuning est généralement le mauvais choix : il est coûteux, les mises à jour sont lentes et il ne permet pas d’éviter de manière fiable les hallucinations. Les applications en production utilisent plutôt la génération augmentée par récupération de données (RAG), qui fournit des données externes sur demande sans réentraînement. Alors que le fine-tuning équivaut à des semaines d’études pour un étudiant, la RAG correspond à un examen avec le livre ouvert, à la bonne page déjà tournée.

Les trois mots du nom

  • Retrieval signifie rechercher dans sa propre base de données ou son stockage de documents des extraits liés à la question.
  • Augmented signifie coller directement ces extraits dans le contexte de l’instruction.
  • Generation signifie envoyer cette instruction enrichie à l’LLM, qui répond en s’appuyant sur les faits récupérés.

Sans RAG, le processus est simplifié :

Without RAG:
[User Question] ──> [LLM] ──> [Answer based on generic training data]

Avec RAG, une étape de recherche se situe au milieu :

With RAG:
[User Question] ──> [Search Engine / Vector DB]
                          │
                          └──> [Relevant Documents]
                                     │
[User Question] + [Relevant Documents] ──> [LLM] ──> [Factual Answer]

Puisque le matériel source est transmis avec l’instruction, le modèle n’a plus besoin de se remémorer des faits à partir de ses paramètres figés.

Pourquoi les équipes le choisissent

Trois obstacles se présentent lors de l’ajout de fonctionnalités d’IA aux systèmes existants :

  • Coupure des connaissances. Les données d’entraînement s’arrêtent à une date précise, ce qui empêche le modèle de connaître ce qui s’est passé ce matin ou ce qu’une API a renvoyé il y a deux secondes.
  • Confidentialité. Les modèles publics ne peuvent pas lire une wiki interne, un espace de travail Notion ou une base de données MongoDB.
  • Tracabilité. Une réponse produite à partir de la mémoire ne peut pas être rattachée à un enregistrement source. Avec RAG, on sait exactement quel fragment a été inclus dans l’instruction, ce qui facilite les citations.

Une idée reçue fréquente est que le fine-tuning permet d’apprendre de nouveaux faits. En réalité, il ajuste le ton, le style ou le format de sortie. La récupération de connaissances factuelles est précisément l’objectif de RAG.

Deux étapes

Un système de production comprend une étape d’ingestion, qui prépare les fichiers à l’avance, et une étape de requête, qui sert l’utilisateur en temps réel. L’ingestion s’effectue hors ligne :

1. Ingestion Pipeline (Offline / Background):
[Raw Documents] ──> [Chunking] ──> [Embedding Model] ──> [Vector Database]

Le chemin de la requête est exécuté au moment de la demande :

2. Query Pipeline (Runtime):
[User Question] ──> [Embedding Model] ──> [Vector Search in DB]
                                                  │
                                                  ▼
[User Question] + [Top Matching Chunks] ──> [LLM] ──> [Final Answer]

Chunking

Un PDF de 300 pages ne peut pas être traité en une seule requête. Les documents volumineux sont divisés en segments appelés chunks, généralement comprenant de 200 à 800 mots. Un chunk doit être suffisamment petit pour se concentrer sur une seule idée, mais suffisamment grand pour conserver son contexte.

Embedding

Les ordinateurs ne comprennent pas les mots, et la correspondance de mots-clés telle que SQL LIKE '%refund%' échoue lorsque les gens utilisent des synonymes. C’est pourquoi chaque chunk est soumis à un modèle d’embedding qui renvoie une liste de nombres à virgule flottante, un vecteur pouvant contenir jusqu’à 1 536 éléments. Ces vecteurs placent les significations dans un espace géométrique. Les phrases ayant un sens similaire, comme "Comment annuler ?" et "Étapes pour résilier un compte", se trouvent proches les unes des autres, tandis que des phrases sans lien, comme ">Comment cuire du pain au levain", se situent loin les unes des autres.

Les vecteurs sont stockés à côté du texte original dans une base de données vectorielle telle que Pinecone, Qdrant, Milvus ou PostgreSQL avec l’extension pgvector.

Récupération et génération de prompts

Lorsqu’une question arrive, le serveur l’incorpore à l’aide du même modèle. La base de données mesure l’angle entre le vecteur de la question et chaque vecteur stocké (similitude cosinus) et retourne les trois à cinq extraits les plus proches. L’application les insère ensuite dans le prompt du système et indique au LLM de répondre en se basant uniquement sur ces éléments.

Un petit exemple fonctionnel

Imaginons une entreprise de logiciels qui souhaite disposer d’un assistant pour répondre aux questions relatives à sa politique interne de remboursements. Le fichier d’importation commence par l’importation du client OpenAI :

// ingest.js
import { OpenAI } from "openai";

et crée le client :

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

Une application réelle chargerait des documents depuis Markdown ou un CMS, tandis que cet exemple utilise des valeurs codées pour quelques-uns d’entre eux :

// In a real application, you would load these from Markdown files or a CMS
const documents = [
  {
    id: "doc_1",
    text: "Enterprise customers can request a full refund within 30 days of contract signing. Contact enterprise-support@example.com."
  },
  {
    id: "doc_2",
    text: "Monthly self-serve subscriptions are non-refundable once the billing cycle begins. Users can cancel anytime to avoid future charges."
  },
  {
    id: "doc_3",
    text: "Custom engineering work and onboarding packages are strictly non-refundable once the kickoff meeting has taken place."
  }
];

Un outil d’aide transforme le texte en embedding :

async function createEmbedding(text) {
  const response = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: text,
  });
  return response.data[0].embedding;
}

Un autre construit la base de connaissances en intégrant chaque document :

export async function buildKnowledgeBase() {
  const embeddedDocs = [];
  for (const doc of documents) {
    const vector = await createEmbedding(doc.text);
    embeddedDocs.push({ ...doc, vector });
  }
  return embeddedDocs;
}

Dans un environnement de production, la base de données vectorielle effectue le calcul de la distance sur des millions de lignes en quelques millisecondes. À des fins de démonstration, la similarité cosinus peut être calculée manuellement :

// search.js
function cosineSimilarity(vecA, vecB) {
  let dotProduct = 0;
  let normA = 0;
  let normB = 0;
  for (let i = 0; i < vecA.length; i++) {
    dotProduct += vecA[i] * vecB[i];
    normA += vecA[i] * vecA[i];
    normB += vecB[i] * vecB[i];
  }
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

et les meilleures correspondances sélectionnées :

export function findTopMatches(queryVector, knowledgeBase, topK = 2) {
  return knowledgeBase
    .map(doc => ({
      ...doc,
      score: cosineSimilarity(queryVector, doc.vector)
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

Ensuite, un fichier relie la requête, les résultats de recherche et le LLM, en commençant par les importations :

// answer.js
import { OpenAI } from "openai";
import { createEmbedding, buildKnowledgeBase } from "./ingest.js";
import { findTopMatches } from "./search.js";

puis le client à nouveau :

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

La fonction principale insère d’abord la question de l’utilisateur :

async function askKnowledgeBase(userQuestion, knowledgeBase) {
  // 1. Convert user question into an embedding
  const questionVector = await createEmbedding(userQuestion);

puis récupère les plus gros morceaux :

  // 2. Retrieve top matching chunks
  const matches = findTopMatches(questionVector, knowledgeBase, 1);
  const contextText = matches.map(m => m.text).join("\n---\n");

puis crée une instruction enrichie :

  // 3. Augment prompt with retrieved context
  const systemPrompt = `
You are a helpful customer service assistant.
Answer the user's question using ONLY the context provided below.
If the context does not contain the answer, say "I do not have enough information to answer that."

qui se termine par le contexte injecté :

Context:
${contextText}
`;

et finalement génère la réponse :

  // 4. Generate answer
  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: systemPrompt },
      { role: "user", content: userQuestion }
    ],
    temperature: 0.2, // Low temperature minimizes creative liberties
  });

Rétablissement du texte du modèle :

  return completion.choices[0].message.content;
}

Voici un exemple d’utilisation, avec une question concernant le remboursement d’argent après une transaction d’entreprise :

// Example usage:
const knowledgeBase = await buildKnowledgeBase();
const answer = await askKnowledgeBase("I signed an enterprise deal 2 weeks ago, can I get my money back?", knowledgeBase);
console.log(answer);
// Output: Yes, enterprise customers can request a full refund within 30 days of contract signing. You can email enterprise-support@example.com to initiate the process.

La réponse n’a pas été générée à partir des poids de formation généraux du modèle. Elle a tiré la réponse précise du petit extrait injecté en temps de exécution.

Trois erreurs courantes

Un script court donne l’impression que RAG est simple, mais les systèmes réels échouent de trois manières récurrentes.

Division du texte en longueurs fixes. Couper tous les 500 caractères sépare les mots, les phrases et les tableaux. Si une phrase décrivant une condition essentielle est divisée en deux parties, chacune perd son sens. La solution consiste à diviser le texte en segments le long de frontières naturelles telles que des paragraphes, des titres ou des sections Markdown, et à ajouter une superposition, par exemple des segments de 500 tokens partageant 50 tokens.

Se fier uniquement aux vecteurs. La recherche vectorielle comprend les concepts mais gère mal les chaînes de caractères exactes. Une recherche d’un numéro de facture comme INV-2026-09 peut retourner des factures qui ne sont que partiellement similaires. La solution est une recherche hybride : combiner une recherche par mots-clés telle que BM25 ou une recherche de texte complet avec la recherche vectorielle, puis fusionner les scores à l’aide d’une méthode comme Reciprocal Rank Fusion (RRF).

Surcharge du prompt. Les fenêtres de contexte continuent de s’agrandir, mais l’envoi de 50 segments diminue la qualité. Les modèles se souviennent le mieux du matériel situé au début ou à la fin d’un prompt, tandis que le milieu a tendance à être oublié. Retrouvez uniquement les trois à cinq segments les plus fiables. Si davantage de documents doivent être examinés, exécutez un réordonneur léger comme Cohere Rerank avant le modèle LLM principal.

RAG ou affinage

Stockage et appels API ordinaires
Dimension RAG Affinage
Objectif principal Fournir des données factuelles et actualisables Enseigner un style, un dialecte ou une syntaxe stricte
Mises à jour Instantanées, par modification des enregistrements de base de données Lentes, nécessitant de nouvelles données et un reconditionnement
Risque d’hallucination Faible, limité par le contexte fourni Moyen à élevé
Citations Intégrées, puisque l’ID du fragment est connu Impossibles, les faits se mélangent aux poids
Coût de maintenanceCoûts élevés de formation sur GPU et d’hébergement

Lorsque les données changent quotidiennement, hebdomadairement ou horairement, le réglage fin est peu pratique, et RAG est l’architecture conçue pour les connaissances dynamiques.

Début

La partie difficile de la création avec les LLM réside dans l’ancrage factuel, et non dans l’intelligence du modèle. RAG relie un modèle de base statique à des données privées et en évolution, et en combinant une bonne couche de récupération avec des prompts améliorés, on transforme un générateur de texte imprévisible en un système capable de fournir des réponses vérifiables. Un bon point de départ : choisir un stockage vectoriel, diviser les documents en segments pertinents, et s’assurer que la récupération trouve bien le contexte adéquat avant de blâmer l’LLM pour une mauvaise réponse.