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

Chunking: Dela upp dina dokument intelligent

Lektion 12 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Varför dela upp dokument?
  3. Strategi 1: Chunking med fast storlek
  4. Strategi 2: Separatorbaserad chunking
  5. Strategi 3: Chunking efter Markdown-sektioner
  6. Strategi 4: Semantisk chunking
  7. Berika chunke med kontext
  8. Vilken chunk-storlek ska du välja?
  9. Viktiga punkter

Mål

  • Förstå varför chunking är avgörande för RAG-kvalitet
  • Behärska olika uppdelningsstrategier
  • Välja rätt chunk-storlek och överlappning

Varför dela upp dokument?

Inbäddningsmodeller har en token-gräns: 8 191 för OpenAI. Denna gräns är den första anledningen att dela upp dokument, men det är inte den viktigaste. Även ett dokument som ligger långt under taket ger dåliga resultat om det kodas som ett enda block, eftersom den resulterande vektorn medelvärdesbildar allt innehåll och tappar detaljer. Ta ett 40 sidor långt HR-manual som täcker semesterpolicyer, distansarbete, utläggsrapporter och sjukförsäkring: dess enda inbäddning liknar inte riktigt någon av dessa fyra ämnen, och en sökning på “hur många semesterdagar” kommer att ranka det lägre än ett mycket kortare men betydligt mer målinriktat dokument.

Chunking löser detta problem genom att bryta ner dokumentet i sammanhängande bitar, där varje bit fångar en specifik idé eller ett stycke. Det är här en RAG-pipeline vinner eller förlorar mest kvalitet – även innan du väljer en inbäddningsmodell.

Strategi 1: Chunking med fast storlek

Den enklaste metoden räknar ord och klipper vid regelbundna intervall. Den ignorerar helt textens struktur, vilket gör den brutal, men den kräver bara tre rader kod och fungerar som en viktig baslinje: varje mer sofistikerad strategi måste bevisa att den presterar bättre än denna.

