Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Forbered dataene

Lektion 10 af 18 Opdateret 29. juli 2026 Udvikler
På denne side
  1. RAG-kvalitet afhænger af dine data
  2. Hentning af data
  3. Rensning af data
  4. Strategier for opdeling i udsnit (Chunking)
  5. Komplet forberedelsespipeline
  6. Vigtige pointer

RAG-kvalitet afhænger af dine data

En RAG-pipeline er kun lige så god som de data, den indekserer. Du kan skrive den perfekte prompt og vælge den bedste generationsmodel, men hvis det hentede udsnit halverer en definition eller trækker en gentaget sidefod ind i stedet for brugbar tekst, vil dit svar lide under det. Forberedelsen foregår i tre faser: hent dataene, hvor de befinder sig, fjern alt meningsløst indhold, og opdel teksten i udsnit optimeret til indeksering.

Hentning af data

Corpora i den virkelige verden er sjældent homogene. Du vil typisk have Markdown-dokumentation i et repository, nogle få sider fra en offentlig hjemmeside og en håndfuld regulatoriske PDF-filer. Hver kilde kræver sin egen loader, men de skal alle producere den samme struktur – indhold, kilde og type – så resten af pipelinen forbliver uafhængig af tekstens oprindelse.

Til tekstfiler er en rekursiv gennemgang af mapper tilstrækkelig, og filtrering efter filtype forhindrer utilsigtet indlæsning af binære filer.

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")

Websider tilgås via HTTP, men det du modtager er HTML. Uddraget nedenfor fjerner tags ved hjælp af regulære udtryk og samler flere mellemrum til ét. Dette er nok til en prototype, men kommentaren minder dig om, at BeautifulSoup i produktion vil gøre et langt bedre stykke arbejde med tabeller og nestede lister.

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-filer fortjener særlig behandling. I stedet for at sammenkæde hele dokumentet, skal du beholde én post pr. side og kode sidetallet i kilden som file.pdf#page=12. Når din assistent citerer dette afsnit, vil brugeren vide præcis, hvor vedkommende kan verificere det.

# 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

Rensning af data

Rensning er afgørende for kvaliteten af søgningen, fordi hvert enkelt overflødigt tegn optager plads i udsnittet og forurener den resulterende vektor. Funktionen nedenfor kæder fire behandlinger sammen: den fjerner kontroltegn tilbage fra formatkonverteringer, normaliserer sekvenser af linjeskift og mellemrum, sletter pagineringsmarkører typiske for PDF’er, og erstatter uendelige URLs med en simpel pladsholder, så de ikke æder hele udsnittet.

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"])

Strategier for opdeling i udsnit (Chunking)

Opdeling i udsnit er det vigtigste skridt i forberedelsen: størrelsen på udsnittet og metoden påvirker direkte kvaliteten af søgningen. Der findes tre tilgange, der spænder fra mekanisk til strukturbaseret.

Opdeling i faste størrelser bevæger sig gennem teksten i regelmæssige bidder. Den ignorerer betydningen fuldstændigt, hvilket gør den anvendelig på enhver kilde, men den halverer ofte sætninger. Overlap korrigerer delvist denne fejl: med overlap=200 gentages slutningen af hvert udsnit i starten af det næste, hvilket sikrer, at en opdelt idé forbliver hel i mindst én af de to dele.

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

Afsnitsbaseret opdeling, som anbefales til dokumentation, stole i stedet på tekstens naturlige grænser. Den akkumulerer afsnit, så længe de holder sig under max_size, og åbner derefter et nyt udsnit. Tærsklen min_size forhindrer indeksering af en forældreløs overskrift eller en isoleret linje, hvilket ville producere en vektor uden brugbart indhold.

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

Opdeling efter Markdown-sektioner udnytter information, som forfatteren allerede har leveret: deres overskrifter. Hver sektion bliver et selvstændigt udsnit, hvilket garanterer, at et spørgsmål om „autentificering” henter hele sektionen frem i stedet for et fragment. Sektioner, der er for lange, falder tilbage til afsnitsopdeling, hvilket sikrer, at intet udsnit overskrider grænsen.

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

Komplet forberedelsespipeline

Til sidst kæder du de tre operationer sammen og vælger opdelingsstrategi baseret på filtype: .md-filer går gennem sektioner, alt andet gennem afsnit. Hvert udsnit bærer derefter sine metadata – kilde, position i dokumentet og det samlede antal udsnit fra dette dokument. Uden dette vil du ikke kunne spore svaret til kilden. De sidste to linjer viser ekspansionsraten og den gennemsnitlige størrelse: hvis dette gennemsnit falder langt under din chunk_size, er dokumentet mere fragmenteret end forventet, og du skal genoverveje din opdelingsstrategi.

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")

Vigtige pointer

  • RAG-kvalitet afhænger direkte af datakvalitet og strategi for opdeling i udsnit
  • Rens data før indeksering (fjern overflødige tegn, lange URLs, dubletter)
  • Opdeling efter afsnit eller Markdown-sektioner bevarer semantisk sammenhæng
  • Et overlap på 10–15 % mellem udsnit forhindrer opsplitning af idéer
  • Behold metadata (kilde, side, position) for at kunne spore svar