Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kompletní architektura RAG

Lekce 11 z 22 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Cíle
  2. Co je to RAG?
  3. Fáze pipeline
  4. Kompletní implementace
  5. Použití
  6. Body optimalizace
  7. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o odvozování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení odvozují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (API Responses) nebo reasoning_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.

KrokMožné optimalizace
ChunkingVelikost chunku, překryv, sémantické chunkování
EmbeddingVýběr modelu, dimenze, obohacení textu
SearchHybridní vyhledávání, přerazování (reranking), filtry metadat
PromptSystémové instrukce, formát kontextu, few-shot
GenerationModel, 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