Comprendre le RAG et son implémentation pratique avec LangChain, Bun, Ollama et Qdrant

Les Large Language Models (LLMs) modernes sont impressionnants, mais ils ont une limite majeure : leur connaissance est figée, ce qui rend difficile la mise à jour et l'extension de leur savoir. Le Retrieval-Augmented Generation (RAG) est une approche conçue pour pallier ce problème. Introduite par Meta en 2020, elle connecte un modèle de langage à une base de connaissances externe (par exemple un ensemble de documents) afin qu'il puisse intégrer des informations à jour et spécifiques dans ses réponses. Concrètement, à chaque question posée, le système RAG va d'abord extraire du contenu pertinent dans sa base documentaire, puis générer une réponse en combinant ce contexte récupéré et les capacités linguistiques du LLM.

Note : Le code source complet du projet d'exemple mentionné dans cet article est disponible sur GitHub.

Plan de l'Article

1. Qu'est-ce que le RAG et pourquoi l'utiliser ?

   • Principe de fonctionnement
   • Avantages par rapport aux approches classiques
   • Cas d'usage concrets

2. Architecture d'un système RAG

   • Composants essentiels
   • Flux de données
   • Choix technologiques

3. Implémentation pratique avec TypeScript

   • Setup du projet avec Bun
   • Intégration de LangChain
   • Configuration d'Ollama et Qdrant

4. Analyse du code et bonnes pratiques

   • Indexation des documents
   • Recherche sémantique
   • Génération de réponses

5. Avantages de la stack technique

   • Performance de Bun vs Node.js
   • Simplicité de LangChain
   • Flexibilité d'Ollama
   • Scalabilité de Qdrant

6. Pour aller plus loin

   • Optimisations avancées
   • Évaluation et métriques
   • Alternatives technologiques

Qu'est-ce que le RAG et pourquoi l'utiliser ?

Retrieval-Augmented Generation (RAG) signifie littéralement « génération augmentée par récupération ». L'idée est de séparer la connaissance du modèle. Au lieu d'essayer d'incorporer toutes les informations dans les paramètres d'un LLM (par un fine-tuning coûteux) ou de concevoir un modèle classique qui prédirait des réponses à partir de données, on laisse le modèle principal générer du texte et on l'augmente avec une étape intermédiaire de recherche d'information. Un pipeline RAG typique fonctionne ainsi :

1. Requête de l'utilisateur – L'utilisateur pose une question ou fournit une requête en langage naturel (par ex. « À quoi sert la classe X dans ce projet ? »).
2. Recherche de documents pertinents – Le système transforme cette question en une représentation vectorielle (embedding) puis interroge une base de données vectorielle pour retrouver les documents ou passages les plus similaires sémantiquement à la requête. Cela permet d'identifier le contexte pertinent (par ex. un extrait de documentation, de code ou d'article correspondant à la question).
3. Combinaison contexte + question – Les documents ou extraits récupérés sont ensuite fournis en contexte du modèle de langage. Concrètement, on va les insérer dans l'invite (prompt) du LLM, typiquement via un message système ou en préfixant la question utilisateur par le texte des documents trouvés.
4. Génération de la réponse – Le modèle de langage (LLM) génère alors une réponse en s'appuyant à la fois sur la question et le contexte fourni. La réponse devrait contenir l'information issue des documents, formulée de manière cohérente grâce aux capacités du LLM.

Ce procédé permet au modèle de s'appuyer sur des connaissances externes spécifiques au moment de la génération, sans avoir à les mémoriser définitivement. On peut comparer cela à un humain qui, face à une question, irait consulter des livres ou des documents de référence avant de répondre : le LLM "cherche dans sa bibliothèque" avant de parler.

Cas d'usage concrets du RAG

L'approche RAG est particulièrement utile dès qu'un assistant conversationnel doit manipuler une base de connaissances évolutive ou volumineuse. Voici quelques exemples de cas d'usage concrets où RAG excelle par rapport aux méthodes classiques :

Chatbots documentaires : Un assistant alimenté par la documentation technique d'une entreprise, capable de répondre aux questions des développeurs ou clients en puisant directement dans les manuels, les bases de connaissances internes ou même le code source. Par exemple, on peut connecter le modèle aux spécifications d'API ou au code d'un projet open-source pour qu'il explique le fonctionnement d'une fonction ou la raison d'un certain design.

FAQ dynamiques : Dans un contexte de support client, un chatbot RAG peut répondre aux questions courantes (FAQ) en s'appuyant sur les dernières politiques ou données produits. Si une politique (ex: conditions de retour) change, il suffit de mettre à jour le document de référence et le bot en tiendra compte instantanément, sans nécessiter de ré-entraînement. On obtient ainsi des FAQ toujours à jour, avec la possibilité de fournir la source de l'information à l'appui de la réponse.

