Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Promptovanie s rozšíreným vyhľadávaním

Lekcia 9 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Promptovanie s rozšíreným vyhľadávaním
  2. Architektúra systému RAP
  3. Kompletná pipelína
  4. Chunking: Rozdeľovanie dokumentov
  5. Pokročilé stratégie vyhľadávania
  6. Využitie natívneho vyhľadávania súborov od OpenAI
  7. Stanovenie východiskovej hodnoty
  8. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Používanie modelu GPT-6 · GPT-5.6 Terra.

Promptovanie s rozšíreným vyhľadávaním

Promptovanie s rozšíreným vyhľadávaním (Retrieval-Augmented Prompting – RAP) spája vyhľadávanie v dokumentoch s tvorbou promptov, aby sa modelu poskytol relevantný a aktuálny kontext. Je to prirodzený vývoj uzemňovania (grounding): namiesto manuálneho vkladania kontextu automatizujete vyhľadávanie relevantných pasáží pred každým volaním LLM.

Rozdiel je zrejmý vo veľkom meradle. Manuálne kopírovanie troch užitočných odsekov z vašej dokumentácie funguje pri demoverzii, ale akonáhle dosiahne vaša dokumentácia niekoľko sto strán a otázky prichádzajú nepretržite, nikto už nevie, ktoré pasáže vložiť. RAP deleguje túto voľbu na automatickú zložku, ktorá sa spustí pred každou generáciou a ktorej jedinou úlohou je nájsť to, čo má byť vložené do promptu.

Architektúra systému RAP

Pipelína RAP sa rozkladá na tri kroky, ktoré fungujú rôznou rýchlosťou a s rôznymi nákladmi. Indexovanie transformuje vaše dokumenty na vektorové embedingy; deje sa to raz, offline, pričom každý dokument sa zmení na číselný vektor zakódujúci jeho význam a uloží sa spolu s pôvodným textom. Vyhľadávanie (Retrieval) naopak beží pri každej otázke: otázku transformujete na vektor pomocou rovnakého modelu embedingu a následne vyhľadáte najbližšie vektory dokumentov. Nakoniec, augmentácia je len štandardné promptovanie – zostavíte systémový prompt obsahujúci získané pasáže a modelu prikážete, aby sa mimo tento rozsah nepohyboval.

Zapamätajte si toto rozdelenie: všetko nákladné sa deje počas indexovania, kde si môžete dovoliť byť nároční, zatiaľ čo všetko, čo sa opakuje pre každú otázku, musí zostať rýchle. Kód nižšie implementuje prvé dva kroky s použitím kosínusovej podobnosti ako miery blízkosti.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Step 1: Generate document embeddings
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Generates embeddings for a list of texts."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts
    )
    return [item.embedding for item in response.data]

# Step 2: Search by cosine similarity
def cosine_similarity(a: list[float], b: list[float]) -> float:
    """Calculates cosine similarity between two vectors."""
    a, b = np.array(a), np.array(b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def retrieve(query: str, documents: list[str],
             doc_embeddings: list[list[float]],
             top_k: int = 3) -> list[str]:
    """Returns the top_k most relevant documents."""
    query_emb = embed_texts([query])[0]

    scores = [
        (i, cosine_similarity(query_emb, doc_emb))
        for i, doc_emb in enumerate(doc_embeddings)
    ]
    scores.sort(key=lambda x: x[1], reverse=True)

    return [documents[i] for i, _ in scores[:top_k]]

Kompletná pipelína

Spojením týchto stavebných blokov vznikne trieda, ktorá sa zmestí asi do tridsiatich riadkov. Väčšina rozhodnutí sa odohráva v generovanom systémovom prompte a oplatí sa prečítať si ho riadok po riadku. Model najprv dostane príkaz odpovedať IBA na základe poskytnutých pasáží, čo obmedzuje halucinované odpovede, keď je dokumentácia tichá. Následne dostane inštrukciu citovať číslo pasáže pre každé tvrdenie, a práve to umožňuje overenie: recenzent môže na prvý pohľad vysledovať zdroj späť k pôvodu. Hodnota temperature 0,1 dokončuje nastavenie – pri odpovedi ukotvenej v dokumentoch je kreativita chybou.

class RAGPipeline:
    """Minimalistická pipelína RAP."""

    def __init__(self, documents: list[str]):
        self.documents = documents
        self.embeddings = embed_texts(documents)

    def query(self, question: str, top_k: int = 3) -> str:
        """Odpovedá na otázku na základe dokumentov."""
        # Vyhľadávanie
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Augmentácia promptu
        context = "\n\n---\n\n".join(
            f"[Passage {i+1}]\n{doc}"
            for i, doc in enumerate(relevant_docs)
        )

        system = f"""You are a technical assistant.
Answer ONLY based on the provided passages.
If the passages do not contain the answer, say so.
Cite the passage number for every claim.

RELEVANT PASSAGES:
{context}"""

        # Generovanie
        response = client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature requires effort none
            instructions=system,
            input=question,
            temperature=0.1
        )
        return response.output_text

Chunking: Rozdeľovanie dokumentov

Rozdeľovanie dokumentov na chunky (časti) je kľúčové pre kvalitu vyhľadávania. Ak sú chunky príliš veľké, utopia relevantné informácie; ak sú príliš malé, stratia kontext. Príručka API rozdelená na desaťstranové bloky vždy vráti ten istý všeobecný blok bez ohľadu na položenú otázku. Ak ju rozdelíte na izolované vety, vráti vetu začínajúcu „táto metóda“, pričom model nebude vedieť, o ktorú metódu ide. Prekrývanie (overlap) špecificky zmierňuje toto riziko: každý chunk opakuje koniec predchádzajúceho, takže informácia presahujúca hranicu zostáva čitateľná aspoň z jednej strany.

