1 
2Large Language Models (LLM's) zoals GPT-4 en Claude zijn buitengewoon krachtig, maar ze lijden aan een fundamentele beperking: hun kennis is bevroren op het moment van training. **Retrieval-Augmented Generation (RAG)** lost precies dit probleem op door de generatieve kracht van LLM's te combineren met het vermogen om informatie uit externe bronnen op te halen.
3 
4## Het Probleem: LLM-beperkingen
5 
61.  **Statische kennis**: Een LLM weet alleen wat het zag tijdens training.
72.  **Hallucinaties**: Wanneer een LLM het antwoord niet weet, verzint het er een.
83.  **Geen toegang tot privédata**: Een generiek LLM heeft geen toegang tot je interne documentatie.
9 
10## Wat is RAG?
11 
12RAG is een architectuur die de prompt verrijkt met informatie opgehaald uit een externe kennisbasis.
13 
14```mermaid
15graph LR
16    User["User"] -- "Question" --> Retriever
17    Retriever -- "Search relevant\ndocuments" --> VectorStore["Vector Store"]
18    VectorStore -- "Relevant\ndocuments" --> Retriever
19    Retriever -- "Context + Question" --> LLM
20    LLM -- "Grounded\nresponse" --> User
21```
22 
23## Hoe RAG Werkt
24 
25### Fase 1: Indexering
26 
27```mermaid
28graph TD
29    A["Documents\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
30    B --> C["Text Splitter"]
31    C --> D["Text Chunks"]
32    D --> E["Embedding Model"]
33    E --> F["Numerical Vectors"]
34    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
35```
36 
37### Fase 2: Retrieval + Generation
38 
391.  De vraag wordt omgezet in een embedding.
402.  De Vector Store vindt de meest vergelijkbare chunks.
413.  De opgehaalde chunks worden in de prompt ingevoegd als context.
424.  Het LLM genereert een antwoord op basis van de context.
43 
44## Een RAG Pipeline Bouwen met LangChain
45 
46```bash
47pip install langchain langchain-openai langchain-community chromadb
48```
49 
50### Stap 1: Documenten Laden
51 
52```python
53from langchain_community.document_loaders import (
54    PyPDFLoader,
55    WebBaseLoader,
56    DirectoryLoader,
57    TextLoader,
58)
59 
60# Load a PDF
61pdf_loader = PyPDFLoader("docs/manual.pdf")
62pdf_docs = pdf_loader.load()
63 
64# Load a web page
65web_loader = WebBaseLoader("https://docs.example.com/guide")
66web_docs = web_loader.load()
67 
68# Load all .md files from a directory
69dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
70md_docs = dir_loader.load()
71 
72all_docs = pdf_docs + web_docs + md_docs
73```
74 
75### Stap 2: Documenten Splitsen
76 
77```python
78from langchain.text_splitter import RecursiveCharacterTextSplitter
79 
80text_splitter = RecursiveCharacterTextSplitter(
81    chunk_size=1000,
82    chunk_overlap=200,
83    separators=["\n\n", "\n", ". ", " ", ""],
84)
85 
86chunks = text_splitter.split_documents(all_docs)
87print(f"Original documents: {len(all_docs)}, Chunks: {len(chunks)}")
88```
89 
90### Stap 3: Embeddings en Vector Store
91 
92```python
93from langchain_openai import OpenAIEmbeddings
94from langchain_community.vectorstores import Chroma
95 
96embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
97 
98vectorstore = Chroma.from_documents(
99    documents=chunks,
100    embedding=embedding_model,
101    persist_directory="./chroma_db",
102)
103```
104 
105### Stap 4: De Retriever
106 
107```python
108retriever = vectorstore.as_retriever(
109    search_type="similarity",
110    search_kwargs={"k": 4},
111)
112 
113relevant_docs = retriever.invoke("How does authentication work?")
114for doc in relevant_docs:
115    print(doc.page_content[:200])
116    print("---")
117```
118 
119### Stap 5: De RAG Chain
120 
121```python
122from langchain_openai import ChatOpenAI
123from langchain_core.prompts import ChatPromptTemplate
124from langchain_core.runnables import RunnablePassthrough
125from langchain_core.output_parsers import StrOutputParser
126 
127llm = ChatOpenAI(model="gpt-4o", temperature=0)
128 
129prompt = ChatPromptTemplate.from_template("""
130Answer the question based only on the provided context.
131If the context does not contain enough information, say you don't know.
132 
133Context:
134{context}
135 
136Question: {question}
137 
138Answer:
139""")
140 
141def format_docs(docs):
142    return "\n\n".join(doc.page_content for doc in docs)
143 
144rag_chain = (
145    {"context": retriever | format_docs, "question": RunnablePassthrough()}
146    | prompt
147    | llm
148    | StrOutputParser()
149)
150 
151response = rag_chain.invoke("How does authentication work in the system?")
152print(response)
153```
154 
155## Geavanceerde RAG-technieken
156 
157### Multi-Query Retrieval
158 
159```python
160from langchain.retrievers import MultiQueryRetriever
161 
162multi_retriever = MultiQueryRetriever.from_llm(
163    retriever=vectorstore.as_retriever(),
164    llm=llm,
165)
166```
167 
168### Contextual Compression
169 
170```python
171from langchain.retrievers import ContextualCompressionRetriever
172from langchain.retrievers.document_compressors import LLMChainExtractor
173 
174compressor = LLMChainExtractor.from_llm(llm)
175compression_retriever = ContextualCompressionRetriever(
176    base_compressor=compressor,
177    base_retriever=retriever,
178)
179```
180 
181### Hybrid Search
182 
183```python
184from langchain.retrievers import EnsembleRetriever
185from langchain_community.retrievers import BM25Retriever
186 
187bm25_retriever = BM25Retriever.from_documents(chunks)
188bm25_retriever.k = 4
189 
190semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
191 
192hybrid_retriever = EnsembleRetriever(
193    retrievers=[bm25_retriever, semantic_retriever],
194    weights=[0.4, 0.6],
195)
196```
197 
198### Conversational RAG (met Geheugen)
199 
200```python
201from langchain.chains import create_history_aware_retriever
202from langchain_core.prompts import MessagesPlaceholder
203 
204contextualize_prompt = ChatPromptTemplate.from_messages([
205    ("system", "Given the chat history and the user's latest question, "
206               "reformulate the question so it is understandable without the history."),
207    MessagesPlaceholder("chat_history"),
208    ("human", "{input}"),
209])
210 
211history_aware_retriever = create_history_aware_retriever(
212    llm, retriever, contextualize_prompt
213)
214```
215 
216## Best Practices
217 
2181.  **Kies de juiste chunkgrootte**: Experimenteer met 500-1500 tokens.
2192.  **Gebruik documentmetadata**: Voeg bron, datum en categorie toe als metadata.
2203.  **Evalueer kwaliteit**: Gebruik frameworks zoals [RAGAS](https://docs.ragas.io/).
2214.  **Beheer documentupdates**: Implementeer een her-ingestiepipeline.
2225.  **Voeg een re-ranker toe**: Gebruik een re-ranking model na initiële retrieval.
223 
224## Conclusie
225 
226RAG is de standaardarchitectuur geworden voor AI-applicaties die toegang nodig hebben tot specifieke, actuele kennis. LangChain vereenvoudigt de implementatie enorm.
227