Assistants juridiques : Un assistant peut aider des avocats ou des juristes en retrouvant dans une base de lois, de jurisprudences ou de contrats les passages pertinents pour une question donnée, puis en formulant la réponse en langage naturel. Le modèle n'a pas besoin de connaître par cœur tout le Code civil ; il lui suffit de chercher les articles appropriés. Il en va de même pour un assistant médical, qui pourrait interroger des bases de publications scientifiques ou de protocoles médicaux pour fournir des réponses fondées sur les dernières connaissances cliniques.

Assistant de programmation : C'est le cas de notre projet d'exemple – un assistant qui connaît le contenu d'un dépôt de code et peut répondre aux questions sur ce code (architecture, rôle d'un module, présence de bugs potentiels, etc.). Plutôt que d'entraîner un modèle spécialisé en programmation, on utilise un LLM généraliste augmenté par la recherche de fichiers de code pertinents dans le dépôt.

Architecture d'un système RAG

Composants essentiels

Un système RAG complet comprend généralement les composants suivants :

1. Indexation et stockage

   • Processeur de documents (extraction, nettoyage, chunking)
   • Générateur d'embeddings (transformation en vecteurs)
   • Base de données vectorielle (stockage et recherche)

2. Pipeline de requête

   • Préprocesseur de requête
   • Moteur de recherche sémantique
   • Générateur de prompts

3. Génération et post-traitement

   • Interface avec le LLM
   • Évaluateur de réponses
   • Formateur de sortie

Flux de données

typescript
1// Exemple simplifié du flux de données dans un système RAG
2async function processQuery(query: string): Promise<string> {
3  // 1. Transformer la requête en embedding
4  const queryEmbedding = await embedder.embedQuery(query);
5  
6  // 2. Rechercher les documents pertinents
7  const relevantDocs = await vectorStore.similaritySearch(queryEmbedding);
8  
9  // 3. Construire le prompt avec le contexte
10  const prompt = buildPromptWithContext(query, relevantDocs);
11  
12  // 4. Générer la réponse avec le LLM
13  const response = await llm.generate(prompt);
14  
15  return response;
16}

Choix technologiques

Pour notre implémentation, nous avons choisi une stack moderne et performante :

• Bun : Runtime JavaScript ultra-rapide, idéal pour les applications serveur
• TypeScript : Typage statique pour une meilleure maintenabilité
• LangChain : Framework pour construire des applications basées sur les LLMs
• Ollama : Outil pour exécuter des modèles de langage localement
• Qdrant : Base de données vectorielle performante et facile à déployer

Cette combinaison offre un excellent équilibre entre performance, facilité de développement et flexibilité.

Implémentation pratique avec TypeScript

Setup du projet avec Bun

Commençons par initialiser notre projet :

bash
1# Création du projet
2mkdir rag-code-assistant
3cd rag-code-assistant
4bun init
5
6# Installation des dépendances
7bun add langchain @langchain/community @langchain/openai
8bun add qdrant-js ollama
9bun add -d typescript @types/node

Configuration de base

typescript
1// src/config.ts
2export const CONFIG = {
3  // Configuration Ollama
4  OLLAMA_BASE_URL: 'http://localhost:11434',
5  OLLAMA_MODEL_NAME: 'llama3',
6  
7  // Configuration Qdrant
8  QDRANT_URL: 'http://localhost:6333',
9  QDRANT_COLLECTION_NAME: 'code_repository',
10  
11  // Configuration de l'indexation
12  CHUNK_SIZE: 1000,
13  CHUNK_OVERLAP: 200,
14  
15  // Chemin vers le dépôt de code à indexer
16  REPOSITORY_PATH: './repository',
17};

Indexation des documents

L'indexation est une étape cruciale dans un système RAG. Elle consiste à transformer les documents bruts en chunks (morceaux) de taille appropriée, puis à générer des embeddings pour chaque chunk.

