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

Celotna arhitektura RAG

Lekcija 11 od 22 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Kaj je RAG?
  3. Faze cevovoda
  4. Celotna implementacija
  5. Uporaba
  6. Točke optimizacije
  7. 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"} (API Responses) ali reasoning_effort="none" (Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Cilji

  • Razumevanje celotne arhitekture RAG od začetka do konca
  • Implementacija delujočega cevovoda RAG
  • Prepoznavanje komponent za optimizacijo

Kaj je RAG?

RAG (Retrieval-Augmented Generation ali generiranje s pomočjo iskanja) združuje iskanje po dokumentih z generiranjem besedila s strani velikega jezikovnega modela (LLM). Namesto da bi se model zanašal izključno na svoje notranje znanje, prejme ustrezne dokumente kot kontekst in nato na podlagi tega konteksta oblikuje odgovor. Vse, kar si zgradil od začetka tega tečaja – vgradnje (embeddings), indeksiranje, iskanje, evalvacija – tu postane zgornji del celovitega sistema.

Zakaj RAG?

Obstajajo štirje razlogi, ki se med seboj krepijo. Prvič, lastniški podatki: tvoja politika dela na daljavo, interni postopki in katalog izdelkov se nikoli niso pojavili v učnih podatkih modela in noben poziv jih ne more tja dodati. Drugič, najnovejše informacije: vse, kar je nastalo po zaključku usposabljanja, je za model nevidno, medtem ko se indeks posodobi še isti dan. Enako pomembna je preverljivost, saj je vsak odgovor sidran v prepoznavnih virih, ki jih uporabnik lahko odpre in preveri – s tem se spremeni narava zaupanja v sistem. Nazadnje, v prid mu govori tudi strošek: dodajanje znanja prek RAG stane bistveno manj kot fino uglaševanje (fine-tuning), popravki pa se izvedejo z brisanjem dokumenta namesto s ponovnim usposabljanjem modela.

Faze cevovoda

RAG beri kot dva ločena procesa, ki ju ne smeš zamenjati. Vnos (Ingestion) poteka brez povezave (offline), enkrat za vselej ali ob vsaki posodobitvi korpusa:

Dokumenti → Razčlenjevanje (Chunking) → Vgradnje → Vektorska shramba

Povpraševanje poteka v realnem času (online), ob vsakem zastavljenem vprašanju, in mora ostati hitro:

Vprašanje → Vgradnja → Iskanje → Kontekst + Vprašanje → LLM → Odgovor

Ta ločitev ima praktično posledico: stroški vnosa se plačajo enkrat in so lahko visoki, medtem ko se stroški povpraševanja plačujejo ob vsakem klicu in določajo uporabniško izkušnjo. Zato si lahko privoščiš sofisticirano obdelavo pri vnosu, moraš pa ostati vitak pri strani povpraševanja.

Celotna implementacija

Naslednji razred materializira tri faze v treh ločenih metodah, plus četrto, ki jih poveže v celoto. Ta ločitev ni kozmetična: omogoča ti testiranje iskanja brez porabe žetonov za generiranje in ponovno izvajanje generiranja na fiksnem kontekstu za primerjavo dveh pozivov.

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 vnosa (Ingestion) ---

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

        # Generiranje vgradenj v serijah
        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"Vnos končan: indeksiranih {len(self.chunks)} delčkov")

    # --- Faza pridobivanja (Retrieval) ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Poišče k najbolj relevantnih delčkov."""
        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 podlagi pridobljenih kontekstov."""
        # Izgradnja poziva
        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

    # --- Celoten cevovod ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Celoten cevovod RAG: iskanje → 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 podrobnosti v fazi generiranja odločilno vplivajo na kakovost. Sistemsko sporočilo zahteva odgovarjanje izključno na podlagi priloženih dokumentov in priznanje, ko informacije manjkajo: brez tega navodila bo model vrzeli zapolnil s svojim splošnim znanjem, kar bo rezultiralo v verjetnem, a izmišljenem odgovoru. Predpona [Source: id] pred vsakim izvlečkom modelu da nekaj konkretnega za citiranje, namesto nejasnega „glede na dokumente”. Nazadnje, temperature vrednosti 0,2 zmanjša variabilnost: za dejanska vprašanja glede na bazo dokumentov želiš doslednost, ne ustvarjalnosti.

Uporaba

Preizkusimo cevovod na minimalnem poslovnem primeru – treh internih pravilnikih in vprašanju, ki ne kopira nobenega od njihovih točnih besedil.

# Priprava dokumentov
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"}
    },
]

# Ustvarjanje cevovoda
rag = PipelineRAG()
rag.ingest(documents)

# Postavitev vprašanja
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']}")

Vajo poglobi tako, da postaviš vprašanje, na katerega noben dokument ne odgovarja, na primer vprašanje o zdravstvenem zavarovanju podjetja. Cevovod bo še vedno vrnil tri vire – iskanje vedno vrne svoje k najboljših kandidatov – in sistemsko sporočilo je tisto, ki mora modelu preprečiti izmišljanje odgovora. Preverjanje tega vedenja pred uvedbo v proizvodnjo je boljše kot odkrivanje težav preko pritožbe.

Točke optimizacije

Vsak korak cevovoda je mogoče izboljšati neodvisno, kar omogoča napredek z majhnimi, merljivimi prilagoditvami.

KorakMožne optimizacije
Razčlenjevanje (Chunking)Velikost delčka, prekrivanje, semantično razčlenjevanje
Vgradnja (Embedding)Izbira modela, dimenzije, obogatitev besedila
IskanjeHibridno, ponovno razvrščanje (reranking), filtri metapodatkov
Poziv (Prompt)Sistemska navodila, format konteksta, nekaj primerov (few-shot)
GeneriranjeModel, temperatura, citati

Naslednje lekcije podrobneje opisujejo vsako od teh optimizacij. Loti se jih v tem vrstnem redu: razčlenjevanje določa, kaj je mogoče pridobiti, in nobeno ponovno razvrščanje ne bo popravilo slabo razčlenjenega dokumenta.

Ključne ugotovitve

  • RAG = Iskanje + Kontekst + Generiranje LLM
  • Cevovod se deli na vnos (offline) in povpraševanje (online)
  • Vsako komponento (razčlenjevanje, vgradnja, iskanje, poziv, generiranje) je mogoče optimizirati neodvisno
  • RAG je bolj prilagodljiv in cenejši od finega uglaševanja za dodajanje znanja