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

Retrieval: Chunking och rangordning

Lektion 8 av 20 Utvecklare
På denna sida
  1. Retrieval: Chunking och rangordning
  2. Retrieval-pipelinen
  3. Konfigurera chunking-strategin
  4. Relevanströskel och rangordning
  5. Optimera retrieval-kvalitet
  6. Mäta retrieval-kvalitet
  7. Avancerade strategier
  8. Viktiga punkter

Retrieval: Chunking och rangordning

File Search bygger på en komplett retrieval-pipeline: dina dokument delas upp i bitar (chunks), vektoriseras, indexeras och rangordnas sedan efter relevans när en fråga ställs. Att förstå denna pipeline gör att du kan optimera svarskvaliteten.

Retrieval-pipelinen

När du laddar upp en fil till ett vektorlager utför OpenAI automatiskt följande steg:

  1. Parsing: Extraherar råtext från källformatet
  2. Chunking: Delar upp texten i segment med kontrollerad storlek
  3. Embedding: Vektoriserar varje bit
  4. Indexering: Lagrar vektorerna i vektorindexet

Vid frågetillfället sker följande:

  1. Frågeembedding: Frågan vektoriseras
  2. Vektorsökning: Identifierar de bitar som ligger närmast
  3. Rangordning: Rangordnar resultaten på nytt efter relevans
  4. Inmatning: Matar in de bästa bitarna i modellens kontext

Konfigurera chunking-strategin

Chunking är den inställning som styr allt annat, och avvägningen är enkel. Korta bitar ger precisa sökresultat men levererar utdrag som saknar kontext – du hittar rätt mening men tappar referensramen. Långa bitar bevarar kontexten men begraver relevant information i irrelevant text, vilket försvagar likhetspoängen.

Det finns inget universellt värde: rätt inställning beror på din dokumentstruktur, precis som sammanfattas i tabellen nedan.

from openai import OpenAI

client = OpenAI()

# Standardstrategi: auto
vector_store = client.vector_stores.create(
    name="legal-base",
    chunking_strategy={"type": "auto"}
)

# Anpassad strategi: mindre bitar för högre precision
vector_store = client.vector_stores.create(
    name="support-faq",
    chunking_strategy={
        "type": "static",
        "static": {
            "max_chunk_size_tokens": 400,
            "chunk_overlap_tokens": 100
        }
    }
)

Välja rätt bitstorlek

Innehållstypmax_chunk_sizeoverlapVarför
FAQ, Q&A200-40050Korta, fristående svar
Teknisk dokumentation600-800200Stycken med kontext
Avtal, juridiska texter800-1200300Långa, sammanlänkade klausuler
Källkod400-600100Funktioner och klasser

Påverkan av överlappning

Överlappning löser ett specifikt problem: information som sträcker sig över gränsen mellan två bitar skulle annars klippas itu, vilket innebär att ingen av halvorna matchar frågan. Genom att låta bitarna överlappa garanterar du att varje mening förekommer intakt i minst ett segment. Kostnaden är redundans – en överlappning på 300 token för bitar på 800 token lagrar nästan 40 % duplicerad text.

# Originaltext (förenklad)
# "Klausul 5.1 anger att leverantören måste leverera inom 30 dagar.
#  Vid försening tillämpas vite på 1 % per dag.
#  Klausul 5.2 specificerar att vitet är taket vid 15 %."

# Utan överlappning: Klausul 5.1 och vite kan hamna i olika bitar
# Med överlappning: länken mellan klausul och vite bevaras

Relevanströskel och rangordning

Rangordningen avgör vilka bitar som behålls. Du kan konfigurera ett filter:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the return policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id],
        "max_num_results": 10,
        "ranking_options": {
            "ranker": "auto",
            "score_threshold": 0.5
        }
    }]
)

score_threshold filtrerar bort resultat under en viss relevanströskel. Ett värde på 0,0 returnerar allt, medan 1,0 skulle vara alltför restriktivt. I praktiken ger värden mellan 0,3 och 0,6 bra resultat.

Optimera retrieval-kvalitet

Förbereda dokument

Detta är den mest kostnadseffektiva hävstången i hela lektionen, och den enda som inte kostar något i inställningar: ett välstrukturerat dokument indexeras bra. Använd tydliga rubriker, en inledande mening för varje avsnitt och undvik tabeller som omvandlats till textmos. Omvänt kommer ingen chunking-inställning att rädda en PDF vars extrahering producerar sammanflätade kolumner.

# Dåligt: Skannad PDF med ungefärlig OCR
# -> Inkoherenta bitar, embedding av låg kvalitet