typescript
1// src/indexer.ts
2import { DirectoryLoader } from 'langchain/document_loaders/fs/directory';
3import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
4import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
5import { QdrantClient } from 'qdrant-js';
6import { CONFIG } from './config';
7
8export async function indexRepository() {
9  // 1. Chargement des fichiers du dépôt
10  const loader = new DirectoryLoader(
11    CONFIG.REPOSITORY_PATH,
12    {
13      '.ts': (path) => new TextLoader(path),
14      '.js': (path) => new TextLoader(path),
15      '.tsx': (path) => new TextLoader(path),
16      '.jsx': (path) => new TextLoader(path),
17      '.md': (path) => new TextLoader(path),
18    }
19  );
20  
21  const docs = await loader.load();
22  console.log(`Chargement de ${docs.length} fichiers terminé`);
23  
24  // 2. Découpage en chunks
25  const textSplitter = new RecursiveCharacterTextSplitter({
26    chunkSize: CONFIG.CHUNK_SIZE,
27    chunkOverlap: CONFIG.CHUNK_OVERLAP,
28  });
29  
30  const chunks = await textSplitter.splitDocuments(docs);
31  console.log(`Création de ${chunks.length} chunks terminée`);
32  
33  // 3. Génération des embeddings
34  const embeddings = new OllamaEmbeddings({
35    baseUrl: CONFIG.OLLAMA_BASE_URL,
36    model: CONFIG.OLLAMA_MODEL_NAME,
37  });
38  
39  // 4. Stockage dans Qdrant
40  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
41  
42  // Création de la collection si elle n'existe pas
43  try {
44    await qdrant.createCollection(CONFIG.QDRANT_COLLECTION_NAME, {
45      vectors: {
46        size: 1536, // Taille des vecteurs d'embedding
47        distance: 'Cosine',
48      },
49    });
50  } catch (e) {
51    console.log('Collection existe déjà ou erreur:', e.message);
52  }
53  
54  // Insertion des documents avec leurs embeddings
55  for (let i = 0; i < chunks.length; i += 100) {
56    const batch = chunks.slice(i, i + 100);
57    const batchEmbeddings = await embeddings.embedDocuments(
58      batch.map(chunk => chunk.pageContent)
59    );
60    
61    await qdrant.upsert(CONFIG.QDRANT_COLLECTION_NAME, {
62      points: batchEmbeddings.map((vector, idx) => ({
63        id: `${i + idx}`,
64        vector,
65        payload: {
66          text: batch[idx].pageContent,
67          metadata: batch[idx].metadata,
68        },
69      })),
70    });
71    
72    console.log(`Traitement du batch ${i}-${i + batch.length} terminé`);
73  }
74  
75  console.log('Indexation terminée avec succès!');
76}

Recherche et génération de réponses

typescript
1// src/rag.ts
2import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
3import { QdrantClient } from 'qdrant-js';
4import { Ollama } from '@langchain/community/llms/ollama';
5import { CONFIG } from './config';
6
7export async function generateResponse(query: string): Promise<string> {
8  // 1. Initialisation des composants
9  const embeddings = new OllamaEmbeddings({
10    baseUrl: CONFIG.OLLAMA_BASE_URL,
11    model: CONFIG.OLLAMA_MODEL_NAME,
12  });
13  
14  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
15  
16  const llm = new Ollama({
17    baseUrl: CONFIG.OLLAMA_BASE_URL,
18    model: CONFIG.OLLAMA_MODEL_NAME,
19  });
20  
21  // 2. Génération de l'embedding de la requête
22  const queryEmbedding = await embeddings.embedQuery(query);
23  
24  // 3. Recherche des documents pertinents
25  const searchResults = await qdrant.search(CONFIG.QDRANT_COLLECTION_NAME, {
26    vector: queryEmbedding,
27    limit: 5,
28  });
29  
30  const relevantDocs = searchResults.map(result => result.payload.text).join('\n\n');
31  
32  // 4. Construction du prompt avec le contexte
33  const prompt = `
34  Tu es un assistant de programmation expert qui aide à comprendre le code source d'un projet.
35  Utilise le contexte suivant pour répondre à la question de l'utilisateur.
36  Si tu ne trouves pas l'information dans le contexte, dis-le clairement.
37  
38  CONTEXTE:
39  ${relevantDocs}
40  
41  QUESTION: ${query}
42  
43  RÉPONSE:
44  `;
45  
46  // 5. Génération de la réponse
47  const response = await llm.call(prompt);
48  
49  return response;
50}

Interface utilisateur simple

