RAG et LangChain : Guide Complet de la Retrieval-Augmented Generation

spinny:~/writing $ vim rag-langchain-deep-dive.md

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~

NORMAL · rag-langchain-deep-dive.md [readonly]288 lines · :q to close

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.

4## Le Problème : Les Limites des LLMs

6Avant de parler de RAG, il est important de comprendre pourquoi nous en avons besoin.

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~