Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Förbered datan

Lektion 10 av 18 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. RAG-kvalitet beror på din data
  2. Hämta datan
  3. Rengöra datan
  4. Strategier för bitindelning (Chunking)
  5. Kompletterande förberedelsepipeline
  6. Viktiga punkter

RAG-kvalitet beror på din data

En RAG-pipeline är bara så bra som datan den indexerar. Du kan skriva den perfekta prompten och välja den bästa generationsmodellen, men om det hämtade utdraget klipper av en definition mitt i eller drar med sig en repetitiv sidfot istället för användbar text, kommer ditt svar att bli lidande. Förberedelsen sker i tre steg: hämta datan där den finns, skala bort allt som är meningslöst och dela upp den i bitar optimerade för indexering.

Hämta datan

Corpora i verkliga scenarier är sällan homogena. Du har oftast Markdown-dokumentation i ett arkiv, några sidor från en offentlig webbplats och en handfull regulatoriska PDF-filer. Varje källa behöver sin egen inläsare, men de måste alla producera samma struktur – innehåll, källa och typ – så att resten av pipelinen förblir oberoende av textens ursprung.

För textfiler räcker det med en rekursiv genomgång av kataloger, och filtrering på filändelse förhindrar att du av misstag läser in binära 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")

Webbsidor kommer in via HTTP, men det du får är HTML. Extraktionen nedan tar bort taggar med hjälp av reguljära uttryck och slår ihop flera mellanslag. Detta räcker för en prototyp, men kommentaren påminner dig om att BeautifulSoup i produktion gör ett mycket bättre jobb med tabeller och nästlade listor.

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 förtjänar särskild behandling. Istället för att slå ihop hela dokumentet till en klump, behåll en post per sida och koda sidnumret i källan som file.pdf#page=12. När din assistent citerar detta stycke vet användaren exakt var hen ska verifiera informationen.

# 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

Rengöra datan

Rengöring är avgörande för sökkvaliteten eftersom varje främmande tecken äter upp plats i biten och grumlar den resulterande vektorn. Funktionen nedan kedjar fyra behandlingar: den tar bort kontrolltecken som blivit kvar från formatkonverteringar, normaliserar sekvenser av nya rader och mellanslag, raderar sidnumreringar typiska för PDF-filer och ersätter oändliga URL:er med en enkel platshållare så att de inte äter upp en hel bit.

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 för bitindelning (Chunking)

Bitindelning är det viktigaste steget i förberedelsen: storlek och metod påverkar sökkvaliteten direkt. Det finns tre tillvägagångssätt, från mekaniska till strukturmedvetna.

Bitindelning med fast storlek rör sig genom texten i regelbundna skivor. Den ignorerar betydelsen helt, vilket gör den tillämpbar på alla källor, men den klipper ofta av meningar mitt i. Överlappning korrigerar delvis detta fel: med overlap=200 upprepas slutet av varje bit i början av nästa, vilket säkerställer att en uppdelad idé förblir hel i åtminstone en av de två delarna.

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

Paragrafbaserad bitindelning, som rekommenderas för dokumentation, förlitar sig istället på textens naturliga gränser. Den ackumulerar paragrafer så länge de håller sig under max_size, och öppnar sedan en ny bit. Tröskelvärdet min_size förhindrar indexering av en övergiven rubrik eller isolerad rad, vilket skulle producera en vektor utan användbart innehåll.

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

Bitindelning efter Markdown-sektioner utnyttjar information som författaren redan har tillhandahållit: deras rubriker. Varje sektion blir en fristående bit, vilket garanterar att en fråga om “autentisering” hämtar hela sektionen snarare än ett fragment. Sektioner som är för långa faller tillbaka till paragrafbitindelning, vilket säkerställer att ingen bit överskrider 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

Kompletterande förberedelsepipeline

Slutligen kedjar du ihop de tre operationerna och väljer bitindelningsstrategi baserat på filtyp: .md-filer går genom sektioner, allt annat genom paragrafer. Varje bit bär sedan med sig sin metadata – källa, position i dokumentet och totalt antal bitar från det dokumentet. Utan detta kommer du inte att kunna spåra svarets ursprung. De två sista raderna visar expansionsgraden och genomsnittlig storlek: om detta genomsnitt sjunker långt under din chunk_size är dokumentet mer fragmenterat än väntat, och du behöver se över din bitindelningsstrategi.

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

Viktiga punkter

  • RAG-kvalitet beror direkt på datakvalitet och bitindelningsstrategi
  • Rengör data innan indexering (ta bort främmande tecken, långa URL:er, dubbletter)
  • Paragraf- eller Markdown-sektionsbitindelning bevarar semantisk sammanhang
  • En överlappning på 10–15 % mellan bitar förhindrar att idéer splittras
  • Behåll metadata (källa, sida, position) för att kunna spåra svar