Kompletní architektura RAG
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o odvozování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení odvozují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(API Responses) neboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Cíle
- Porozumět architektuře RAG od začátku do konce
- Implementovat funkční pipeline RAG
- Identifikovat komponenty vhodné k optimalizaci
Co je to RAG?
RAG (Retrieval-Augmented Generation, generování rozšířené o vyhledávání) kombinuje vyhledávání v dokumentech s generováním textu pomocí LLM. Místo toho, aby se model spoléhal výhradně na své interní znalosti, obdrží jako kontext relevantní dokumenty a na jejich základě poté sestaví odpověď. Vše, co jsi od začátku tohoto kurzu vybudoval – vnoření (embeddings), indexaci, vyhledávání a evaluaci – se zde stává vstupní polovinou kompletního systému.
Proč RAG?
Existují čtyři důvody, které se vzájemně posilují. Zaprvé, vlastní data: tvá politika práce na dálku, interní procedury a katalog produktů se nikdy neobjevily ve vzdávacích datech modelu a žádný prompt je tam nedostane. Zadruhé, aktuální informace: vše, co vzniklo po ukončení tréninku, je pro model neviditelné, zatímco index lze aktualizovat týž den. Neméně důležitá je ověřitelnost, protože každá odpověď je ukotvena v identifikovatelných zdrojích, které si uživatel může otevřít a zkontrolovat – což mění samotnou podstatu důvěry vkládané do systému. Nakonec, náklady hrají v jeho prospěch: přidání znalostí prostřednictvím RAG stojí výrazně méně než jemné doladění (fine-tuning) a opravy se provádějí smazáním dokumentu, nikoliv přetrénováním modelu.
Fáze pipeline
Na RAG se dívej jako na dvě odlišné fáze, které si nesmíš plést. Ingestace probíhá offline, jednorázově nebo při každé aktualizaci korpusu:
Documents → Chunking → Embeddings → Vector Storage
Dotaz probíhá online, pro každou položenou otázku, a musí zůstat rychlý:
Question → Embedding → Search → Context + Question → LLM → Response
Toto oddělení má praktický dopad: náklady na ingestaci zaplatíš jednou a mohou být vysoké, zatímco náklady na dotaz platíš za každý požadavek a určují uživatelskou zkušenost. Můžeš si tedy dovolit sofistikované zpracování při ingestaci, ale na straně dotazů musíš zůstat štíhlý.
Kompletní implementace
Následující třída materializuje tři fáze do tří samostatných metod plus čtvrtou, která je řadí za sebe. Toto oddělení není jen kosmetické: umožňuje ti testovat vyhledávání bez spotřeby tokenů pro generování a přehrávat generování na fixním kontextu pro porovnání dvou promptů.
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
]
}
Tři detaily ve fázi generování rozhodují o většině kvality. Systémová zpráva vyžaduje odpovídat pouze na základě poskytnutých dokumentů a přiznat, když informace chybí: bez této instrukce model mezery zaplní svými obecnými znalostmi, což vede k věrohodné, ale vymyšlené odpovědi. Prefix [Source: id] před každým úryvkem dává modelu něco konkrétního pro citaci, místo vágního „podle dokumentů“. Nakonec, temperature nastavená na 0,2 snižuje variabilitu: u faktických otázek proti bázi dokumentů chceš konzistenci, nikoliv kreativitu.
Použití
Otestujme pipeline na minimálním obchodním případu – tři interní politiky a otázka, která nekopíruje žádné jejich přesné znění.
# 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čení dál položením otázky, na kterou žádný dokument neodpovídá, například otázku týkající se firemního zdravotního pojištění. Pipeline stále vrátí tři zdroje – vyhledávání vždy vrátí svých $k$ nejlepších kandidátů – a je to systémová zpráva, která musí modelu zabránit vymyslet si odpověď. Ověření tohoto chování před nasazením do produkce je lepší než jeho objevení prostřednictvím stížnosti.
Body optimalizace
Každý krok pipeline lze zlepšit nezávisle, což umožňuje postupovat pomocí malých, měřitelných úprav.
| Krok | Možné optimalizace |
|---|---|
| Chunking | Velikost chunku, překryv, sémantické chunkování |
| Embedding | Výběr modelu, dimenze, obohacení textu |
| Search | Hybridní vyhledávání, přerazování (reranking), filtry metadat |
| Prompt | Systémové instrukce, formát kontextu, few-shot |
| Generation | Model, teplota, citace |
Následující lekce podrobně rozebírají každou z těchto optimalizací. Řeš je v tomto pořadí: chunkování určuje, co lze získat, a žádné přerazování (reranking) neopraví špatně rozchunkovaný dokument.
Klíčové poznatky
- RAG = Vyhledávání + Kontext + Generování LLM
- Pipeline se dělí na ingestaci (offline) a dotaz (online)
- Každou komponentu (chunking, embedding, vyhledávání, prompt, generování) lze optimalizovat nezávisle
- RAG je pro přidávání znalostí flexibilnější a méně nákladné než fine-tuning