# Bra: Strukturerat dokument med rubriker och avsnitt
# -> Bitar anpassade efter logiska sektioner

# Mönster: Förbehandla före uppladdning
def prepare_document(raw_text: str) -> str:
    """Rensar och strukturerar text före indexering."""
    # Ta bort upprepade sidhuvuden/sidfötter
    lines = raw_text.split("\n")
    lines = [l for l in lines if not is_header_footer(l)]

    # Normalisera mellanrum
    text = "\n".join(lines)
    text = re.sub(r"\n{3,}", "\n\n", text)

    return text

Berika med metadata

Metadata möjliggör förfiltrering före vektorsökning, vilket förbättrar precisionen:

# Ladda upp med rik metadata
documents = [
    {"file": "hr-policy-2026.pdf", "department": "hr", "type": "policy", "year": 2026},
    {"file": "supplier-contract-a.pdf", "department": "procurement", "type": "contract", "year": 2026},
    {"file": "it-security-guide.pdf", "department": "it", "type": "guide", "year": 2025},
]

for doc in documents:
    with open(doc["file"], "rb") as f:
        file_obj = client.files.create(file=f, purpose="assistants")

    client.vector_stores.files.create(
        vector_store_id=vector_store.id,
        file_id=file_obj.id,
        attributes={
            "department": doc["department"],
            "document_type": doc["type"],
            "year": doc["year"]
        }
    )

Mäta retrieval-kvalitet

Utan mätning är varje chunking-inställning bara intuition. En uppsättning på tjugo frågor där du känner till det förväntade svaret och vilket dokument det finns i räcker för att objektivisera processen: ändra en parameter, kör testsviten på nytt och jämför. Detta är lite arbete jämfört med timmar spenderade på att debattera bitstorlek utan data.

def evaluate_retrieval(test_questions: list[dict], vs_id: str) -> dict:
    """Utvärderar retrieval-kvalitet på en testuppsättning.

    Varje element i test_questions innehåller:
    - question: frågan som ska ställas
    - expected_answer: nyckelord eller fraser som förväntas i svaret
    """
    results = {"total": 0, "relevant": 0, "irrelevant": 0}

    for test in test_questions:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=test["question"],
            tools=[{
                "type": "file_search",
                "vector_store_ids": [vs_id],
                "max_num_results": 5
            }]
        )

        answer = response.output_text.lower()
        found_keywords = sum(
            1 for word in test["expected_answer"]
            if word.lower() in answer
        )

        results["total"] += 1
        if found_keywords >= len(test["expected_answer"]) * 0.5:
            results["relevant"] += 1
        else:
            results["irrelevant"] += 1

    results["relevance_rate"] = results["relevant"] / results["total"]
    return results

Avancerade strategier

Multi-Vector-Store

Fråga flera dokumentbaser parallellt:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare our HR policy with legal obligations",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [
            vs_internal_policies,
            vs_legal_texts
        ],
        "max_num_results": 15
    }]
)

Dekomponerade frågor

En fråga som innehåller flera begäranden producerar en genomsnittlig vektor som inte liknar någon av dem, vilket leder till dåliga sökresultat för alla. Att bryta ner den i separata delfrågor ger betydligt bättre resultat – detta är samma princip som vid webbsökning: en precis fråga slår en uttömmande.

def decomposed_search(complex_question: str, vs_id: str) -> str:
    """Dekomponerar en komplex fråga i delsökningar."""
    # Steg 1: Dekomponera frågan
    decomposition = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Decompose this question into 2-3 simple sub-questions: {complex_question}",
    )

    # Steg 2: Sök efter varje delfråga
    sub_results = []
    for sub_q in decomposition.output_text.split("\n"):
        if sub_q.strip():
            r = client.responses.create(
                model="gpt-5.6-terra",
                input=sub_q.strip(),
                tools=[{"type": "file_search", "vector_store_ids": [vs_id]}]
            )
            sub_results.append(r.output_text)

    # Steg 3: Syntetisera
    synthesis = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Original question: {complex_question}\n\n"
              f"Intermediate results:\n" + "\n---\n".join(sub_results) +
              "\n\nSynthesize a complete and coherent answer."
    )
    return synthesis.output_text

Viktiga punkter

  • static chunking med anpassad storlek och överlappning förbättrar precisionen
  • Små bitar för FAQ, stora bitar för juridiska dokument
  • score_threshold filtrerar bort irrelevanta resultat
  • Rensa och strukturera dina dokument före indexering
  • Utvärdera retrieval-kvalitet med en testuppsättning