A teljes RAG-architektúra
Ezen az oldalon
A leckét 2026. november 3-án frissítettük az OpenAI dokumentációja alapján: a
temperatureés atop_pparaméterek csaknonegondolkodá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 areasoning={"effort": "none"}(API Responses) vagyreasoning_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és | Lehetsé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és | Hibrid keresés, újra rangsorolás (reranking), metaadat-szűrők |
| Prompt | Rendszerutasítások, kontextus formátuma, few-shot példák |
| Generálás | Modell, 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