Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kutse loomine otsingu abil täiendatuna

Õppetund 9 / 16 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Kutse loomine otsingu abil täiendatuna
  2. RAP-süsteemi arhitektuur
  3. Täielik torustik
  4. Tükeldamine: dokumentide jagamine
  5. Täiustatud otsingustrateegiad
  6. OpenAI kohaliku failiotsingu kasutamine
  7. Lähtetaseme loomine
  8. Peamised punktid

Õppetund uuendatud 3. novembril 2026 vastavalt OpenAI dokumentatsioonile: parameetreid temperature ja top_p aktsepteeritakse ainult siis, kui arutluse intensiivsus on none, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Seetõttu peavad need parameetrid määravad päringud sisaldama reasoning={"effort": "none"} (Responses API) või reasoning_effort="none" (Chat Completions). Allikad: GPT-6 kasutamine · GPT-5.6 Terra.

Kutse loomine otsingu abil täiendatuna

Otsingu abil täiendatud kutse loomine (Retrieval-Augmented Prompting ehk RAP) ühendab dokumentide otsimise kutse loomisega, et pakkuda mudelile asjakohast ja ajakohast konteksti. See on maandamise loomulik edasiarendus: käsitsi konteksti sisestamise asemel automatiseerid asjakohaste lõikude otsimise enne iga suure keelemudeli (LLM) väljakutset.

Erinevus muutub ilmseks suuremates mahudes. Kolme kasuliku lõigu käsitsi kleepimine oma dokumentatsioonist toimib demo jaoks, kuid kui dokumentatsioonibaas kasvab sadadele lehekülgedele ja küsimusi laekub pidevalt, ei tea enam keegi, milliseid lõike kleepida. RAP delegeerib selle valiku automaatsele komponendile, mida käivitatakse enne iga genereerimist ja mille ainus ülesanne on leida, mida kutse sisusse lisada.

RAP-süsteemi arhitektuur

RAP-torustik jaguneb kolmeks sammuks, mis töötavad erineva kiiruse ja kuluga. Indekseerimine teisendab sinu dokumendid vektorembeddinguteks; see toimub üks kord, võrguühenduseta, muutes iga dokumendi numbriliseks vektoriks, mis kodeerib selle tähenduse ja salvestatakse koos algse tekstiga. Otsing seevastu käivitub iga küsimuse korral: teisendad küsimuse sama embedding-mudeli abil vektoriks ja otsid seejärel lähimaid dokumentide vektoreid. Lõpuks on täiendamine lihtsalt tavaline kutse loomine – koostad süsteemse kutse, mis sisaldab leitud lõike, ja juhendad mudelit mitte sellest raamistikust välja minema.

Pea meeles seda jaotust: kõik, mis on kulukas, toimub indekseerimise ajal, kus saad endale lubada nõudlikkust, samas kui kõik, mis kordub iga küsimuse puhul, peab jääma kiireks. Allpool olev kood rakendab kahte esimest sammu, kasutades läheduse mõõdikuna koosinuse sarnasust.

from openai import OpenAI
import numpy as np

client = OpenAI()

# 1. samm: genereeri dokumentide embeddingud
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Genereerib tekstide loendi embeddingud."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts
    )
    return [item.embedding for item in response.data]

# 2. samm: otsing koosinuse sarnasuse alusel
def cosine_similarity(a: list[float], b: list[float]) -> float:
    """Arvutab kahe vektori vahelise koosinuse sarnasuse."""
    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]:
    """Tagastab top_k kõige asjakohasemat dokumenti."""
    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]]

Täielik torustik

Nende ehitusplokkide kokkupanemisel saad klassi, mis mahub umbes kolmekümnesse ritta. Enamik otsuseid tehakse genereeritud süsteemses kutses ja seda tasub rida-realt lugeda. Mudel saab esmalt korralduse vastata AINULT esitatud lõikude põhjal, mis piirab hallutsineeritud vastuseid, kui dokumentatsioon vaikib. Seejärel saab ta juhise tsiteerida iga väite puhul lõigu numbrit, mis teeb kontrollimise võimalikuks: ülevaataja saab pilguheituga allikale jälitada. temperature väärtus 0,1 viib seadistuse lõpule – dokumentidel põhineva vastuse puhul on loovus viga.

class RAGPipeline:
    """Minimalistlik RAP-torustik."""

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

    def query(self, question: str, top_k: int = 3) -> str:
        """Vastab küsimusele dokumentide põhjal."""
        # Otsing
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Kutse täiendamine
        context = "\n\n---\n\n".join(
            f"[Lõik {i+1}]\n{doc}"
            for i, doc in enumerate(relevant_docs)
        )

        system = f"""Oled tehniline assistent.
Vasta AINULT esitatud lõikude põhjal.
Kui lõigud vastust ei sisalda, ütle seda.
Tsiteeri iga väite puhul lõigu numbrit.

ASJAKOHASED LÕIGUD:
{context}"""

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

Tükeldamine: dokumentide jagamine

Dokumentide tükkideks jagamine on otsingu kvaliteedi jaoks kriitilise tähtsusega. Kui tükid on liiga suured, uputavad need asjakohase info; kui liiga väikesed, kaotavad nad konteksti. API käsiraamat, mis on jagatud kümneleheküljelisteks plokkideks, tagastab alati sama üldise ploki, sõltumata esitatud küsimusest. Kui jagada see üksikuteks lauseteks, tagastatakse lause, mis algab sõnadega „see meetod“, ilma et mudel teaks, millist meetodit silmas peetakse. Ülekattumine leevendab seda riski spetsiaalselt: iga tükk kordab eelmise lõppu, nii et piiri ületav info jääb vähemalt ühelt poolt loetavaks.

