Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Prompting potpomognut dohvaćanjem

Lekcija 9 od 16 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Prompting potpomognut dohvaćanjem
  2. Arhitektura RAP sustava
  3. Potpuni cjevovod
  4. Chunking: dijeljenje dokumenata
  5. Napredne strategije dohvaćanja
  6. Korištenje OpenAI-jevog izvornog File Searcha
  7. Uspostavi osnovnu liniju
  8. Ključne točke

Lekcija ažurirana 3. studenoga 2026. na temelju OpenAI dokumentacije: parametri temperature i top_p prihvaćeni su samo uz napor razmišljanja (reasoning effort) od none, dok modeli GPT-5.6 prema zadanim postavkama razmišljaju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificirati reasoning={"effort": "none"} (Responses API) ili reasoning_effort="none" (Chat Completions). Izvori: Korištenje GPT-6 · GPT-5.6 Terra.

Prompting potpomognut dohvaćanjem

Prompting potpomognut dohvaćanjem (RAP – Retrieval-Augmented Prompting) kombinira pretraživanje dokumenata s promptingom kako bi modelu osigurao relevantan i ažuran kontekst. To je prirodna evolucija utemeljenja (grounding): umjesto ručnog ubacivanja konteksta, automatiziraš pretraživanje relevantnih odlomaka prije svakog poziva LLM-u.

Razlika postaje očita u većem opsegu. Ručno kopiranje triju korisnih odlomaka iz tvoje dokumentacije funkcionira za demonstraciju; no čim baza dokumentacije naraste na nekoliko stotina stranica, a pitanja pristižu neprestano, nitko više ne zna koje odlomke kopirati. RAP delegira taj izbor automatskoj komponenti koja se pokreće prije svake generacije, a čija je jedina uloga pronaći što treba staviti u prompt.

Arhitektura RAP sustava

RAP cjevovod dijeli se na tri koraka koji rade različitim brzinama i troškovima. Indeksiranje transformira tvoje dokumente u vektorske ugradnje (embeddings); to se događa jednom, izvan mreže (offline), pretvarajući svaki dokument u numerički vektor koji kodira njegovo značenje, pohranjen uz izvorni tekst. Dohvaćanje (retrieval), nasuprot tome, pokreće se na svako pitanje: pitanje transformiraš u vektor koristeći isti model za ugradnju, zatim tražiš najbliže vektore dokumenata. Konačno, augmentacija je samo standardni prompting – gradiš sistemski prompt koji sadrži dohvaćene odlomke i upućuješ model da ne izlazi iz tog okvira.

Zapamti ovu podjelu: sve što je skupo događa se tijekom indeksiranja, gdje si možeš priuštiti biti zahtjevan, dok sve što se ponavlja za svako pitanje mora ostati brzo. Kod u nastavku implementira prva dva koraka koristeći kosinusnu sličnost kao mjeru bliskosti.

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

Potpuni cjevovod

Spajanjem ovih gradivnih blokova dobivaš klasu koja staje u tridesetak redaka. Većina odluka događa se u generiranom sistemskom promptu i vrijedi ga pročitati redak po redak. Model prvo prima naredbu da odgovara ISKLJUČIVO na temelju priloženih odlomaka, što ograničava halucinirane odgovore kada dokumentacija šuti. Zatim prima uputu da citira broj odlomka za svaku tvrdnju, a to je ono što omogućuje provjeru: recenzent može u trenu pratiti izvor natrag. temperature od 0.1 dovršava postavku – kod odgovora utemeljenih na dokumentima, kreativnost je greška.

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

Chunking: dijeljenje dokumenata

