Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Visa RAG architektūra

Paskaita 11 iš 22 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Kas yra RAG?
  3. Proceso etapai
  4. Pilnas įgyvendinimas
  5. Naudojimas
  6. Optimizavimo punktai
  7. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ dokumentaciją: parametrai temperature ir top_p priimami tik esant none lygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodyti reasoning={"effort": "none"} (API Responses) arba reasoning_effort="none" (Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.

Tikslai

  • Suprasti visą RAG architektūrą nuo pradžios iki galo
  • Įgyvendinti veikiantį RAG procesą
  • Nustatyti komponentus, kuriuos galima optimizuoti

Kas yra RAG?

RAG (Retrieval-Augmented Generation – generavimas, papildytas paieška) sujungia dokumentų paiešką su teksto generavimu naudojant didelį kalbos modelį (LLM). Užuot pasikliovęs tik savo vidinėmis žiniomis, modelis gauna aktualius dokumentus kaip kontekstą ir pagal juos suformuluoja atsakymą. Viskas, ką kūrei nuo šio kurso pradžios – įterpinius (embeddings), indeksavimą, paiešką, vertinimą – čia tampa pilnos sistemos pirmąja puse.

Kodėl RAG?

Tam yra keturios priežastys, ir jos sustiprina viena kitą. Pirma, nuosavi duomenys: tavo nuotolinio darbo politika, vidinės procedūros ir produktų katalogas niekada nebuvo modelio mokymo duomenyse, ir joks raginimas (prompt) jų ten nepateks. Antra, naujausia informacija: viskas, kas atsirado po mokymo datos, modeliui yra nematoma, tuo tarpu indeksą galima atnaujinti tą pačią dieną. Patikrinamumas yra lygiai taip pat svarbus, nes kiekvienas atsakymas yra pagrįstas identifikuojamais šaltiniais, kuriuos vartotojas gali atidaryti ir patikrinti – tai iš esmės keičia pasitikėjimo sistema pobūdį. Galiausiai, kaštai kalba jo naudai: žinių pridėjimas per RAG kainuoja daug mažiau nei derinimas (fine-tuning), o klaidos taisomos tiesiog ištrinant dokumentą, o ne permodeliuojant visą modelį.

Proceso etapai

RAG reikia skaityti kaip du atskirus etapus, kurių negalima painioti. Priėmimas (Ingestion) vyksta ne realiuoju laiku, vieną kartą arba kai tik atnaujinamas dokumentų rinkinys:

Dokumentai → Skaidymas → Įterpiniai → Vektorinė saugykla

Užklausa vyksta realiuoju laiku, kiekvieną kartą užduodant klausimą, ir turi būti greita:

Klausimas → Įterpinys → Paieška → Kontekstas + Klausimas → LLM → Atsakymas

Šis atskyrimas turi praktinę pasekmę: priėmimo kaštai patiriami vieną kartą ir gali būti dideli, tuo tarpu užklausų kaštai mokami už kiekvieną kvietimą ir lemia vartotojo patirtį. Todėl priėmimo etape gali sau leisti sudėtingą apdorojimą, tačiau užklausų etape privalai išlikti maksimaliai efektyvus.

Pilnas įgyvendinimas

Toliau pateikta klasė materializuoja tris etapus trijuose atskiruose metoduose, plus ketvirtą, kuris juos sujungia į vieną grandinę. Šis atskyrimas nėra tik formalus: jis leidžia testuoti paiešką nesunaudodant generavimo tokenų ir kartoti generavimą su fiksuotu kontekstu, lyginant skirtingus raginimus.

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

    # --- Priėmimo etapas ---

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

        # Generuojame įterpinius grupėmis
        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"Priėmimas baigtas: indeksuota {len(self.chunks)} dalis")

    # --- Gavimo etapas ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Randa k aktualiausių dalių."""
        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
        ]

    # --- Generavimo etapas ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generuoja atsakymą remdamasis gautu kontekstu."""
        # Suformuojame raginimą
        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

    # --- Pilnas procesas ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Pilnas RAG procesas: paieška → generavimas."""
        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
            ]
        }

Trys detalės generavimo etape lemia didžiąją dalį kokybės. Sistemos žinutė įpareigoja atsakyti tik remiantis pateiktais dokumentais ir pripažinti, kai informacijos trūksta: be šios instrukcijos modelis užpildys spragas savo bendrosiomis žiniomis, sukurdamas tikroviškai skambantį, tačiau išgalvotą atsakymą. Prieš kiekvieną ištrauką esantis priešdėlis [Source: id] suteikia modeliui ką konkrečiai cituoti, o ne miglotą „pagal dokumentus“. Galiausiai, temperature reikšmė 0,2 sumažina variaciją: faktiniams klausimams, remiantis dokumentų baze, tau reikia nuoseklumo, o ne kūrybiškumo.

Naudojimas

Išbandykime šį procesą su minimaliu verslo atveju – trimis vidinėmis politikomis ir klausimu, kuris neatkartoja jokio jų tikslios formuluotės.

# Paruošiame dokumentus
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"}
    },
]

# Sukuriame procesą
rag = PipelineRAG()
rag.ingest(documents)

# Užduodame klausimą
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']}")

Patobulink pratimą užduodamas klausimą, į kurį neatsako joks dokumentas, pavyzdžiui, apie įmonės sveikatos draudimo planą. Procesas vis tiek grąžins tris šaltinius – paieška visada grąžina k geriausius kandidatus – ir būtent sistemos žinutė turi sutrukdyti modeliui išgalvoti atsakymą. Geriau patikrinti šį elgesį prieš paleidžiant į gamybą, nei sužinoti apie jį iš vartotojo skundo.

Optimizavimo punktai

Kiekvieną proceso žingsnį galima pagerinti nepriklausomai, leidžiant progresuoti mažais, išmatuojamais pakeitimais.

ŽingsnisGalimos optimizacijos
SkaidymasDalies dydis, persidengimas, semantinis skaidymas
ĮterpiniaiModelio pasirinkimas, matmenys, teksto praturtinimas
PaieškaHibridinė, perrikiavimas, metaduomenų filtrai
RaginimasSistemos instrukcijos, konteksto formatas, few-shot
GeneravimasModelis, temperatūra, citavimas

Kitose pamokose išsamiai aptarsime kiekvieną iš šių optimizacijų. Imkis jų šia tvarka: skaidymas lemia, ką galima gauti, ir joks perrikiavimas neištaisys blogai suskaidyto dokumento.

Svarbiausi punktai

  • RAG = Paieška + Kontekstas + LLM Generavimas
  • Procesas skirstomas į priėmimą (ne realiuoju laiku) ir užklausą (realiuoju laiku)
  • Kiekvieną komponentą (skaidymą, įterpinius, paiešką, raginimą, generavimą) galima optimizuoti nepriklausomai
  • RAG yra lankstesnis ir pigesnis nei derinimas (fine-tuning), norint pridėti naujų žinių