Keď majú vaše dokumenty štruktúru nadpisov, chunking založený na sekciách je takmer vždy lepší ako chunking s pevnou veľkosťou: sekcia „Autentifikácia“ zostane nedotknutá aj so svojím úvodom a príkladmi.

def chunk_document(text: str, chunk_size: int = 500,
                   overlap: int = 50) -> list[str]:
    """Splits text into chunks with overlap."""
    words = text.split()
    chunks = []

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

    return chunks

def chunk_by_sections(text: str) -> list[str]:
    """Splits by sections (Markdown headings)."""
    sections = []
    current = []

    for line in text.split("\n"):
        if line.startswith("## ") and current:
            sections.append("\n".join(current))
            current = [line]
        else:
            current.append(line)

    if current:
        sections.append("\n".join(current))

    return sections

Pokročilé stratégie vyhľadávania

Prehodnotenie poradia (Reranking)

Po počiatočnom vyhľadávaní použite LLM na preusporiadanie výsledkov. Logika funguje ako lievik: vektorové vyhľadávanie je rýchle, ale približné, a prináša späť tucet pravdepodobných kandidátov; model, ktorý je pomalší, ale nuancovanejší, si týchto kandidátov znova prečíta so znalosťou otázky a zoradí ich. Následne si pre generovanie ponecháte len špičku zoznamu. Zisk je najviditeľnejší pri otázkach, kde niekoľko pasáží hovorí o rovnakej téme, ale len jedna na ňu skutočne odpovedá – tri sekcie spomínajú slovo „kvóta“, ale len jedna vysvetľuje, ako ju zvýšiť.

def rerank(question: str, passages: list[str]) -> list[str]:
    """Reorders passages by relevance using the LLM."""
    prompt = f"""Question: {question}

Here are candidate passages. Rank them from most relevant
to least relevant for answering the question.
Return only the numbers in order (e.g., 3, 1, 2).

{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0
    )
    # Parse returned order and reorganize
    return response.output_text

Hypotetické vkladanie dokumentov (HyDE)

Vygenerujte ideálny hypotetický dokument a následne vyhľadajte podobné dokumenty. Problém, ktorý táto technika rieši, je nezhoda v slovnej zásobe: otázka položená v bežnom jazyku nevypadá z vektorového hľadiska ako odsek technickej dokumentácie. Tým, že najprv požiadate model, aby napísal odpoveď, ktorú si predstavuje, získate text napísaný registrom vašich dokumentov, a práve tento text použijete ako dopyt (query). Nezáleží na tom, ak hypotetický odsek obsahuje nepresnosti: nikdy neslúži ako odpoveď, iba ako sonda.

def hyde_retrieve(question: str, documents: list[str],
                  doc_embeddings: list[list[float]]) -> list[str]:
    """Retrieval via HyDE."""
    # Generate a hypothetical passage
    hypo_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=f"Write a short technical paragraph that would perfectly "
              f"answer this question: {question}",
        temperature=0.5
    )
    hypothetical_doc = hypo_response.output_text

    # Search for documents similar to the hypothetical passage
    return retrieve(hypothetical_doc, documents,
                    doc_embeddings, top_k=3)

Využitie natívneho vyhľadávania súborov od OpenAI

Pre rýchle nasadenie ponúka API integrované vyhľadávanie. Nahrajete súbor, vytvoríte úložisko vektorov, pripojíte k nemu súbor a vo volaní deklarujete nástroj file_search: chunking, embeding aj vyhľadávanie sú vybavené na strane servera. Je to správna voľba, keď sú vaše dokumenty štandardné a nezaujíma vás, kde sa údaje nachádzajú. Vlastná pipelína si zachováva výhodu hneď, ako potrebujete ovládať chunking, hostiť index sami alebo zapojiť špecifické prehodnotenie poradia (reranking).

# Upload file
file = client.files.create(
    file=open("documentation.pdf", "rb"),
    purpose="assistants"
)

# Create a vector store
vector_store = client.vector_stores.create(
    name="Technical Documentation"
)

client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file.id
)

# Query with File Search
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Answer based on the provided documentation.",
    input="How do I configure authentication?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }]
)

Stanovenie východiskovej hodnoty

Vezmite päť až desať strán technickej dokumentácie a implementujte kompletnú pipelínu od chunkingu až po generovanie. Napíšte desať otázok, ktorých odpovede sa nachádzajú v dokumentoch, spustite na každej pipelínu a potom to zopakujte so zapnutým prehodnotením poradia (reranking): práve pozorovaním, pri ktorých otázkach sa poradie zmení, pochopíte, čo samotné vektorové vyhľadávanie míňa. Nakoniec zmerajte percentuálny podiel správne ukotvených odpovedí, teda tých, kde sa každé tvrdenie efektívne odvoláva na poskytnutú pasáž. Toto číslo je vaším východiskovým bodom; všetky následné optimalizácie budú posudzované voči nemu, nie podľa dojmu, ktorý zanechá dva či tri náhodne prečítané odpovede.

Kľúčové poznatky

  • RAP automatizuje vkladanie relevantného kontextu do promptu
  • Chunking je kritický: experimentujte s rôznymi veľkosťami
  • Prehodnotenie poradia (Reranking) pomocou LLM výrazne zlepšuje relevantnosť
  • HyDE je užitočné, keď sa otázka veľmi líši od slovnej zásoby dokumentov
  • OpenAI File Search zjednodušuje nasadenie pre štandardné prípady