Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A teljes RAG-architektúra

11. lecke 22 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Mi az a RAG?
  3. A folyamat szakaszai
  4. Teljes megvalósítás
  5. Használat
  6. Optimalizálási pontok
  7. Főbb megállapítások

A leckét 2026. november 3-án frissítettük az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk a reasoning={"effort": "none"} (API Responses) vagy reasoning_effort="none" (Chat Completions) értéket. Források: GPT-6 használata · GPT-5.6 Terra.

Célok

  • Megérteni a végpontok közötti RAG-architektúrát
  • Működőképes RAG-folyamatot megvalósítani
  • Azonosítani az optimalizálható komponenseket

Mi az a RAG?

A RAG (Retrieval-Augmented Generation, azaz visszakereséssel bővített generálás) egyesíti a dokumentumkeresést az LLM általi szöveggenerálással. Ahelyett, hogy kizárólag a belső tudására támaszkodna, a modell releváns dokumentumokat kap kontextusként, majd ezek alapján fogalmazza meg a választ. Minden, amit e tanfolyam kezdete óta felépítettél – beágyazások, indexelés, keresés, kiértékelés –, itt válik egy teljes rendszer upstream (bemeneti) felévé.

Miért a RAG?

Négy ok igazolja alkalmazását, és ezek hatása összeadódik. Először is: saját adatok. A távmunka-szabályzatod, belső eljárásaid és terméklistád sosem szerepeltek a modell tanítóadataiban, és egyetlen prompttal sem kerülhetnek oda. Másodszor: friss információk. Minden, ami a tanítás dátuma után keletkezett, láthatatlan a modell számára, míg egy index még ugyanazon a nap frissíthető. A ellenőrizhetőség ugyanilyen fontos, mivel minden válasz azonosítható forrásokra épül, amelyeket a felhasználó megnyithat és ellenőrizhet – ez alapjaiban változtatja meg a rendszerbe vetett bizalom természetét. Végül a költséghatékonyság is mellette szól: a tudás RAG-on keresztüli hozzáadása sokkal olcsóbb, mint a finomhangolás (fine-tuning), a javítások pedig egy dokumentum törlésével történnek, nem pedig egy modell újratanításával.

A folyamat szakaszai

A RAG-rendszert két elkülönült fázisként kell értelmezned, amelyeket nem szabad összekeverni. A betáplálás (ingestion) offline történik, egyszer és mindenkorra, vagy amikor a korpusz frissül:

Dokumentumok → Darabolás (Chunking) → Beágyazások → Vektortároló

A lekérdezés (query) online zajlik, minden egyes feltett kérdésre, és gyorsnak kell maradnia:

Kérdés → Beágyazás → Keresés → Kontextus + Kérdés → LLM → Válasz

Ennek a szétválasztásnak gyakorlati következménye van: a betáplálás költségeit egyszer kell megfizetni (és ezek magasak is lehetnek), míg a lekérdezés költségei hívásonként merülnek fel, és közvetlenül befolyásolják a felhasználói élményt. Ezért engedhetsz meg magadnak összetett feldolgozást a betáplálás során, de a lekérdezés oldalán karcsúnak kell maradnod.

Teljes megvalósítás

Az alábbi osztály három különálló metódusban valósítja meg a három fázist, plusz egy negyedikben, amely láncolja őket. Ez a szétválasztás nem csupán esztétikai: lehetővé teszi, hogy teszteld a keresést anélkül, hogy generálási tokeneket fogyasztanál, illetve hogy rögzített kontextuson játszd újra a generálást két prompt összehasonlításához.

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

    # --- Ingestion Phase ---

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

        # Generate embeddings in batches
        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"Ingestion complete: {len(self.chunks)} chunks indexed")

    # --- Retrieval Phase ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Finds the k most relevant chunks."""
        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
        ]

    # --- Generation Phase ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generates a response based on retrieved contexts."""
        # Build the 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

    # --- Complete Pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Complete RAG pipeline: search → generation."""
        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
            ]
        }

A generálási fázisban három részlet dönti el a minőség nagy részét. A rendszerüzenet (system message) előírja, hogy kizárólag a megadott dokumentumok alapján válaszolj, és valljad be, ha hiányzik az információ: e utasítás nélkül a modell a saját általános tudásával tölti ki a hézagokat, ami hihető, de kitalált választ eredményez. A [Source: id] előtag minden részlet előtt konkrét hivatkozási pontot ad a modellnek, nem pedig egy homályos „a dokumentumok szerint“ kitételt. Végül a 0,2-es temperature csökkenti a variabilitást: ténykérdéseknél, dokumentumbázis ellenében a konzisztenciára van szükséged, nem a kreativitásra.

Használat

Teszteljük a folyamatot egy minimális üzleti eseten – három belső szabályzaton és egy olyan kérdéssel, amely nem másolja szó szerint egyik szövegét sem.

# Prepare documents
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"}
    },
]

# Create the pipeline
rag = PipelineRAG()
rag.ingest(documents)

# Ask a question
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']}")

Vidd tovább a gyakorlatot egy olyan kérdéssel, amelyre egyetlen dokumentum sem ad választ, például a cég egészségbiztosítási tervéről. A folyamat ekkor is visszaad három forrást – a keresés mindig visszaadja a k legjobb jelöltet –, és a rendszerüzenet feladata megakadályozni, hogy a modell kitaláljon egy választ. Jobb ezt a viselkedést élesítés előtt ellenőrizni, mintsem egy panasz révén felfedezni.

Optimalizálási pontok

A folyamat minden lépése függetlenül javítható, lehetővé téve a haladást kicsi, mérhető módosításokon keresztül.

LépésLehetséges optimalizálások
Darabolás (Chunking)Darabméret, átfedés, szemantikai darabolás
Beágyazás (Embedding)Modellválasztás, dimenziók, szöveggazdagítás
KeresésHibrid keresés, újra rangsorolás (reranking), metaadat-szűrők
PromptRendszerutasítások, kontextus formátuma, few-shot példák
GenerálásModell, temperature, hivatkozások

A következő leckék mindegyik optimalizálást részletesen tárgyalják. Ebben a sorrendben haladj: a darabolás határozza meg, mi kereshető vissza, és egyetlen újra rangsorolás sem javít egy rosszul darabolt dokumentumon.

Főbb megállapítások

  • RAG = Keresés + Kontextus + LLM-generálás
  • A folyamat két részre oszlik: betáplálás (offline) és lekérdezés (online)
  • Minden komponens (darabolás, beágyazás, keresés, prompt, generálás) függetlenül optimalizálható
  • A tudás hozzáadásához a RAG rugalmasabb és kevésbé költséges, mint a finomhangolás