Prompting potpomognut dohvaćanjem
Na ovoj stranici
Lekcija ažurirana 3. studenoga 2026. na temelju OpenAI dokumentacije: parametri
temperatureitop_pprihvaćeni su samo uz napor razmišljanja (reasoning effort) odnone, dok modeli GPT-5.6 prema zadanim postavkama razmišljaju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificiratireasoning={"effort": "none"}(Responses API) ilireasoning_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