RAG (Retrieval-Augmented Generation)

RAG je technika, ktorá kombinuje vyhľadávanie informácií z externých zdrojov s generovaním textu pomocou LLM. Namiesto spoliehania sa na „pamäť" modelu z tréningu RAG v reálnom čase vyhľadá relevantné dokumenty a použije ich ako kontext pre generovanie presnejších a aktuálnych odpovedí.

V roku 2026 je RAG de facto štandardnou architektúrou pre enterprise AI aplikácie — konkuruje mu hlavne nástup modelov s extrémne dlhým kontextom, no pre väčšinu produkčných scenárov zostáva rýchlejší, lacnejší a kontrolovateľnejší.

1. Ako RAG funguje

  • Základný workflow:

    1. Indexovanie: Dokumenty sa rozrežú na chunky a prevedú na vektorové embeddings
    2. Query processing: Používateľská otázka sa tiež prevedie na embedding
    3. Retrieval: Systém nájde top-K najpodobnejších chunkov
    4. Augmentation: Nájdené chunky sa pridajú do promptu ako kontext
    5. Generation: LLM vygeneruje odpoveď na základe kontextu

  • Jednoduchý príklad:

# Používateľ: "Aká je naša politika dovoleniek?"

# 1. Vyhľadanie relevantných dokumentov
relevant_docs = vector_db.search("politika dovoleniek", k=3)

# 2. Vytvorenie promptu s kontextom
prompt = f"""
Kontext: {relevant_docs}
Otázka: Aká je naša politika dovoleniek?
Odpoveď:"""

# 3. Generovanie odpovede
response = llm.generate(prompt)

2. Prečo je RAG dôležitý

Problém klasických LLM Ako RAG pomáha Praktický dopad
Zastarané znalosti Real-time prístup k aktuálnym dátam Vždy aktuálne odpovede
Halucinácie/konfabulácie Odpovede zakotvené v reálnych dokumentoch Výrazne menej faktických chýb
Čierna skrinka Citácie zdrojov pre každé tvrdenie Overiteľnosť a dôveryhodnosť
Nemožnosť updatu Stačí aktualizovať dokumenty v DB Žiadne pretrénovanie
Domain expertise Špecializované znalosti z firemných dát Expertné odpovede bez fine-tuningu
  • Čísla z praxe (orientačné, závisí od use case):
    • Presnosť faktov: ~50 % (vanilla LLM) → ~85–90 % (dobre naladený RAG)
    • Náklady: $50 000 fine-tuning → $100–500/mesiac vector DB + inference
    • Čas na update znalostnej bázy: dni/týždne retrainingu → minúty pri inkrementálnom indexovaní

3. Technická architektúra RAG

  • Komponenty systému:
Komponent Funkcia Populárne riešenia (2026)
Document Store Uloženie originálnych dokumentov S3, MongoDB, PostgreSQL
Chunking Strategy Rozdelenie dokumentov na segmenty Fixed-size, Semantic, Late chunking
Embedding Model Konverzia textu na vektory OpenAI text-embedding-3, Cohere embed-v4, GTE
Vector Database Indexovanie a vyhľadávanie vektorov Pinecone, Weaviate, Qdrant, pgvector
Reranker Zoradenie výsledkov podľa relevancie Cohere Rerank 3.5, ColBERT, Jina
LLM Generovanie finálnej odpovede GPT-4o, Claude Sonnet, Gemini Flash, Llama 3
  • Parametre ovplyvňujúce výkon:
# Kľúčové konfiguračné parametre
config = {
    "chunk_size": 512,           # Veľkosť chunkov (tokeny)
    "chunk_overlap": 128,        # Prekryv medzi chunkmi
    "embedding_dim": 1536,       # Dimenzionalita vektorov
    "top_k": 5,                  # Počet retrieved chunkov
    "similarity_threshold": 0.7, # Minimálna podobnosť
    "rerank_top_n": 3,           # Finálny počet po rerankingu
    "max_context_length": 8000   # Max tokeny v prompte
}

4. Implementácia RAG systému

  • Krok 1: Príprava dát
def chunk_document(text, chunk_size=500, overlap=50):
    chunks = []
    for i in range(0, len(text), chunk_size - overlap):
        chunk = text[i:i + chunk_size]
        chunks.append({
            "text": chunk,
            "metadata": {"start": i, "end": i + chunk_size}
        })
    return chunks
  • Krok 2: Embedding a indexovanie
from sentence_transformers import SentenceTransformer
import chromadb

embedder = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = embedder.encode(chunks)

client = chromadb.Client()
collection = client.create_collection("knowledge_base")
collection.add(
    embeddings=embeddings,
    documents=chunks,
    ids=[f"chunk_{i}" for i in range(len(chunks))]
)
  • Krok 3: Query a generovanie
