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

Potpuna arhitektura RAG-a

Lekcija 11 od 22 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Što je RAG?
  3. Faze pipelinea
  4. Potpuna implementacija
  5. Korištenje
  6. Točke optimizacije
  7. Ključne točke

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

Ciljevi

  • Razumjeti RAG arhitekturu od početka do kraja
  • Implementirati funkcionalan RAG pipeline
  • Identificirati komponente za optimizaciju

Što je RAG?

RAG (Retrieval-Augmented Generation) kombinira pretraživanje dokumenata s generiranjem teksta pomoću LLM-a. Umjesto da se oslanja isključivo na svoje interno znanje, model prima relevantne dokumente kao kontekst, a zatim na temelju tog konteksta sastavlja odgovor. Sve što si izgradio od početka ovog tečaja—ugrađivanja (embeddings), indeksiranje, pretraživanje, evaluacija—ovdje postaje gornja polovina cjelovitog sustava.

Zašto RAG?

Četiri razloga to opravdavaju, a oni se međusobno pojačavaju. Prvo, vlastiti podaci: tvoja politika rada na daljinu, interni postupci i katalog proizvoda nikada se nisu pojavili u podacima za obuku modela, i nijedan prompt ih tamo neće ubaciti. Drugo, nedavne informacije: sve što je nastalo nakon završetka obuke modelu je nevidljivo, dok se indeks može ažurirati istog dana. Provjerljivost je jednako važna jer je svaki odgovor sidren u identificirane izvore koje korisnik može otvoriti i provjeriti—time se mijenja sama narav povjerenja u sustav. Konačno, trošak ide u njegovu korist: dodavanje znanja putem RAG-a košta znatno manje od finog podešavanja (fine-tuning), a ispravci se vrše brisanjem dokumenta umjesto ponovnom obukom modela.

Faze pipelinea

RAG čitaj kao dva različita procesa koja ne smiješ miješati. Unos podataka (Ingestion) događa se izvan mreže (offline), jednom zauvijek ili kad god se korpus ažurira:

Dokumenti → Dijeljenje (Chunking) → Ugrađivanja (Embeddings) → Vektorska pohrana

Upit se događa na mreži (online), za svako postavljeno pitanje, i mora ostati brz:

Pitanje → Ugrađivanje → Pretraživanje → Kontekst + Pitanje → LLM → Odgovor

Ova odvojenost ima praktičnu posljedicu: troškovi unosa podataka plaćaju se jednom i mogu biti veliki, dok se troškovi upita plaćaju po pozivu i diktiraju korisničko iskustvo. Stoga si možeš priuštiti sofisticiranu obradu pri unosu, ali moraš ostati što lakši na strani upita.

Potpuna implementacija

Sljedeća klasa materijalizira tri faze u tri različite metode, plus četvrtu koja ih povezuje u lanac. Ova odvojenost nije kozmetička: omogućuje ti testiranje pretraživanja bez trošenja tokena za generiranje i ponovno pokretanje generiranja na fiksnom kontekstu kako bi usporedio dva prompta.

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Faza unosa (Ingestion) ---

    def ingest(self, documents: list[dict]):
        """Unosi dokumente {id, text, metadata}."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Generiraj ugrađivanja u serijama
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Unos završen: {len(self.chunks)} dijelova indeksirano")

    # --- Faza dohvaćanja (Retrieval) ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Pronalazi k najrelevantnijih dijelova."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Faza generiranja (Generation) ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generira odgovor na temelju dohvaćenih konteksta."""
        # Izgradi prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Source: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "You are an assistant that answers questions "
                    "based solely on the provided documents. "
                    "If the information is not in the documents, "
                    "state this clearly. Cite your sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Reference documents:\n\n{formatted_context}\n\n"
                    f"---\n\nQuestion: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature requires effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Potpuni pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Potpuni RAG pipeline: pretraživanje → generiranje."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Tri detalja u fazi generiranja najviše utječu na kvalitetu. Sistemska poruka nalaže odgovaranje isključivo na temelju priloženih dokumenata i priznavanje kada informacije nedostaju: bez ove upute, model će popuniti praznine svojim općim znanjem, što rezultira uvjerljivim, ali izmišljenim odgovorom. Prefiks [Source: id] ispred svakog isječka daje modelu nešto konkretno za citiranje, umjesto neodređenog „prema dokumentima“. Konačno, temperature od 0.2 smanjuje varijabilnost: za činjenična pitanja nasuprot bazi dokumenata, želiš dosljednost, a ne kreativnost.

Korištenje

Testirajmo pipeline na minimalnom poslovnom slučaju—tri interne politike i pitanje koje ne kopira nijednu od njihovih točnih formulacija.

# Pripremi dokumente
documents = [
    {
        "id": "leave-policy",
        "text": "Employees receive 25 days of paid leave "
                 "per year. Leave must be requested at least 2 weeks "
                 "in advance via the HR portal.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Remote work is authorized up to 3 days per week. "
                 "Tuesdays and Thursdays are mandatory office days. "
                 "Written agreement with the manager is required.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Expense reports must be submitted within 30 days "
                 "of the expense. Attach the original receipt. "
                 "Validation by the direct supervisor required for amounts over 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Stvori pipeline
rag = PipelineRAG()
rag.ingest(documents)

# Postavi pitanje
result = rag.answer("How many days of remote work per week?")
print(result["response"])
print("\nSources used:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Gurni vježbu korak dalje postavljajući pitanje na koje nijedan dokument ne odgovara, poput onog o zdravstvenom osiguranju tvrtke. Pipeline će i dalje vratiti tri izvora—pretraživanje uvijek vraća svojih k najboljih kandidata—i sistemska poruka je ta koja mora spriječiti model da izmisli odgovor. Provjera ovog ponašanja prije produkcije bolja je od otkrivanja kroz pritužbu.

Točke optimizacije

Svaki korak pipelinea može se poboljšati neovisno, omogućujući napredak kroz male, mjerljive prilagodbe.

KorakMoguće optimizacije
Dijeljenje (Chunking)Veličina dijela, preklapanje, semantičko dijeljenje
Ugrađivanje (Embedding)Izbor modela, dimenzije, obogaćivanje teksta
Pretraživanje (Search)Hibridno, ponovno rangiranje (reranking), filteri metapodataka
PromptSistemske upute, format konteksta, few-shot primjeri
GeneriranjeModel, temperatura, citati

Sljedeće lekcije detaljno obrađuju svaku od ovih optimizacija. Rješavaj ih ovim redoslijedom: dijeljenje određuje što se može dohvatiti, i nikakvo ponovno rangiranje neće popraviti loše podijeljen dokument.

Ključne točke

  • RAG = Pretraživanje + Kontekst + Generiranje LLM-om
  • Pipeline se dijeli na unos (offline) i upit (online)
  • Svaka komponenta (dijeljenje, ugrađivanje, pretraživanje, prompt, generiranje) može se optimizirati neovisno
  • RAG je fleksibilniji i jeftiniji od finog podešavanja (fine-tuning) za dodavanje znanja