Kui sinu dokumentidel on pealkirjade struktuur, on lõikude põhine tükeldamine peaaegu alati parem kui fikseeritud suurusega tükeldamine: lõik „Autentimine“ jääb tervikuks koos sissejuhatuse ja näidetega.

def chunk_document(text: str, chunk_size: int = 500,
                   overlap: int = 50) -> list[str]:
    """Jagab teksti ülekattuvateks tükkideks."""
    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]:
    """Jagab lõikude kaupa (Markdowni pealkirjad)."""
    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

Täiustatud otsingustrateegiad

Ümberjärjestamine (Reranking)

Pärast esmast otsingut kasuta LLM-i tulemuste ümberjärjestamiseks. Loogika on lehtrilaadne: vektorotsing on kiire, kuid ligikaudne, tuues tagasi tosinaga usutavaid kandidaate; mudel, mis on aeglasem, kuid nüansirikkam, loeb need kandidaadid küsimust teades uuesti läbi ja järjestab need. Seejärel jätad genereerimiseks alles ainult nimekirja tipu. Kasu on kõige nähtavam küsimuste puhul, kus mitu lõiku räägib samast teemast, kuid ainult üks neist tegelikult vastab – kolm lõiku mainivad sõna „kvoot“, kuid ainult üks selgitab, kuidas seda suurendada.

def rerank(question: str, passages: list[str]) -> list[str]:
    """Järjestab lõigud ümber asjakohasuse alusel, kasutades LLM-i."""
    prompt = f"""Küsimus: {question}

Siin on kandidaat-lõigud. Järjesta need küsimusele vastamiseks
kõige asjakohasemast kõige vähem asjakohaseni.
Tagasta ainult numbrid järjekorras (nt 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 nõuab effort none
        input=prompt,
        temperature=0.0
    )
    # Parsi tagastatud järjekord ja korralda ümber
    return response.output_text

Hüpoteetiline dokumendi embedding (HyDE)

Genereeri ideaalne hüpoteetiline dokument ja otsi seejärel sarnaseid dokumente. Probleem, mida see tehnika lahendab, on sõnavara mittevastavus: igapäevases keeles esitatud küsimus ei sarnane vektoriaalselt tehnilise dokumentatsiooni lõiguga. Paludes mudelil esmalt kirjutada vastus, mida ta ette kujutab, saad teksti, mis on kirjutatud sinu dokumentide registris, ja just seda teksti kasutad päringuna. Pole tähtis, kas hüpoteetiline lõik sisaldab ligikaudsusi: seda ei kasutata kunagi vastusena, vaid ainult sondina.

def hyde_retrieve(question: str, documents: list[str],
                  doc_embeddings: list[list[float]]) -> list[str]:
    """Otsing HyDE kaudu."""
    # Genereeri hüpoteetiline lõik
    hypo_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature nõuab effort none
        input=f"Kirjuta lühike tehniline lõik, mis vastaks täiuslikult "
              f"sellele küsimusele: {question}",
        temperature=0.5
    )
    hypothetical_doc = hypo_response.output_text

    # Otsi dokumente, mis sarnanevad hüpoteetilise lõiguga
    return retrieve(hypothetical_doc, documents,
                    doc_embeddings, top_k=3)

OpenAI kohaliku failiotsingu kasutamine

Kiireks kasutuselevõtuks pakub API integreeritud otsingut. Laadid faili üles, lood vektorpoe, kinnitad faili selle külge ja deklareerid väljakutses tööriista file_search: tükeldamise, embeddingute loomise ja otsingu haldab serveripoolne süsteem. See on õige valik, kui sinu dokumendid on standardsed ja sind ei huvita, kus andmed asuvad. Oma käega loodud torustik säilitab eelise niipea, kui vajad tükeldamise üle kontrolli, soovid indeksit ise majutada või soovida lisada spetsiifilist ümberjärjestamist.

# Laadi fail üles
file = client.files.create(
    file=open("documentation.pdf", "rb"),
    purpose="assistants"
)

# Loo vektorpood
vector_store = client.vector_stores.create(
    name="Technical Documentation"
)

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

# Päring failiotsinguga
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Vasta esitatud dokumentatsiooni põhjal.",
    input="Kuidas konfigureerida autentimist?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }]
)

Lähtetaseme loomine

Võta viis kuni kümme lehekülge tehnilist dokumentatsiooni ja rakenda täielik torustik, alates tükeldamisest kuni genereerimiseni. Kirjuta kümme küsimust, mille vastused on dokumentides olemas, käivita torustik igaühe jaoks ja korda seda seejärel, lubades ümberjärjestamise: just küsimuste vaatlemisel, mille puhul järjestus muutub, saad aru, mida puhas vektorotsing mööda laseb. Lõpeta mõõtes nende õigesti maandatud vastuste protsenti, kus iga väide viitab tegelikult esitatud lõigule. See number on sinu lähtepunkt; kõiki järgnevaid optimeerimisi hinnatakse selle, mitte kahe-kolme juhuslikult loetud vastuse jäetud mulje põhjal.

Peamised punktid

  • RAP automatiseerib asjakohase konteksti sisestamise kutsesse
  • Tükeldamine on kriitiline: katseta erinevaid suurusi
  • LLM-iga ümberjärjestamine parandab oluliselt asjakohasust
  • HyDE on kasulik, kui küsimuse sõnavara erineb suuresti dokumentide omast
  • OpenAI failiotsing lihtsustab standardjuhtude kasutuselevõttu