1 
2Les Large Language Models (LLMs) comme GPT-4 et Claude sont extraordinairement puissants, mais ils souffrent d'une limitation fondamentale : leurs connaissances sont figées au moment de l'entraînement. Ils ne peuvent pas accéder à vos documents internes, à votre base de données ou à des informations en temps réel. La **Retrieval-Augmented Generation (RAG)** résout exactement ce problème en combinant la puissance générative des LLMs avec la capacité de récupérer des informations à partir de sources externes.
3 
4## Le Problème : Les Limites des LLMs
5 
6Avant de parler de RAG, il est important de comprendre pourquoi nous en avons besoin.
7 
81.  **Connaissances statiques** : Un LLM ne sait que ce qu'il a vu pendant l'entraînement. Si vous lui demandez un événement survenu après sa date de coupure, il ne peut pas répondre.
92.  **Hallucinations** : Quand un LLM ne connaît pas la réponse, il a tendance à en inventer une, générant des informations plausibles mais complètement fausses.
103.  **Pas d'accès aux données privées** : Un LLM générique n'a pas accès à la documentation interne de votre entreprise, aux tickets ou à votre base de code.
11 
12La RAG résout ces trois problèmes en fournissant au modèle un **contexte pertinent** récupéré depuis des sources externes au moment de la requête.
13 
14## Qu'est-ce que la RAG ?
15 
16La Retrieval-Augmented Generation est une architecture qui enrichit le prompt envoyé à un LLM avec des informations récupérées depuis une base de connaissances externe. Au lieu de s'appuyer uniquement sur les connaissances paramétriques du modèle, la RAG **recherche** d'abord les informations pertinentes puis les **injecte** dans le prompt, permettant au modèle de générer des réponses précises et fondées.
17 
18```mermaid
19graph LR
20    User["Utilisateur"] -- "Question" --> Retriever
21    Retriever -- "Recherche documents\npertinents" --> VectorStore["Vector Store"]
22    VectorStore -- "Documents\npertinents" --> Retriever
23    Retriever -- "Contexte + Question" --> LLM
24    LLM -- "Réponse\nfondée" --> User
25```
26 
27## Comment la RAG Fonctionne en Détail
28 
29L'architecture RAG se compose de deux phases principales : l'**Indexation** (hors ligne) et la **Récupération + Génération** (en ligne).
30 
31### Phase 1 : Indexation (Ingestion des Documents)
32 
33La phase d'indexation prépare vos documents pour la recherche sémantique. Elle se compose de quatre étapes.
34 
35```mermaid
36graph TD
37    A["Documents\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
38    B --> C["Text Splitter"]
39    C --> D["Chunks de Texte"]
40    D --> E["Modèle d'Embedding"]
41    E --> F["Vecteurs Numériques"]
42    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
43```
44 
45#### 1. Chargement des Documents
46 
47Les documents peuvent provenir de n'importe quelle source : fichiers PDF, pages web, bases de données, fichiers Markdown, APIs. Le **Document Loader** lit ces documents et les convertit en texte structuré.
48 
49#### 2. Découpage du Texte (Chunking)
50 
51Les LLMs ont une fenêtre de contexte limitée, et les documents peuvent être très longs. Le **Text Splitter** divise les documents en fragments plus petits appelés *chunks*. La qualité du chunking est critique : des chunks trop petits perdent le contexte, des chunks trop grands diluent la pertinence.
52 
53Les stratégies les plus courantes sont :
54-   **Recursive Character Splitting** : Divise le texte récursivement en utilisant des séparateurs comme `\n\n`, `\n`, `. `, en respectant la structure du document.
55-   **Semantic Splitting** : Utilise les embeddings pour trouver les points de rupture naturels dans le texte.
56-   **Chunk Overlap** : Inclut un chevauchement entre les chunks consécutifs pour préserver le contexte aux frontières.
57 
58#### 3. Embedding
59 
60Chaque chunk est transformé en un **vecteur numérique** (embedding) via un modèle d'embedding (comme `text-embedding-3-small` d'OpenAI). Ces vecteurs capturent le sens sémantique du texte : des phrases avec des significations similaires auront des vecteurs proches dans l'espace multidimensionnel.
61 
62#### 4. Vector Store
63 
64Les vecteurs sont sauvegardés dans un **Vector Store** (ou base de données vectorielle), comme ChromaDB, Pinecone, Weaviate ou FAISS. Cette base de données est optimisée pour la **recherche de similarité** : étant donné une requête, elle trouve les vecteurs (et donc les chunks de texte) les plus similaires.
65 
66### Phase 2 : Récupération + Génération
67 
68Quand l'utilisateur pose une question :
69 
701.  La question est transformée en embedding en utilisant le même modèle d'embedding.
712.  Le Vector Store trouve les chunks les plus similaires via la **recherche de similarité** (typiquement la similarité cosinus ou la distance euclidienne).
723.  Les chunks récupérés sont insérés dans le prompt comme contexte.
734.  Le LLM génère la réponse basée sur le contexte fourni.
74 
75## Construire une Pipeline RAG avec LangChain
76 
77**LangChain** est le framework Python (et JavaScript) le plus populaire pour construire des applications basées sur les LLMs. Il fournit des abstractions de haut niveau pour chaque composant de la pipeline RAG.
78 
79### Installation
80 
81```bash
82pip install langchain langchain-openai langchain-community chromadb
83```
84 
85### Étape 1 : Charger les Documents
86 
87LangChain fournit des dizaines de Document Loaders pour différentes sources de données.
88 
89```python
90from langchain_community.document_loaders import (
91    PyPDFLoader,
92    WebBaseLoader,
93    DirectoryLoader,
94    TextLoader,
95)
96 
97# Charger un PDF
98pdf_loader = PyPDFLoader("docs/manuel.pdf")
99pdf_docs = pdf_loader.load()
100 
101# Charger une page web
102web_loader = WebBaseLoader("https://docs.example.com/guide")
103web_docs = web_loader.load()
104 
105# Charger tous les fichiers .md d'un répertoire
106dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
107md_docs = dir_loader.load()
108 
109all_docs = pdf_docs + web_docs + md_docs
110```
111 
112### Étape 2 : Découper les Documents en Chunks
113 
114```python
115from langchain.text_splitter import RecursiveCharacterTextSplitter
116 
117text_splitter = RecursiveCharacterTextSplitter(
118    chunk_size=1000,
119    chunk_overlap=200,
120    separators=["\n\n", "\n", ". ", " ", ""],
121)
122 
123chunks = text_splitter.split_documents(all_docs)
124print(f"Documents originaux : {len(all_docs)}, Chunks : {len(chunks)}")
125```
126 
127Le paramètre `chunk_overlap` est crucial : il crée un chevauchement entre les chunks consécutifs pour que le contexte ne soit pas perdu aux frontières.
128 
129### Étape 3 : Créer les Embeddings et le Vector Store
130 
131```python
132from langchain_openai import OpenAIEmbeddings
133from langchain_community.vectorstores import Chroma
134 
135embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
136 
137vectorstore = Chroma.from_documents(
138    documents=chunks,
139    embedding=embedding_model,
140    persist_directory="./chroma_db",
141)
142```
143 
144### Étape 4 : Créer le Retriever
145 
146Le retriever est le composant qui, étant donné une requête, récupère les chunks les plus pertinents du vector store.
147 
148```python
149retriever = vectorstore.as_retriever(
150    search_type="similarity",
151    search_kwargs={"k": 4},
152)
153 
154relevant_docs = retriever.invoke("Comment fonctionne l'authentification ?")
155for doc in relevant_docs:
156    print(doc.page_content[:200])
157    print("---")
158```
159 
160### Étape 5 : Construire la Chain RAG
161 
162Maintenant, assemblons le tout avec un LLM et un template de prompt.
163 
164```python
165from langchain_openai import ChatOpenAI
166from langchain_core.prompts import ChatPromptTemplate
167from langchain_core.runnables import RunnablePassthrough
168from langchain_core.output_parsers import StrOutputParser
169 
170llm = ChatOpenAI(model="gpt-4o", temperature=0)
171 
172prompt = ChatPromptTemplate.from_template("""
173Réponds à la question en te basant uniquement sur le contexte fourni.
174Si le contexte ne contient pas assez d'informations, dis que tu ne sais pas.
175 
176Contexte :
177{context}
178 
179Question : {question}
180 
181Réponse :
182""")
183 
184def format_docs(docs):
185    return "\n\n".join(doc.page_content for doc in docs)
186 
187rag_chain = (
188    {"context": retriever | format_docs, "question": RunnablePassthrough()}
189    | prompt
190    | llm
191    | StrOutputParser()
192)
193 
194response = rag_chain.invoke("Comment fonctionne l'authentification dans le système ?")
195print(response)
196```
197 
198## Techniques RAG Avancées
199 
200La pipeline de base fonctionne bien, mais il existe plusieurs techniques pour améliorer significativement la qualité des réponses.
201 
202### Multi-Query Retrieval
203 
204Parfois, la requête de l'utilisateur est ambiguë ou n'est pas alignée avec le langage utilisé dans les documents. Le **Multi-Query Retriever** génère automatiquement des variantes de la question originale pour capturer plusieurs perspectives.
205 
206```python
207from langchain.retrievers import MultiQueryRetriever
208 
209multi_retriever = MultiQueryRetriever.from_llm(
210    retriever=vectorstore.as_retriever(),
211    llm=llm,
212)
213 
214docs = multi_retriever.invoke("Quelles sont les bonnes pratiques de sécurité ?")
215```
216 
217### Contextual Compression
218 
219Tout le contenu d'un chunk n'est pas pertinent pour la requête. Le **Contextual Compression Retriever** utilise un LLM pour extraire uniquement les parties pertinentes de chaque chunk récupéré.
220 
221```python
222from langchain.retrievers import ContextualCompressionRetriever
223from langchain.retrievers.document_compressors import LLMChainExtractor
224 
225compressor = LLMChainExtractor.from_llm(llm)
226compression_retriever = ContextualCompressionRetriever(
227    base_compressor=compressor,
228    base_retriever=retriever,
229)
230```
231 
232### Hybrid Search
233 
234La recherche purement sémantique n'est pas toujours optimale. L'**Hybrid Search** combine la recherche sémantique (embeddings) avec la recherche lexicale (BM25, correspondance de mots-clés) pour obtenir de meilleurs résultats.
235 
236```python
237from langchain.retrievers import EnsembleRetriever
238from langchain_community.retrievers import BM25Retriever
239 
240bm25_retriever = BM25Retriever.from_documents(chunks)
241bm25_retriever.k = 4
242 
243semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
244 
245hybrid_retriever = EnsembleRetriever(
246    retrievers=[bm25_retriever, semantic_retriever],
247    weights=[0.4, 0.6],
248)
249```
250 
251### RAG Conversationnel (avec Mémoire)
252 
253Pour construire un chatbot RAG qui se souvient du contexte de la conversation, il faut ajouter une mémoire qui reformule les questions de l'utilisateur en tenant compte de l'historique.
254 
255```python
256from langchain.chains import create_history_aware_retriever
257from langchain_core.prompts import MessagesPlaceholder
258 
259contextualize_prompt = ChatPromptTemplate.from_messages([
260    ("system", "Étant donné l'historique du chat et la dernière question de l'utilisateur, "
261               "reformule la question pour qu'elle soit compréhensible sans l'historique."),
262    MessagesPlaceholder("chat_history"),
263    ("human", "{input}"),
264])
265 
266history_aware_retriever = create_history_aware_retriever(
267    llm, retriever, contextualize_prompt
268)
269```
270 
271## Bonnes Pratiques
272 
2731.  **Choisir la bonne taille de chunk** : Expérimentez avec différentes tailles (500-1500 tokens). Des chunks plus petits pour des réponses précises, plus grands pour un contexte élargi.
2742.  **Utiliser les métadonnées des documents** : Ajoutez source, date et catégorie comme métadonnées aux chunks. Cela permet de filtrer les résultats lors de la récupération.
2753.  **Évaluer la qualité** : Utilisez des frameworks comme [RAGAS](https://docs.ragas.io/) pour mesurer des métriques telles que la *faithfulness*, la *relevancy* et la *context precision*.
2764.  **Gérer les mises à jour des documents** : Implémentez un pipeline de ré-ingestion pour maintenir le vector store synchronisé avec vos sources de données.
2775.  **Ajouter un re-ranker** : Après la récupération initiale, utilisez un modèle de re-ranking (comme Cohere Rerank) pour réordonner les résultats selon la pertinence réelle.
278 
279## Conclusion
280 
281La RAG est devenue l'architecture standard pour construire des applications IA qui nécessitent un accès à des connaissances spécifiques et à jour. LangChain simplifie énormément l'implémentation en fournissant des abstractions pour chaque composant de la pipeline.
282 
283**Prochaines étapes :**
284- **Expérimenter en local** : Commencez avec ChromaDB et quelques documents pour vous familiariser avec la pipeline.
285- **Explorer LangSmith** : Utilisez [LangSmith](https://smith.langchain.com/) pour surveiller et déboguer vos chains en production.
286- **Essayer différents modèles d'embedding** : Comparez des modèles comme `text-embedding-3-small`, `text-embedding-3-large` et des modèles open-source de Sentence Transformers.
287- **Consulter la documentation** : La [documentation LangChain](https://python.langchain.com/docs/) est une ressource excellente et constamment mise à jour.
288