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~