Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pozivanje s pomočjo iskanja (RAG)

Lekcija 9 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Pozivanje s pomočjo iskanja (RAG)
  2. Arhitektura sistema RAP
  3. Celoten cevovod
  4. Razčlenjevanje: deljenje dokumentov
  5. Napredne strategije pridobivanja
  6. Uporaba nativnega iskanja po datotekah pri OpenAI
  7. Vzpostavi izhodišče
  8. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra temperature in top_p sta sprejeta le pri naporu razmišljanja (reasoning effort) vrednosti none, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določiti reasoning={"effort": "none"} (Responses API) ali reasoning_effort="none" (Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Pozivanje s pomočjo iskanja (RAG)

Pozivanje s pomočjo iskanja (Retrieval-Augmented Prompting – RAP) združuje iskanje po dokumentih s pozivanjem, da modelu zagotovi relevanten in ažuren kontekst. To je naravna evolucija utemeljevanja (grounding): namesto ročnega vnašanja konteksta avtomatiziraš iskanje relevantnih odlomkov pred vsakim klicem LLM.

Razlika postane očitna pri večjem obsegu. Ročno kopiranje treh uporabnih odstavkov iz tvoje dokumentacije deluje za demonstracijo; ko pa baza dokumentacije naraste na nekaj sto strani in vprašanja prihajajo neprekinjeno, nihče več ne ve, katere odlomke prilepiti. RAP to izbiro prepusti samodejni komponenti, ki se sproži pred vsako generacijo in ima edino nalogo najti tisto, kar mora iti v poziv.

Arhitektura sistema RAP

Cevovod RAP je razdeljen na tri korake, ki delujejo z različnimi hitrostmi in stroški. Indeksiranje pretvori tvoje dokumente v vektorske vložitve (embeddings); to se zgodi enkrat, offline, pri čemer se vsak dokument spremeni v številski vektor, ki kodira njegov pomen, in shrani skupaj z izvirnim besedilom. Pridobivanje (retrieval) nasprotno teče ob vsakem vprašanju: vprašanje pretvoriš v vektor z uporabo istega modela za vložitve, nato pa poiščeš najbližje vektorje dokumentov. Nazadnje je povečanje (augmentation) le standardno pozivanje – sestaviš sistemski poziv, ki vsebuje pridobljene odlomke, in modelu naročiš, naj ne stopi izven tega okvira.

Zapomni si to delitev: vse, kar je drago, se zgodi med indeksiranjem, kjer si lahko privoščiš zahtevnost, medtem ko mora vse, kar se ponavlja za vsako vprašanje, ostati hitro. Spodnja koda implementira prva dva koraka z uporabo kosinusne podobnosti kot mere bližine.

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

Celoten cevovod

Sestavljanje teh gradnikov da razred, ki zavzame približno trideset vrstic. Večina odločitev se zgodi v generiranem sistemskem pozivu in vredno si ga je prebrati vrstico za vrstico. Model najprej prejme ukaz, naj odgovori SAMO na podlagi priloženih odlomkov, kar omeji halucinirane odgovore, ko dokumentacija molči. Nato prejme navodilo, naj za vsako trditev navede številko odlomka, kar omogoča preverjanje: pregledovalec lahko na hitro sledi nazaj do vira. temperature 0,1 zaključi nastavitev – pri odgovoru, zasidranem v dokumentih, je ustvarjalnost napaka.

class RAGPipeline:
    """Minimalist RAP pipeline."""

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

    def query(self, question: str, top_k: int = 3) -> str:
        """Answers a question based on the documents."""
        # Retrieval
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Prompt augmentation
        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}"""

        # Generation
        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

Razčlenjevanje: deljenje dokumentov

Razčlenjevanje dokumentov na dele (chunking) je ključnega pomena za kakovost pridobivanja. Če so deli preveliki, utopijo relevantne informacije; če so premajhni, izgubijo kontekst. Priročnik API, razdeljen na desetstranske bloke, bo vedno vrnil isti generični blok, ne glede na zastavljeno vprašanje. Če ga razdeliš na izolirane stavke, bo vrnil stavek, ki se začne z „ta metoda”, ne da bi model vedel, na katero metodo se nanaša. Prekrivanje (overlap) specifično ublaži to tveganje: vsak del ponovi konec prejšnjega, tako da informacija, ki prečka mejo, ostane berljiva vsaj z ene strani.

Ko imajo tvoji dokumenti strukturo naslovov, je razčlenjevanje po razdelkih skoraj vedno boljše od razčlenjevanja fiksne velikosti: razdelek „Avtentikacija” ostane nedotaknjen, skupaj z uvodom in primeri.

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

Napredne strategije pridobivanja

Ponovno razvrščanje (Reranking)

Po začetnem pridobivanju uporabi LLM za prerazvrstitev rezultatov. Logika je lijakasta: vektorsko iskanje je hitro, a približno, in vrne ducat verjetnih kandidatov; model, ki je počasnejši, a bolj niansiran, ponovno prebere te kandidate z vednostjo o vprašanju in jih razvrsti. Nato za generacijo obdržiš le vrh seznama. Dobiček je najbolj viden pri vprašanjih, kjer več odlomkov govori o isti temi, a nanjo odgovarja le eden – trije razdelki omenjajo besedo „kvota”, a le eden pojasnjuje, kako jo zvišati.

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

Hipotetično vlaganje dokumentov (HyDE)

Generiraj idealen hipotetični dokument, nato poišči podobne dokumente. Težava, ki jo rešuje ta tehnika, je neskladje besedišča: vprašanje, zastavljeno v vsakdanjem jeziku, vektorsko ne izgleda kot odstavek tehnične dokumentacije. Tako da najprej modelu naročiš, naj napiše odgovor, kot si ga zamišlja, dobiš besedilo, napisano v registru tvojih dokumentov, in prav to besedilo uporabiš kot poizvedbo. Ni pomembno, če hipotetični odstavek vsebuje približke: nikoli ne služi kot odgovor, ampak le kot 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)

Uporaba nativnega iskanja po datotekah pri OpenAI

Za hitro uvedbo API ponuja integrirano pridobivanje. Naložiš datoteko, ustvariš vektorsko shrambo, ji pripneš datoteko in v klicu deklariraš orodje file_search: razčlenjevanje, vlaganje in iskanje so obravnavani na strani strežnika. To je prava izbira, ko so tvoji dokumenti standardni in te ne zanima, kje živijo podatki. Domači cevovod obdrži prednost takoj, ko moraš obvladovati razčlenjevanje, gostiti indeks sam ali priklopiti specifično ponovno razvrščanje.

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

Vzpostavi izhodišče

Vzemi pet do deset strani tehnične dokumentacije in implementiraj celoten cevovod, od razčlenjevanja do generiranja. Zapiši deset vprašanj, katerih odgovori so v dokumentih, zaženi cevovod za vsako od njih, nato postopek ponovi z omogočenim ponovnim razvrščanjem: prav z opazovanjem, pri katerih vprašanjih se razvrstitev spremeni, razumeš, kaj samo vektorsko iskanje spregleda. Zaključi z merjenjem odstotka pravilno zasidranih odgovorov, torej tistih, kjer se vsaka trditev dejansko nanaša na priložen odlomek. Ta številka je tvoje izhodišče; vse nadaljnje optimizacije bodo ocenjene glede na njo, ne glede na vtis, ki ga pustita dva ali tri naključno prebrana odgovora.

Ključne ugotovitve

  • RAP avtomatizira vnašanje relevantnega konteksta v poziv
  • Razčlenjevanje je ključno: eksperimentiraj z različnimi velikostmi
  • Ponovno razvrščanje z LLM bistveno izboljša relevantnost
  • HyDE je uporaben, ko se vprašanje močno razlikuje od besedišča dokumentov
  • OpenAI File Search poenostavi uvedbo za standardne primere