De gegevens voorbereiden
Op deze pagina
De kwaliteit van RAG hangt af van uw gegevens
Een RAG-pipeline is slechts zo goed als de gegevens die deze indexeert. U kunt de perfecte prompt ontwerpen en het beste generatiemodel selecteren, maar als het opgehaalde fragment een definitie doormidden snijdt of een repetitieve voettekst bevat in plaats van nuttige tekst, zal uw antwoord eronder lijden. De voorbereiding verloopt in drie fasen: de gegevens ophalen waar ze zich bevinden, alles wat betekenisloos is verwijderen, en de tekst splitsen in fragmenten die geoptimaliseerd zijn voor indexering.
Gegevens ophalen
Corpora uit de praktijk zijn zelden homogeen. Doorgaans heeft u te maken met Markdown-documentatie in een repository, enkele pagina’s van een openbare website en een handvol regelgevende PDF-bestanden. Elke bron vereist zijn eigen loader, maar ze moeten allemaal dezelfde structuur produceren—inhoud, bron en type—zodat de rest van de pipeline onafhankelijk blijft van de herkomst van de tekst.
Voor tekstbestanden volstaat een recursieve directory-walk; filteren op extensie voorkomt dat u per ongeluk binaire bestanden laadt.
import os
def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
"""Load all text files from a directory."""
documents = []
for root, dirs, files in os.walk(directory):
for f in files:
if any(f.endswith(ext) for ext in extensions):
filepath = os.path.join(root, f)
with open(filepath, "r", encoding="utf-8") as fh:
content = fh.read()
documents.append({
"content": content,
"source": filepath,
"type": "text",
})
return documents
docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")
Webpagina’s komen binnen via HTTP, maar wat u ontvangt is HTML. De onderstaande extractie verwijdert tags met behulp van reguliere expressies en vouwt meerdere spaties samen. Dit volstaat voor een prototype, maar de opmerking herinnert u eraan dat BeautifulSoup in een productieomgeving veel beter omgaat met tabellen en geneste lijsten.
import requests
def fetch_web_page(url):
"""Fetch the text content of a web page."""
response = requests.get(url)
response.raise_for_status()
# Basic text extraction (use BeautifulSoup for production)
text = response.text
# Remove HTML tags
import re
text = re.sub(r'<[^>]+>', ' ', text)
text = re.sub(r'\s+', ' ', text).strip()
return {
"content": text,
"source": url,
"type": "web",
}
# Example
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")
PDF’s verdienen een speciale behandeling. In plaats van het hele document aaneen te plakken, houdt u één entry per pagina aan en codeert u het paginanummer in de bron als file.pdf#page=12. Wanneer uw assistent deze passage citeert, weet de gebruiker precies waar deze geverifieerd kan worden.
# pip install PyPDF2
from PyPDF2 import PdfReader
def load_pdf(filepath):
"""Extract text from a PDF."""
reader = PdfReader(filepath)
pages = []
for i, page in enumerate(reader.pages):
text = page.extract_text()
if text.strip():
pages.append({
"content": text,
"source": f"{filepath}#page={i+1}",
"type": "pdf",
"page": i + 1,
})
return pages
Gegevens opschonen
Opschonen is cruciaal voor de kwaliteit van het ophalen, omdat elk verdwaald teken ruimte inneemt in het fragment en de resulterende vector vertroebelt. De volgende functie ketent vier behandelingen aan elkaar: het verwijdert besturingstekens die overblijven na formaatconversies, normaliseert reeksen nieuwe regels en spaties, wist paginamarkers die typisch zijn voor PDF’s, en vervangt eindeloze URL’s door een eenvoudige placeholder zodat ze niet een heel fragment opslokken.
import re
def clean_text(text):
"""Clean text for RAG indexing."""
# Remove control characters
text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
# Normalize spaces and newlines
text = re.sub(r'\n{3,}', '\n\n', text)
text = re.sub(r' {2,}', ' ', text)
# Remove repetitive headers/footers (PDF)
text = re.sub(r'Page \d+ of \d+', '', text)
# Remove very long URLs
text = re.sub(r'https?://\S{100,}', '[URL]', text)
return text.strip()
# Apply cleaning
for doc in docs:
doc["content"] = clean_text(doc["content"])
Strategieën voor fragmentatie (Chunking)
Fragmentatie is de belangrijkste stap in de voorbereiding: de grootte en methode van de fragmenten hebben directe invloed op de kwaliteit van het ophalen. Er bestaan drie benaderingen, variërend van mechanisch tot structuurbewust.
Fragmentatie met vaste grootte beweegt door de tekst in regelmatige schijven. Deze methode negeert betekenis volledig, waardoor ze op elke bron toepasbaar is, maar ze snijdt vaak zinnen doormidden. Overlap corrigeert dit gebrek gedeeltelijk: met overlap=200 wordt het einde van elk fragment herhaald aan het begin van het volgende, zodat een gesplitst idee in ten minste één van de twee stukken heel blijft.
def chunk_fixed_size(text, chunk_size=2048, overlap=200):
"""Fixed-size chunking with overlap."""
chunks = []
start = 0
while start < len(text):
end = min(start + chunk_size, len(text))
chunk = text[start:end]
if chunk.strip():
chunks.append(chunk.strip())
start += chunk_size - overlap
return chunks
Fragmentatie op basis van alinea’s, aanbevolen voor documentatie, vertrouwt in plaats daarvan op de natuurlijke grenzen van de tekst. Deze methode stapelt alinea’s op zolang ze onder max_size blijven, en opent vervolgens een nieuw fragment. De drempelwaarde min_size voorkomt dat een verdwaalde kop of geïsoleerde regel wordt geïndexeerd, wat een vector zonder bruikbare inhoud zou opleveren.
def chunk_by_paragraphs(text, max_size=1500, min_size=100):
"""Intelligent paragraph-based chunking."""
paragraphs = text.split("\n\n")
chunks = []
current = ""
for para in paragraphs:
para = para.strip()
if not para:
continue
if len(current) + len(para) + 2 <= max_size:
current = current + "\n\n" + para if current else para
else:
if len(current) >= min_size:
chunks.append(current)
current = para
if current and len(current) >= min_size:
chunks.append(current)
return chunks
Fragmentatie op basis van Markdown-secties maakt gebruik van informatie die de auteur reeds heeft verstrekt: hun koppen. Elke sectie wordt een zelfstandig fragment, wat garandeert dat een vraag over “authenticatie” de volledige sectie ophaalt in plaats van een fragment. Secties die te lang zijn, vallen terug op alinea-fragmentatie, zodat geen enkel fragment de limiet overschrijdt.
def chunk_by_markdown_sections(text, max_size=2000):
"""Chunking by Markdown headings (## and ###)."""
sections = re.split(r'\n(?=##\s)', text)
chunks = []
for section in sections:
section = section.strip()
if not section:
continue
if len(section) <= max_size:
chunks.append(section)
else:
# Sub-chunk overly long sections
sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
chunks.extend(sub_chunks)
return chunks
Complete voorbereidingspipeline
Koppel tot slot de drie bewerkingen aan elkaar en kies de fragmentatiestrategie op basis van het bestandstype: .md-bestanden doorlopen secties, al het andere doorloopt alinea’s. Elk fragment draagt vervolgens zijn metadata—bron, positie in het document en het totale aantal fragmenten van dat document. Zonder dit kunt u een antwoord niet traceren naar de bron. De laatste twee regels tonen de expansiefactor en de gemiddelde grootte: als dit gemiddelde ver onder uw chunk_size zakt, is het document meer gefragmenteerd dan verwacht en moet u uw fragmentatiestrategie herzien.
def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
"""Complete pipeline: clean, chunk, enrich with metadata."""
all_chunks = []
for doc in raw_docs:
# 1. Clean
clean = clean_text(doc["content"])
# 2. Chunk based on type
if doc.get("source", "").endswith(".md"):
chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
else:
chunks = chunk_by_paragraphs(clean, max_size=chunk_size)
# 3. Enrich with metadata
for i, chunk in enumerate(chunks):
all_chunks.append({
"text": chunk,
"source": doc["source"],
"chunk_index": i,
"total_chunks": len(chunks),
})
return all_chunks
# Execution
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")
Belangrijkste punten
- De kwaliteit van RAG hangt direct af van de gegevenskwaliteit en de fragmentatiestrategie
- Maak gegevens schoon voordat u ze indexeert (verwijder verdwaalde tekens, lange URL’s, duplicaten)
- Fragmentatie op basis van alinea’s of Markdown-secties behoudt de semantische samenhang
- Een overlap van 10–15% tussen fragmenten voorkomt het splitsen van ideeën
- Bewaar metadata (bron, pagina, positie) voor traceerbaarheid van antwoorden