Przejdź do głównej treści
Polski— Wybierz język
Menu

Retrieval: Podział na fragmenty i ranking

Lekcja 8 z 20 Programista
Na tej stronie
  1. Retrieval: Podział na fragmenty i ranking
  2. Potok Retrieval
  3. Konfigurowanie strategii podziału na fragmenty
  4. Próg trafności i ranking
  5. Optymalizacja jakości retrieval
  6. Pomiar jakości retrieval
  7. Strategie zaawansowane
  8. Kluczowe wnioski

Retrieval: Podział na fragmenty i ranking

File Search opiera się na kompletnym potoku retrieval: Twoje dokumenty są dzielone na fragmenty, wektoryzowane, indeksowane, a następnie rankowane pod kątem trafności po otrzymaniu zapytania. Zrozumienie tego potoku pozwala zoptymalizować jakość odpowiedzi.

Potok Retrieval

Gdy przesyłasz plik do magazynu wektorowego, OpenAI automatycznie wykonuje:

  1. Parsowanie: Wyodrębnia surowy tekst z formatu źródłowego
  2. Podział na fragmenty (Chunking): Dzieli tekst na segmenty o kontrolowanym rozmiarze
  3. Osadzanie (Embedding): Wektoryzuje każdy fragment
  4. Indeksowanie: Przechowuje wektory w indeksie wektorowym

W momencie zapytania:

  1. Osadzanie zapytania: Pytanie jest wektoryzowane
  2. Wyszukiwanie wektorowe: Identyfikuje najbliższe fragmenty
  3. Ranking: Ponownie rankuje wyniki według trafności
  4. Iniekcja: Wstrzykuje najlepsze fragmenty do kontekstu modelu

Konfigurowanie strategii podziału na fragmenty

Podział na fragmenty to ustawienie, które napędza wszystko inne, a kompromis jest prosty. Krótkie fragmenty dają precyzyjne wyniki wyszukiwania, ale dostarczają wycinków pozbawionych kontekstu – znajdujesz właściwe zdanie, ale tracisz informację, do czego się ono odnosi. Długie fragmenty zachowują kontekst, ale grzebią istotne informacje w tekście nieistotnym, co osłabia wynik podobieństwa.

Nie ma uniwersalnej wartości: właściwe ustawienie zależy od struktury Twojego dokumentu, dokładnie tak, jak podsumowano to w poniższej tabeli.

from openai import OpenAI

client = OpenAI()

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

# Custom strategy: smaller chunks for higher precision
vector_store = client.vector_stores.create(
    name="support-faq",
    chunking_strategy={
        "type": "static",
        "static": {
            "max_chunk_size_tokens": 400,
            "chunk_overlap_tokens": 100
        }
    }
)

Wybór odpowiedniego rozmiaru fragmentu

Typ treścimax_chunk_sizeoverlapDlaczego
FAQ, Q&A200-40050Krótkie, samodzielne odpowiedzi
Dokumentacja techniczna600-800200Akapity z kontekstem
Umowy, teksty prawne800-1200300Długie, powiązane klauzule
Kod źródłowy400-600100Funkcje i klasy

Wpływ nakładania się (Overlap)

Nakładanie się rozwiązuje konkretny problem: informacje przechodzące przez granicę fragmentu zostałyby w przeciwnym razie przecięte na pół, co oznaczałoby, że żadna z połówek nie dopasowałaby się do zapytania. Dzięki nakładaniu się fragmentów gwarantujesz, że każde zdanie pojawi się w całości przynajmniej w jednym segmencie. Kosztem jest redundancja – nakładanie się 300 tokenów na fragmentach 800-tokenowych przechowuje niemal 40% zduplikowanego tekstu.

# Original text (simplified)
# "Clause 5.1 states the supplier must deliver within 30 days.
#  In case of delay, penalties of 1% per day apply.
#  Clause 5.2 specifies penalties are capped at 15%."

# Without overlap: Clause 5.1 and penalties might end up in different chunks
# With overlap: the link between clause and penalties is preserved

Próg trafności i ranking

Ranking decyduje o tym, które fragmenty zostaną zachowane. Możesz skonfigurować filtr:

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

Parametr score_threshold filtruje wyniki poniżej progu trafności. Wartość 0,0 zwraca wszystko, podczas gdy 1,0 byłaby zbyt restrykcyjna. W praktyce przedział od 0,3 do 0,6 daje dobre rezultaty.

Optymalizacja jakości retrieval

Przygotowanie dokumentów

To najbardziej opłacalny dźwignia w całej tej lekcji i jedyna, która nic nie kosztuje w ustawieniach: dobrze ustrukturyzowany dokument indeksuje się dobrze. Używaj wyraźnych nagłówków, zdania wprowadzającego dla każdej sekcji i unikaj tabel konwertowanych na tekstową papkę. Odwrotnie, żadne ustawienie podziału na fragmenty nie uratuje pliku PDF, którego ekstrakcja produkuje splątane kolumny.

# Bad: Scanned PDF with approximate OCR
# -> Incoherent chunks, poor-quality embeddings

# Good: Structured document with headings and sections
# -> Chunks aligned with logical sections

# Pattern: Pre-process before upload
def prepare_document(raw_text: str) -> str:
    """Cleans and structures text before indexing."""
    # Remove repetitive headers/footers
    lines = raw_text.split("\n")
    lines = [l for l in lines if not is_header_footer(l)]

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

    return text

Wzbogacanie metadanymi

Metadane pozwalają na wstępne filtrowanie przed wyszukiwaniem wektorowym, co poprawia precyzję:

# Upload with rich 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"]
        }
    )

Pomiar jakości retrieval

Bez pomiaru każde ustawienie podziału na fragmenty to tylko intuicja. Zestaw dwudziestu pytań, dla których znasz oczekiwaną odpowiedź i zawierający je dokument, wystarczy, aby uczynić proces obiektywnym: zmień parametr, uruchom ponownie zestaw testowy i porównaj wyniki. To niewiele pracy w porównaniu z godzinami spędzanymi na debatowaniu nad rozmiarem fragmentu bez danych.

def evaluate_retrieval(test_questions: list[dict], vs_id: str) -> dict:
    """Evaluates retrieval quality on a test set.

    Each element in test_questions contains:
    - question: the question to ask
    - expected_answer: keywords or phrases expected in the response
    """
    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

Strategie zaawansowane

Multi-Vector-Store

Odpytuj wiele baz dokumentów równolegle:

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

Zdekomponowane zapytania

Pytanie zawierające wiele żądań generuje średni wektor, który nie przypomina żadnego z nich, co prowadzi do słabych wyników wyszukiwania dla wszystkich. Rozbicie go na osobne podpytania daje znacznie lepsze rezultaty – jest to ta sama zasada co w wyszukiwarkach internetowych: precyzyjne zapytanie wygrywa z wyczerpującym.

def decomposed_search(complex_question: str, vs_id: str) -> str:
    """Decomposes a complex question into sub-searches."""
    # Step 1: Decompose the question
    decomposition = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Decompose this question into 2-3 simple sub-questions: {complex_question}",
    )

    # Step 2: Search for each sub-question
    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)

    # Step 3: Synthesize
    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

Kluczowe wnioski

  • Podział na fragmenty static z niestandardowym rozmiarem i nakładaniem się poprawia precyzję
  • Małe fragmenty dla FAQ, duże fragmenty dla dokumentów prawnych
  • score_threshold filtruje nieistotne wyniki
  • Czyść i strukturyzuj swoje dokumenty przed indeksowaniem
  • Oceń jakość retrieval za pomocą zestawu testowego