Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Kompletný RAG pipeline

Lekcia 14 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Spájame všetko dokopy
  2. Kompletný pipeline
  3. Spustenie pipeline
  4. Päť smerov pre ďalšie vylepšenie
  5. Kľúčové poznatky

Spájame všetko dokopy

Predchádzajúce lekcie pokryli každý článok reťaze samostatne: načítanie, chunking, kódovanie, indexovanie, vyhľadávanie a generovanie. Teraz je čas zvárať ich do jedného kompletného end-to-end programu, ktorý môžeš spustiť tak, ako je, a následne prispôsobiť svojim vlastným dokumentom. Tento skript sa zmestí do jedného súboru a vyžaduje iba štyri závislosti.

pip install mistralai faiss-cpu numpy requests

Kompletný pipeline

Tento kód štruktúrujú dve dizajnové rozhodnutia. Po prvé, všetku konfiguráciu zoskupujeme na začiatku súboru: modely, veľkosť chunku, veľkosť batchu a TOP_K sú pomenované konštanty. To ťa ušetrí od hľadania natvrdo zakódovaných hodnôt ukrytých vo funkciách, keď potrebuješ doladiť správanie. Po druhé, logiku rozdeľujeme do šiestich nezávislých funkcií, z ktorých každá zodpovedá jednému kroku a vypisuje svoj postup ako [n/6]. Toto sledovanie nie je dekoratívne: keď pipeline zlyhá alebo vráti divnú odpoveď, okamžite ti povie, či problém spočíva v načítaní, chunkingu alebo vyhľadávaní. Každú funkciu môžeš tiež samostatne vymeniť – do load_data môžeš nasadiť loader pre PDF, bez toho, aby si sa dotkol zvyšku kódu.

Funkcia main spája kroky za sebou a následne kladie korpusu tri otázky týkajúce sa eseje Paula Grahama, ktorú používame ako demo dataset. Všimni si, že vyhľadávanie a generovanie bežia vo vnútri cyklu, zatiaľ čo indexovanie sa deje len raz vopred: prekodovanie celého korpusu pre každú otázku by bolo absurdné z hľadiska nákladov aj latencie.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Konfigurácia
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Krok 1: Načítanie dát
# ============================================================
def load_data(url):
    """Načíta textový dokument z URL."""
    print("[1/6] Načítavam dáta...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Načítaných {len(text)} znakov")
    return text


# ============================================================
# Krok 2: Vytvorenie chunkov
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Rozdelí text na chunky."""
    print("[2/6] Vytváram chunky...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> Vytvorených {len(chunks)} chunkov (priemerná veľkosť: {sum(len(c) for c in chunks) // len(chunks)} znakov)")
    return chunks


# ============================================================
# Krok 3: Generovanie embeddingov
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Kóduje chunky do embeddingov pomocou mistral-embed."""
    print("[3/6] Generujem embeddingy...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Zakódovaný batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1}")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Matica: {embeddings.shape}")
    return embeddings


# ============================================================
# Krok 4: Vytvorenie FAISS indexu
# ============================================================
def create_index(embeddings):
    """Vytvorí a naplní FAISS index."""
    print("[4/6] Vytváram FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vektorov, dimenzia {dimension}")
    return index


# ============================================================
# Krok 5: Vyhľadanie relevantných chunkov
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Vyhľadá najrelevantnejšie chunky."""
    print(f"[5/6] Hľadám pre: '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> Nájdených {len(results)} chunkov")
    return results


# ============================================================
# Krok 6: Generovanie odpovede
# ============================================================
def generate(question, context_chunks):
    """Generuje odpoveď pomocou získaného kontextu."""
    print("[6/6] Generujem odpoveď...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Informatívny kontext:

{context}

---

Na základe IBA vyššie uvedeného kontextu presne a úplne odpovedz na nasledujúcu otázku.

Otázka: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Si asistent, ktorý odpovedá na základe poskytnutého kontextu."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Vygenerovaná odpoveď ({len(answer)} znakov)")
    return answer


# ============================================================
# Hlavný pipeline
# ============================================================
def main():
    """Spustí kompletný RAG pipeline."""
    # 1. Načítanie
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Chunking
    chunks = create_chunks(text)

    # 3. Kódovanie
    embeddings = create_embeddings(chunks)

    # 4. Indexovanie
    index = create_index(embeddings)

    # 5+6. Otázka -> Odpoveď
    questions = [
        "Na čom autor pracoval pred vysokou školou?",
        "Čo autor robil počas svojho pôsobenia v Y Combinator?",
        "Aký programovací jazyk sa autor naučil ako prvý?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nQ: {question}")
        print(f"A: {answer}")


if __name__ == "__main__":
    main()

Spustenie pipeline

Ulož tento kód ako rag_pipeline.py, exportuj svoj API kľúč do prostredia – nikdy ho neukladaj natvrdo do súboru, ktorý sa časom dostane do repozitára – a potom spusti skript. Výstup prejde všetkými šiestimi krokmi a následne spracuje tri otázky s ich odpoveďami. Ak sa ktorákoľvek odpoveď zdá byť mimo témy, porovnajte ju s chunkami zobrazenými v kroku 5, skôr než obviníš generatívny model.

export MISTRAL_API_KEY="tvoj-api-kluc"
python rag_pipeline.py

Päť smerov pre ďalšie vylepšenie

Tento pipeline je základom, nie hotovým produktom, a každé jeho obmedzenie ukazuje na ďalší krok. Najnaliehavejšia je perzistencia: v súčasnej podobe skript pri každom spustení znovu zakóduje celý korpus, zatiaľ čo uloženie FAISS indexu a chunkov by urobilo následné spustenia takmer okamžité. Ďalšou úrovňou je prehodnotenie (re-ranking), ktoré prechádza výsledky z FAISS cez cross-encoder, ktorý posudzuje relevantnosť oveľa jemnejšie než samotná vzdialenosť vektorov. Filtrovanie metadát rieši ďalšiu potrebu: obmedzenie vyhľadávania podľa dátumu, kategórie alebo autora navyše k podobnosti. Dve posledné vylepšenia sa zameriavajú na používateľskú skúsenosť: streamovanie, ktoré zobrazuje odpoveď počas jej generovania namiesto niekoľkých sekúnd ticha, a história konverzácie, ktorá umožňuje používateľom nadviazať otázkou „čo verzia 2?“ bez toho, aby museli opakovať celú svoju otázku.

# 1. Uloženie indexu, aby sa predišlo prepočítavaniu
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Pridanie prehodnotenia (re-ranking)
# Po vyhľadaní vo FAISS použi model cross-encoder
# na preusporiadanie výsledkov podľa jemnejšej relevantnosti

# 3. Filtrovanie metadát
# Pridaj filtre (dátum, kategória, autor) navyše
# k vektorovej podobnosti

# 4. Streamovanie odpovede
# Použi client.chat.stream() na zobrazenie odpovede
# počas jej generovania

# 5. História konverzácie
# Pridaj predchádzajúce výmeny do promptu
# pre kontextuálneho RAG chatbota

Kľúčové poznatky

  • Kompletný RAG pipeline sa rozkladá na 6 krokov: načítanie, chunking, kódovanie, indexovanie, vyhľadávanie, generovanie
  • Každý krok je nezávislá funkcia, ktorú sa ľahko testuje a nahrádza
  • Pre faktické odpovede používaj temperature=0.1
  • Ulož FAISS index a embeddingy, aby sa predišlo ich prepočítavaniu pri každom spustení
  • Tento pipeline je pevným východiskovým bodom, ktorý môžeš obohatiť podľa svojich potrieb