def chunker_fixed_size(
    text: str,
    size: int = 500,
    overlap: int = 100
) -> list[str]:
    """Splits text into fixed-size chunks with overlap."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), size - overlap):
        chunk = " ".join(words[i:i + size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")

Parametern overlap förtjänar uppmärksamhet. Utan överlappning kommer ett klipp så småningom att hamna mitt i en förklaring: meningen “uppsägningstiden är tre månader” hamnar i en chunk, och “utom under provanställningen” i nästa. Ingen av dem svarar korrekt på frågan, och den andra är till och med vilseledande. Genom att låta chunke överlappa varandra med 10–20 % av sin storlek garanterar du att varje idé finns intakt minst en gång någonstans i indexet. Detta är en bra utgångspunkt; justera det senare baserat på din dokumenttäthet.

Strategi 2: Separatorbaserad chunking

Istället för att klippa ord för ord kan du respektera textens naturliga gränser. Idén är att först prova den starkaste separatorn – det dubbla radbrytningen som skiljer två stycken åt – och sedan gå ner till allt svagare separatorer så länge den resulterande biten överskrider maxstorleken. Ett blogginlägg delas således stycke för stycke, och endast ett monstruöst stycke kommer att fragmenteras efter meningar.

import re

def chunker_separators(
    text: str,
    separators: list[str] = ["\n\n", "\n", ". ", " "],
    max_size: int = 1000
) -> list[str]:
    """Splits text while respecting natural separators."""
    chunks = []
    current_chunk = ""

    # Split by the strongest separator first
    segments = [text]
    for sep in separators:
        new_segments = []
        for segment in segments:
            parts = segment.split(sep)
            for part in parts:
                if len(part.split()) > max_size:
                    new_segments.append(part)
                else:
                    if (current_chunk and
                        len((current_chunk + sep + part).split()) > max_size):
                        chunks.append(current_chunk.strip())
                        current_chunk = part
                    else:
                        current_chunk = (
                            current_chunk + sep + part
                            if current_chunk else part
                        )
        segments = new_segments

    if current_chunk.strip():
        chunks.append(current_chunk.strip())

    return chunks

Strategi 3: Chunking efter Markdown-sektioner

När din korpus består av strukturerad dokumentation har rubrikerna redan gjort jobbet åt dig: författaren har redan avgränsat meningsenheterna. Att dela vid rubriknivåerna # och ## producerar chunke som motsvarar sektioner exakt, och funktionen nedan behåller rubriken tillsammans med texten, vilket vi genast använder efteråt för berikning.

def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
    """Splits a Markdown document by sections."""
    chunks = []
    current_section = {"title": "", "content": "", "level": 0}

    for line in text.split("\n"):
        # Detect headings
        match = re.match(r"^(#{1,6})\s+(.+)$", line)
        if match:
            level = len(match.group(1))
            title = match.group(2)

            if level <= max_level and current_section["content"].strip():
                chunks.append({
                    "title": current_section["title"],
                    "text": current_section["content"].strip(),
                    "level": current_section["level"]
                })

            if level <= max_level:
                current_section = {
                    "title": title,
                    "content": "",
                    "level": level
                }
            else:
                current_section["content"] += line + "\n"
        else:
            current_section["content"] += line + "\n"

    if current_section["content"].strip():
        chunks.append({
            "title": current_section["title"],
            "text": current_section["content"].strip(),
            "level": current_section["level"]
        })

    return chunks

Strategi 4: Semantisk chunking

För text utan explicit struktur – ett mötesreferat, en transkribering av ett samtal – vet varken storlek eller separatorer var ämnet byts. Det gör inbäddningar. Du kodar varje mening, jämför varje mening med den föregående och klipper där likheten kollapsar: det är exakt där talaren växlande från budget till rekrytering. Observera att text-embedding-3-small räcker här eftersom du inte letar efter absolut precision utan en relativ brytpunkt.

from openai import OpenAI
import numpy as np

client = OpenAI()

def chunker_semantic(
    text: str,
    similarity_threshold: float = 0.75,
    min_sentence_length: int = 20
) -> list[str]:
    """Groups sentences by semantic similarity."""
    # Split into sentences
    sentences = re.split(r"(?<=[.!?])\s+", text)
    sentences = [s for s in sentences if len(s) > min_sentence_length]

    if len(sentences) <= 1:
        return [text]

    # Embeddings for each sentence
    resp = client.embeddings.create(
        input=sentences,
        model="text-embedding-3-small"  # small is sufficient here
    )
    embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])

    # Find break points
    chunks = []
    chunk_sentences = [sentences[0]]

    for i in range(1, len(sentences)):
        sim = float(np.dot(embs[i], embs[i - 1]))
        if sim < similarity_threshold:
            # Semantic break detected
            chunks.append(" ".join(chunk_sentences))
            chunk_sentences = [sentences[i]]
        else:
            chunk_sentences.append(sentences[i])

    if chunk_sentences:
        chunks.append(" ".join(chunk_sentences))

    return chunks

Berika chunke med kontext

En isolerad chunk tappar ofta den information som gjorde den tolkningsbar. “Löptiden är tre år” betyder ingenting om läsaren – eller inbäddningsmodellen – inte vet att det kommer från kapitlet om tillverkarens garanti. Genom att prefixa varje chunk med dokumenttiteln och sektionstiteln återställs denna kontext direkt i själva vektorn, och en sökning på “garantitid” kommer då att hitta passagen.

def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
    """Adds context to the chunk for better embedding."""
    prefix = f"Document: {doc_title}"
    if section:
        prefix += f" | Section: {section}"
    return f"{prefix}\n\n{chunk}"

Vilken chunk-storlek ska du välja?

Valet innebär en avvägning mellan precision och kontext: en kort chunk målar in sig fint men är amputerad, medan en lång chunk förstår allt men utspäder signalen.

Storlek (tokens)FördelarNackdelar
100–200Mycket precist, bra granularitetTappar kontext
300–500Bra kompromissStandard
500–1000Rik kontextMindre precist, dyrt
1000+Maximal kontextSpäder ut information

Det finns inget universellt värde: den idealiska storleken beror på dina dokument och frågor. Den enda tillförlitliga metoden är att indexera samma korpus med två eller tre storlekar och sedan mäta med hjälp av metrarna från lektion 10 på en uppsättning verkliga frågor. En supportkunskapsbas bestående av korta svar tål 200 tokens; en juridisk korpus kommer att kräva 800.

Viktiga punkter

  • Chunking är det mest impactful steget i RAG-pipelinen
  • Använd fast storlek som baslinje, separatorer för att respektera struktur
  • Semantisk chunking upptäcker automatiskt ämnesbyten
  • Överlappning och kontextuell berikning förbättrar kvaliteten
  • Testa olika storlekar och mät med sökmätvärden