def answer_question(question):
    query_embedding = embedder.encode(question)

    results = collection.query(
        query_embeddings=query_embedding,
        n_results=5
    )

    context = "\n".join(results['documents'])
    prompt = f"Context: {context}\n\nQuestion: {question}\nAnswer:"

    response = llm.generate(prompt)
    return response
  • Frameworky pre rýchly štart: LlamaIndex a LangChain pokrývajú väčšinu RAG primitívov out-of-the-box — indexovanie, chunking, hybrid search, rerankery aj integrované memory. Pre produkciu s vyššou kontrolou sa oplatí postaviť pipeline na meru.

5. Pokročilé RAG techniky

Technika Popis Zlepšenie
Hybrid Search Kombinácia semantic + keyword (BM25) search +10–20 % recall
Multi-hop RAG Iteratívne vyhľadávanie (otázka → docs → follow-up) +25 % na komplexných otázkach
Self-RAG Model sám rozhoduje, kedy potrebuje retrieval −30 % zbytočných retrievalov
CRAG (Corrective RAG) Automatická korekcia irelevantných výsledkov +20 % precision
Graph RAG Knowledge grafy namiesto flat dokumentov +35 % na relačných otázkach
Multimodal RAG Retrieval obrázkov, tabuliek, diagramov (ColPali) Pokrytie vizuálnych zdrojov
Contextual Retrieval Každý chunk dostane LLM-generovaný kontext pred indexovaním +49 % menej failed retrievals
RAG Fusion Viacero query variácií → reciprocal rank fusion +15 % na ambiguous queries
  • Contextual Retrieval (Anthropic, 2025): Pred indexovaním každý chunk obohatíme o kontext celého dokumentu pomocou LLM. Chunk „Tržby vzrástli o 15 %" sa zmení na „Čl. 3 výročnej správy Acme Corp 2024: Tržby vzrástli o 15 % medziročne." Retriever tak vie, čo chunk znamená, nielen čo obsahuje.
def add_context_to_chunk(document, chunk, llm):
    prompt = f"""
<document>
{document}
</document>
<chunk>
{chunk}
</chunk>
Krátko opíš kontext tohto chunku v rámci celého dokumentu (1-2 vety):
"""
    context = llm.generate(prompt)
    return f"{context}\n\n{chunk}"
  • Príklad Hybrid Search:
def hybrid_search(query, alpha=0.5):
    keyword_results = bm25_search(query)
    semantic_results = vector_search(query)

    combined_scores = {}
    for doc_id, score in keyword_results:
        combined_scores[doc_id] = alpha * score
    for doc_id, score in semantic_results:
        combined_scores[doc_id] += (1 - alpha) * score

    return sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)

6. Agentic RAG

V roku 2025–2026 sa klasický RAG posunul k agentickému RAG — namiesto jedného statického retrieval kroku agent dynamicky rozhoduje o stratégii vyhľadávania.

  • Kľúčové rozdiely:
Klasický RAG Agentic RAG
Jeden retrieval krok Iteratívne, multi-step retrieval
Pevný počet chunkov Agent rozhoduje, koľko a čo hľadať
Pasívny — len odpovedá Aktívny — môže volať tools, API, DB
Deterministický pipeline Flexibilný reasoning loop
  • Príklad: ReAct loop pre RAG
# Agent uvažuje → koná → pozoruje → opakuje
def agentic_rag(question):
    context = []
    for step in range(max_steps):
        # Thought: čo potrebujem zistiť?
        thought = llm.think(question, context)

        if thought.action == "search":
            docs = vector_db.search(thought.query)
            context.extend(docs)
        elif thought.action == "answer":
            return llm.generate_answer(question, context)
        elif thought.action == "call_api":
            data = external_api.get(thought.endpoint)
            context.append(data)
  • Kedy použiť: Multi-hop otázky, kde odpoveď vyžaduje kombinovanie informácií z viacerých zdrojov, alebo scenáre kde agent musí volať externé API (ceny, databázy, kalkulátory).

7. RAG vs. alternatívy

V roku 2026 má RAG troch hlavných konkurentov: fine-tuning, long-context modely a MCP.

Prístup Kedy použiť Výhody Nevýhody
RAG Dynamické, aktualizovateľné znalosti Lacné, citácie, aktuálnosť Retrieval latency, chunking overhead
Fine-tuning Pevný štýl/formát, domain terminológia Rýchla inferencia, bez retrieval Drahé, znalosti zastarávajú
Long context Celý dokument naraz (< 1M tokenov) Jednoduché, bez indexovania Drahé na inference, "lost in the middle"
MCP / Tool use Štruktúrované dáta, live API Reálne dáta, akcie Vyžaduje integráciu, latency
  • Praktické pravidlo:
    • Menej ako ~20 dokumentov → long context (hoď ich priamo do promptu)
    • Viac ako 20, aktualizujú sa → RAG
    • Chceš zmeniť správanie/štýl modelu → fine-tuning
    • Potrebuješ live dáta (burza, ERP) → MCP / tool calling