Dijeljenje dokumenata na chunkove (odlomke) ključno je za kvalitetu dohvaćanja. Ako su chunkovi preveliki, guše relevantne informacije; ako su premali, gube kontekst. API priručnik podijeljen na blokove od deset stranica uvijek će vratiti isti generički blok, bez obzira na postavljeno pitanje. Podijeljen na izolirane rečenice, vratit će rečenicu koja počinje s „ova metoda“, a da model ne zna na koju se metodu misli. Preklapanje (overlap) specifično ublažava taj rizik: svaki chunk ponavlja kraj prethodnog, tako da informacija koja prelazi granicu ostaje čitljiva barem s jedne strane.

Kada tvoji dokumenti imaju strukturu naslova, chunking temeljen na odjeljcima gotovo je uvijek superioran chunkingu fiksne veličine: odjeljak „Autentifikacija“ ostaje netaknut, sa svojim uvodom i primjerima.

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 dohvaćanja

Ponovno rangiranje (Reranking)

Nakon početnog dohvaćanja, upotrijebi LLM za ponovno uređivanje rezultata. Logika je lijevka: vektorsko pretraživanje je brzo, ali približno, vraćajući desetak vjerojatnih kandidata; model, sporiji ali nijansiraniji, ponovno čita te kandidate znajući pitanje i rangira ih. Zatim zadržavaš samo vrh liste za generiranje. Dobitak je najvidljiviji kod pitanja gdje nekoliko odlomaka govori o istoj temi, ali samo jedan zapravo odgovara na pitanje – tri odjeljka spominju riječ „kvota“, ali samo jedan objašnjava kako je poveć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

Hipotetsko ugrađivanje dokumenata (HyDE)

Generiraj idealan hipotetski dokument, zatim potraži slične dokumente. Problem koji ova tehnika rješava je neusklađenost rječnika: pitanje postavljeno svakodnevnim jezikom ne izgleda, vektorski, kao odlomak tehničke dokumentacije. Tako što prvo zamoliš model da napiše odgovor kakav zamišlja, dobivaš tekst napisan registrom tvojih dokumenata, i taj tekst koristiš kao upit. Nije bitno sadrži li hipotetski odlomak približne vrijednosti: on nikada ne služi kao odgovor, već samo kao 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)

Korištenje OpenAI-jevog izvornog File Searcha

Za brzo raspoređivanje, API nudi integrirano dohvaćanje. Učitaš datoteku, stvoriš vektorsku pohranu (vector store), pridružiš joj datoteku i deklariraš alat file_search u pozivu: chunking, ugradnja i pretraživanje obrađuju se na strani poslužitelja. To je ispravan izbor kada su tvoji dokumenti standardni i nije ti bitno gdje se podaci nalaze. Vlastiti cjevovod zadržava prednost čim trebaš svladati chunking, samostalno hostati indeks ili uključiti specifično ponovno rangiranje.

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

Uspostavi osnovnu liniju

Uzmi pet do deset stranica tehničke dokumentacije i implementiraj potpuni cjevovod, od chunkinga do generiranja. Napiši deset pitanja čiji se odgovori nalaze u dokumentima, pokreni cjevovod na svakom od njih, zatim ponovi postupak s uključenim ponovnim rangiranjem: promatranjem pitanja kod kojih se rangiranje mijenja razumiješ što samom vektorskom pretraživanju nedostaje. Završi mjerenjem postotka ispravno utemeljenih odgovora, onih gdje se svaka tvrdnja učinkovito poziva na priloženi odlomak. Ta je brojka tvoja početna točka; sve naknadne optimizacije procjenjivat će se u odnosu na nju, a ne prema dojmu koji ostave dva ili tri nasumično pročitana odgovora.

Ključne točke

  • RAP automatizira ubacivanje relevantnog konteksta u prompt
  • Chunking je ključan: eksperimentiraj s različitim veličinama
  • Ponovno rangiranje pomoću LLM-a značajno poboljšava relevantnost
  • HyDE je koristan kada se pitanje jako razlikuje od rječnika dokumenata
  • OpenAI File Search pojednostavljuje raspoređivanje za standardne slučajeve