typescript
1// src/index.ts
2import { indexRepository } from './indexer';
3import { generateResponse } from './rag';
4
5async function main() {
6  // Argument pour indexer ou interroger
7  const args = process.argv.slice(2);
8  
9  if (args[0] === 'index') {
10    console.log('Démarrage de l'indexation...');
11    await indexRepository();
12  } else if (args[0] === 'query') {
13    const query = args.slice(1).join(' ');
14    if (!query) {
15      console.log('Usage: bun run src/index.ts query "Votre question sur le code"');
16      process.exit(1);
17    }
18    
19    console.log(`Question: ${query}`);
20    console.log('Génération de la réponse...');
21    const response = await generateResponse(query);
22    console.log('\nRéponse:');
23    console.log(response);
24  } else {
25    console.log('Usage: bun run src/index.ts [index|query "Votre question"]');
26  }
27}
28
29main().catch(console.error);

Analyse du code et bonnes pratiques

Chunking efficace

Le découpage des documents en chunks est une étape critique qui influence directement la qualité des résultats. Quelques bonnes pratiques :

• Taille adaptée : Les chunks doivent être suffisamment grands pour contenir du contexte, mais pas trop pour rester pertinents (généralement entre 500 et 1500 caractères).
• Chevauchement : Un chevauchement entre chunks (overlap) permet de ne pas perdre de contexte aux frontières.
• Découpage sémantique : Idéalement, le découpage devrait respecter la structure sémantique des documents (paragraphes, fonctions, etc.).

Optimisation des recherches

La qualité de la recherche sémantique est essentielle :

• Filtres métadonnées : Utiliser les métadonnées (type de fichier, date, auteur) pour affiner les recherches.
• Re-ranking : Appliquer un second niveau de filtrage pour améliorer la pertinence.
• Diversité : Assurer une diversité dans les résultats pour couvrir différents aspects de la question.

Prompting avancé

La construction du prompt est un art qui influence fortement la qualité des réponses :

typescript
1// Exemple de prompt plus avancé
2const prompt = `
3# RÔLE
4Tu es un assistant de programmation expert spécialisé dans l'analyse de code source.
5
6# CONTEXTE
7${relevantDocs}
8
9# INSTRUCTIONS
10- Réponds à la question de l'utilisateur en te basant uniquement sur le contexte fourni
11- Si le contexte ne contient pas l'information nécessaire, indique-le clairement
12- Cite les extraits de code pertinents dans ta réponse
13- Explique le code de manière pédagogique
14- Suggère des améliorations si tu en identifies
15
16# QUESTION
17${query}
18`;

Avantages de la stack technique

Performance de Bun vs Node.js

Bun offre des avantages significatifs pour ce type d'application :

• Démarrage rapide : Temps de démarrage jusqu'à 4x plus rapide que Node.js
• Exécution optimisée : Performances d'exécution supérieures, particulièrement pour les opérations d'I/O
• Bundler intégré : Simplification du workflow de développement

Simplicité de LangChain

LangChain facilite considérablement le développement d'applications basées sur les LLMs :

• Abstraction : Interface unifiée pour différents modèles et fournisseurs
• Composants réutilisables : Chaînes, agents et outils prêts à l'emploi
• Patterns établis : Implémentations de référence pour les cas d'usage courants

Flexibilité d'Ollama

Ollama permet d'exécuter des modèles de langage localement avec une grande flexibilité :

• Modèles locaux : Pas de dépendance à des API externes
• Confidentialité : Les données restent sur votre infrastructure
• Personnalisation : Possibilité d'ajuster les modèles selon vos besoins

Scalabilité de Qdrant

Qdrant est une base de données vectorielle moderne conçue pour la recherche sémantique :

• Performance : Optimisée pour les recherches de similarité rapides
• Filtrage : Capacités avancées de filtrage sur les métadonnées
• Déploiement flexible : Utilisable en mode embarqué ou comme service

Pour aller plus loin

Optimisations avancées

• Hybrid search : Combiner recherche vectorielle et recherche par mots-clés
• Chunking hiérarchique : Utiliser différents niveaux de granularité pour les chunks
• Caching : Mettre en cache les résultats de recherche et les réponses fréquentes

Évaluation et métriques

Pour mesurer la qualité d'un système RAG :

• Pertinence : Les documents récupérés sont-ils pertinents pour la question ?
• Fidélité : La réponse est-elle fidèle aux documents sources ?
• Utilité : La réponse répond-elle effectivement à la question de l'utilisateur ?

Alternatives technologiques

• Frameworks : Haystack, LlamaIndex comme alternatives à LangChain
• Bases vectorielles : Pinecone, Weaviate, Milvus comme alternatives à Qdrant
• Modèles : Différents modèles locaux (Llama, Mistral) ou API (OpenAI, Anthropic)

Conclusion

Le Retrieval-Augmented Generation représente une avancée majeure dans la façon dont nous pouvons exploiter les modèles de langage pour des cas d'usage spécifiques. En séparant la connaissance du modèle de génération, RAG permet de créer des assistants IA plus précis, plus à jour et plus transparents.

Notre implémentation avec TypeScript, Bun, LangChain, Ollama et Qdrant démontre qu'il est désormais possible de construire des systèmes RAG performants avec des technologies modernes et accessibles. Cette approche ouvre la voie à une nouvelle génération d'assistants IA capables de raisonner sur des bases de connaissances spécifiques tout en conservant la fluidité et la cohérence des grands modèles de langage.

N'hésitez pas à explorer le code source complet sur GitHub et à l'adapter à vos propres cas d'usage. Le RAG est une technologie en pleine évolution, et les possibilités d'innovation sont nombreuses dans ce domaine passionnant.