8. Optimalizácia výkonu

  • Chunking stratégie:
Stratégia Vhodné pre Chunk size Pros Cons
Fixed-size Všeobecné texty 500–1000 tokenov Jednoduché Môže rozbiť kontext
Semantic Štruktúrované dokumenty Variable Zachováva význam Komplexnejšie
Sliding window Dlhé dokumenty 500 + 100 overlap Lepší context coverage Viac chunkov
Late chunking Dlhé dokumenty s globálnym kontextom Variable Lepšie embeddings Vyžaduje dlhý encoder
  • Embedding model selection (2026):
Model Provider Dimensions Quality Cost
text-embedding-3-large OpenAI 3072 Výborná $0.00013/1k tokenov
embed-v4 Cohere 1024 Výborná $0.0002/1k tokenov
all-MiniLM-L6 Open source 384 Dobrá Zadarmo
GTE-large Alibaba/HF 1024 Veľmi dobrá Zadarmo

9. Monitoring a metriky

  • Kľúčové metriky:
Metrika Definícia Target Ako merať
Retrieval Precision % relevantných dokumentov medzi retrieved >80 % Human evaluation / LLM judge
Answer Faithfulness Odpoveď netvrdí nič navyše oproti kontextu >95 % RAGAS framework
Answer Relevance Odpoveď rieši pôvodnú otázku >90 % Ground truth comparison
Latency Čas odpovede end-to-end <2 s Performance monitoring
Context Recall % kľúčových faktov zachytených retrieval-om >70 % RAGAS

  • RAGAS je štandardný open-source framework na hodnotenie RAG pipeline bez potreby manuálneho labelovania — odporúčaný pre produkciu.

  • Debugging RAG:

def debug_rag(question):
    print(f"Question: {question}")

    retrieved = retrieve(question)
    print(f"Retrieved {len(retrieved)} chunks")
    print(f"Relevance scores: {[r.score for r in retrieved]}")

    context = build_context(retrieved)
    print(f"Context length: {len(context)} tokens")

    response = generate(context, question)
    print(f"Used {count_citations(response)} citations")

    return response

10. Produkčné nasadenie

  • Stack pre production RAG:
Layer Component Options Considerations
Data Pipeline ETL/Ingestion Airflow, Dagster Scheduling, monitoring
Vector DB Storage + Search Pinecone, Qdrant, pgvector Scale, latency, cost
API Layer Serving FastAPI, LiteLLM Rate limiting, auth
Caching Semantic cache Redis + embedding similarity TTL stratégia
Monitoring Observability RAGAS, Langfuse, Datadog Metriky, alerty
LLM Gateway Model management LiteLLM, Portkey Fallbacks, load balancing
  • Cost optimization:
    • Semantic caching: Ukladaj podobné otázky podľa embedding similarity (20–50 % úspora)
    • Incremental indexing: Indexuj len nové/zmenené dokumenty
    • Smart routing: Jednoduché otázky → lacnejší/menší model
    • Embedding cache: Rovnaký text → rovnaký embedding, neembedduj dvakrát

11. Use cases a príklady

Doména Aplikácia Výsledky
Customer Support Chatbot nad knowledge base −60–70 % ticketov, vyššia spokojnosť
Legal Analýza zmlúv, vyhľadávanie judikatúry 5–10× rýchlejší research
Healthcare Medical literature QA Vysoká presnosť na klinické otázky
Education Personalizované doučovanie Merateľné zlepšenie výsledkov
Enterprise Interný knowledge management Hodiny ušetrené denne na tíme
E-commerce Product QA + odporúčania Vyšší konverzný pomer
Software Dev Codebase QA (napr. cez MCP) Rýchlejší onboarding, menej duplicít

Zhrnutie

  • RAG je v roku 2026 zlatý štandard pre enterprise AI aplikácie vyžadujúce aktuálne, verifikovateľné a doménovo špecifické odpovede
  • Citácie zdrojov a nízka miera halucinácií robia z RAG riešenie vhodné tam, kde záleží na dôveryhodnosti — právnictvo, medicína, financie
  • Implementácia za $100–500/mesiac je rádovo lacnejšia ako fine-tuning, pričom znalostná báza sa aktualizuje v reálnom čase
  • V roku 2026 sa posúvame od statického RAG k agentickému — modely dynamicky rozhodujú, čo, kedy a koľkokrát vyhľadať
  • Kľúč k úspechu: Kvalitné chunking a contextual retrieval, hybrid search, reranker — a meranie cez RAGAS ešte pred spustením do produkcie