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 spoliehaľa 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í.

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
Halucinace/konfabulácie Odpovede založené na reálnych dokumentoch 70% 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:
    • Presnosť faktov: 45% (vanilla LLM) → 92% (RAG)
    • Náklady: $50,000 fine-tuning → $100/mesiac vector DB
    • Čas na update: 2-3 mesiace retraining → instant

3. Technická architektúra RAG

  • Komponenty systému:
Komponent Funkcia Populárne riešenia
Document Store Uloženie originálnych dokumentov S3, MongoDB, PostgreSQL
Chunking Strategy Rozdelenie dokumentov na segmenty Fixed-size, Semantic, Sliding window
Embedding Model Konverzia textu na vektory OpenAI Ada, Cohere, Sentence-BERT
Vector Database Indexovanie a vyhľadávanie vektorov Pinecone, Weaviate, ChromaDB, Qdrant
Reranker Zoradenie výsledkov podľa relevancie Cohere Rerank, Cross-encoder
LLM Generovanie finálnej odpovede GPT-4, Claude, Llama
  • 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": 4000    # Max tokeny v prompte
}

4. Implementácia RAG systému

  • Krok 1: Príprava dát
# Chunking stratégie
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

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

# Uloženie do vector DB
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):
    # Embed otázku
    query_embedding = embedder.encode(question)

    # Vyhľadaj relevantné chunky
    results = collection.query(
        query_embeddings=query_embedding,
        n_results=5
    )

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

    # Generuj odpoveď
    response = llm.generate(prompt)
    return response

5. Pokročilé RAG techniky

Technika Popis Improvement
Hybrid Search Kombinácia semantic + keyword search +15% recall
Multi-hop RAG Iteratívne vyhľadávanie (question → docs → follow-up → more docs) +25% na komplexných otázkach
Self-RAG Model sám rozhoduje kedy potrebuje retrieval -30% zbytočných retrievals
CRAG (Corrective RAG) Automatická korekcia irelevantných výsledkov +20% precision
Graph RAG Použitie knowledge graphs namiesto flat documents +35% na relačných otázkach
Multimodal RAG Retrieval obrázkov, tabuliek, diagramov +40% na technických dokumentoch
  • Príklad Hybrid Search:
# Kombinácia BM25 (keyword) + semantic search
def hybrid_search(query, alpha=0.5):
    keyword_results = bm25_search(query)
    semantic_results = vector_search(query)

    # Weighted combination
    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. Optimalizácia výkonu

  • Chunking stratégie:
Stratégia Vhodné pre Chunk size Pros Cons
Fixed-size Všeobecné texty 500-1000 tokens Jednoduché, predvídateľné 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
Document-based Krátke dokumenty Celý dokument Plný kontext Neškáluje pre veľké docs
  • Embedding model selection:
Model Provider Dimensions Speed Quality Cost
Ada-002 OpenAI 1536 Fast Excellent $0.0001/1k tokens
all-MiniLM-L6 Open source 384 Very fast Good Free
E5-large Microsoft 1024 Medium Very good Free
Cohere-v3 Cohere 1024 Fast Excellent $0.0002/1k tokens

7. Monitoring a metriky

  • Kľúčové metriky:
Metrika Definícia Target Ako merať
Retrieval Precision % relevantných dokumentov >80% Human evaluation
Answer Accuracy Správnosť odpovede >90% Ground truth comparison
Latency Čas odpovede end-to-end <2s Performance monitoring
Context Utilization % použitého kontextu v odpovedi >60% Token analysis
Source Attribution % tvrdení s citáciou 100% Automated checking
  • Debugging RAG:
# RAG debugging pipeline
def debug_rag(question):
    print(f"Question: {question}")

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

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

    # 3. Check generation
    response = generate(context, question)
    print(f"Used {count_citations(response)} citations")

    return response

8. Produkčné nasadenie

  • Stack pre production RAG:
Layer Component Options Considerations
Data Pipeline ETL/Ingestion Airflow, Dagster Schedule, monitoring
Vector DB Storage + Search Pinecone, Weaviate, Qdrant Scale, latency, cost
API Layer Serving FastAPI, Flask Rate limiting, auth
Caching Response cache Redis, Memcached TTL strategy
Monitoring Observability Datadog, Grafana Metrics, alerts
LLM Gateway Model management LiteLLM, Portkey Fallbacks, load balancing
  • Cost optimization:
    • Semantic caching: Ukladaj podobné otázky (30-50% úspora)
    • Incremental indexing: Indexuj len nové/zmenené dokumenty
    • Compression: Kompresia embeddings (50% storage saving)
    • Smart routing: Jednoduché otázky → menší model

9. Use cases a príklady

Doména Aplikácia Výsledky
Customer Support Chatbot nad knowledge base -70% ticketov, 4.5/5 satisfaction
Legal Contract analysis, case law search 10x rýchlejší research
Healthcare Medical literature QA 95% accuracy na clinical queries
Education Personalized tutoring +30% learning outcomes
Enterprise Internal knowledge management 2.5h/deň saved per employee
E-commerce Product recommendation + QA +25% conversion rate

Zhrnutie

  • RAG je najefektívnejší spôsob ako dať LLM prístup k aktuálnym a špecifickým informáciám bez nákladného pretrénovania
  • 70% redukcia halucinácií a možnosť citovať zdroje robí z RAG go-to riešenie pre enterprise aplikácie
  • Implementácia za $100-1000/mesiac je 50-100x lacnejšia ako fine-tuning či vlastný model
  • Kľúč k úspechu: Kvalitné chunking, relevantný retrieval a dobrý reranking — nie veľkosť LLM