Kompletná architektúra RAG
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre
temperatureatop_psú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom nanone, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovaťreasoning={"effort": "none"}(API Responses) aleboreasoning_effort="none"(Chat Completions). Zdroje: Používanie GPT-6 · GPT-5.6 Terra.
Ciele
- Pochopiť architektúru RAG od začiatku do konca
- Implementovať funkčné pipeline RAG
- Identifikovať komponenty na optimalizáciu
Čo je RAG?
RAG (Retrieval-Augmented Generation – generovanie rozšírené o vyhľadávanie) spája vyhľadávanie v dokumentoch s generovaním textu pomocou LLM. Namiesto toho, aby sa model spoliehal výlučne na svoje vnútorné vedomosti, dostane ako kontext relevantné dokumenty a na ich základe následne zostaví odpoveď. Všetko, čo si vybudoval od začiatku tohto kurzu – vektory (embeddings), indexovanie, vyhľadávanie, evaluácia – sa tu stáva hornou polovicou kompletného systému.
Prečo RAG?
Existujú štyri dôvody, ktoré sa navzájom násobia. Po prvé, vlastné dáta: tvoja politika práce na diaľku, interné postupy a katalóg produktov sa nikdy neobjavili vo vzdelávacích dátach modelu a žiadny prompt ich tam nedostane. Po druhé, aktuálne informácie: všetko, čo vzniklo po dátume ukončenia trénovania, je pre model neviditeľné, zatiaľ čo index sa dá aktualizovať v ten istý deň. Rovnako dôležitá je overiteľnosť, pretože každá odpoveď je ukotvená v identifikovateľných zdrojoch, ktoré si používateľ môže otvoriť a skontrolovať – čím sa mení samotná podstata dôvery v systém. Nakoniec, náklady hrajú v jeho prospech: pridávanie vedomostí prostredníctvom RAG stojí oveľa menej ako jemné doladenie (fine-tuning) a opravy sa realizujú vymazaním dokumentu namiesto pretrénovania modelu.
Fázy pipeline
RAG vnímaj ako dva odlišné procesy, ktoré si nesmieš pliesť. Ingestia prebieha offline, raz a navždy alebo vždy pri aktualizácii korpusu:
Documents → Chunking → Embeddings → Vector Storage
Dotaz prebieha online, pri každej položenej otázke, a musí zostať rýchly:
Question → Embedding → Search → Context + Question → LLM → Response
Toto oddelenie má praktický dôsledok: náklady na ingestiu zaplatíš raz a môžu byť vysoké, zatiaľ čo náklady na dotaz sa platia za každé volanie a určujú používateľskú skúsenosť. Môžeš si teda dovoliť sofistikované spracovanie pri ingestii, ale na strane dotazov musíš zostať štíhly.
Kompletná implementácia
Nasledujúca trieda materializuje tri fázy do troch odlišných metód plus štvrtú, ktorá ich spája do reťazca. Toto oddelenie nie je len kozmetické: umožňuje ti testovať vyhľadávanie bez spotreby tokenov na generovanie a opakovať generovanie na fixnom kontexte, aby si porovnal dva prompty.
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
]
}
Tri detaily vo fáze generovania rozhodujú o väčšine kvality. Systémová správa nariaďuje odpovedať výlučne na základe poskytnutých dokumentov a priznať, keď informácia chýba: bez tejto inštrukcie model vyplní medzery svojimi všeobecnými vedomosťami, čo vedie k vierohodnej, ale vymyslenej odpovedi. Prefix [Source: id] pred každým úryvkom dáva modelu niečo konkrétne na citovanie, namiesto vágneho „podľa dokumentov“. Nakoniec, hodnota temperature 0,2 znižuje variabilitu: pri faktických otázkach proti báze dokumentov chceš konzistentnosť, nie kreativitu.
Použitie
Otestujme pipeline na minimálnom obchodnom prípade – tri interné smernice a otázka, ktorá nekopíruje ich presné znenie.
# 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']}")
Posuň cvičenie ďalej položením otázky, na ktorú žiadny dokument neodpovedá, napríklad otázkou o firemnom zdravotnom poistení. Pipeline stále vráti tri zdroje – vyhľadávanie vždy vráti svojich k najlepších kandidátov – a práve systémová správa musí zabrániť modelu, aby si odpoveď vymyslel. Overenie tohto správania pred nasadením do produkcie je lepšie než jeho objavovanie až cez sťažnosť.
Body optimalizácie
Každý krok pipeline sa dá vylepšiť nezávisle, čo umožňuje postupovať pomocou malých, merateľných úprav.
| Krok | Možné optimalizácie |
|---|---|
| Chunking | Veľkosť chunku, prekrytie, sémantické chunkovanie |
| Embedding | Výber modelu, dimenzie, obohatenie textu |
| Search | Hybridné vyhľadávanie, preradenie (reranking), filtre metadát |
| Prompt | Systémové inštrukcie, formát kontextu, few-shot |
| Generation | Model, teplota, citácie |
Nasledujúce lekcie podrobne rozoberajú každú z týchto optimalizácií. Rieš ich v tomto poradí: chunkovanie určuje, čo sa dá vyhľadať, a žiadne preradenie (reranking) neopraví zle rozdelený dokument.
Kľúčové poznatky
- RAG = Vyhľadávanie + Kontext + Generovanie LLM
- Pipeline sa delí na ingestiu (offline) a dotaz (online)
- Každý komponent (chunking, embedding, vyhľadávanie, prompt, generovanie) sa dá optimalizovať nezávisle
- RAG je flexibilnejší a lacnejší spôsob pridávania vedomostí než fine-tuning