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

Kompletní pipeline RAG

Lekce 14 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Všechno dohromady
  2. Kompletní pipeline
  3. Spuštění pipeline
  4. Pět směrů pro další vylepšení
  5. Klíčové poznatky

Všechno dohromady

Předchozí lekce pokryly každý článek řetězce samostatně: načítání, dělení na části (chunking), kódování, indexování, vyhledávání a generování. Teď je čas je svařit do jednoho kompletního end-to-end programu, který můžeš spustit tak, jak je, a následně přizpůsobit svým vlastním dokumentům. Tento skript se vejde do jednoho souboru a vyžaduje pouze čtyři závislosti.

pip install mistralai faiss-cpu numpy requests

Kompletní pipeline

Kód strukturuje dvojice designových rozhodnutí. Zaprvé, veškerou konfiguraci sdružujeme na začátku souboru: modely, velikost části (chunk size), velikost dávky (batch size) a TOP_K jsou pojmenované konstanty. To ti ušetří hledání natvrdo zakódovaných hodnot ukrytých uvnitř funkcí, když budeš ladit chování. Zadruhé, logiku dělíme do šesti nezávislých funkcí, z nichž každá odpovídá jednomu kroku a tiskne svůj postup jako [n/6]. Toto trasování není jen pro okrasu: když pipeline selže nebo vrátí podivnou odpověď, okamžitě ti řekne, zda problém leží v načítání, dělení na části nebo ve vyhledávání. Každou funkci lze také samostatně nahradit – do load_data můžeš dosadit načítač PDF, aniž bys musel sahat na zbytek kódu.

Funkce main spojuje kroky za sebou a poté dotazuje korpus třemi otázkami týkajícími se eseje Paula Grahama, kterou používáme jako ukázkovou sadu dat. Všimni si, že vyhledávání a generování běží uvnitř smyčky, zatímco indexování proběhne pouze jednou předem: opětovné kódování celého korpusu pro každou otázku by bylo z hlediska nákladů i latence absurdní.

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

# ============================================================
# Konfigurace
# ============================================================
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čtení dat
# ============================================================
def load_data(url):
    """Načte textový dokument z URL."""
    print("[1/6] Načítám data...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> Načteno {len(text)} znaků")
    return text


# ============================================================
# Krok 2: Vytvoření částí (Chunks)
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Rozdělí text na části."""
    print("[2/6] Vytvářím části...")
    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"  -> Vytvořeno {len(chunks)} částí (průměrná velikost: {sum(len(c) for c in chunks) // len(chunks)} znaků)")
    return chunks


# ============================================================
# Krok 3: Generování vnoření (Embeddings)
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Kóduje části do vnoření pomocí mistral-embed."""
    print("[3/6] Generuji vnoření...")
    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"  -> Dávka {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} zakódována")

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


# ============================================================
# Krok 4: Vytvoření FAISS indexu
# ============================================================
def create_index(embeddings):
    """Vytvoří a naplní FAISS index."""
    print("[4/6] Vytvářím FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vektorů, dimenze {dimension}")
    return index


# ============================================================
# Krok 5: Získání relevantních částí
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Získá nejrelevantnější části."""
    print(f"[5/6] Hledám: '{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"  -> Získáno {len(results)} částí")
    return results


# ============================================================
# Krok 6: Generování odpovědi
# ============================================================
def generate(question, context_chunks):
    """Generuje odpověď pomocí získaného kontextu."""
    print("[6/6] Generuji odpověď...")

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

    prompt = f"""Informativní kontext:

{context}

---

Na základě POUZE výše uvedeného kontextu přesně a úplně odpověz na následující otázku.

Otázka: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "Jsi asistent, který odpovídá na základě poskytnutého kontextu."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Odpověď vygenerována ({len(answer)} znaků)")
    return answer


# ============================================================
# Hlavní pipeline
# ============================================================
def main():
    """Spustí kompletní RAG pipeline."""
    # 1. Načtení
    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. Rozdělení na části
    chunks = create_chunks(text)

    # 3. Kódování
    embeddings = create_embeddings(chunks)

    # 4. Indexování
    index = create_index(embeddings)

    # 5+6. Otázka -> Odpověď
    questions = [
        "Jaké byly dvě hlavní věci, kterým se autor věnoval před vysokou školou?",
        "Co autor dělal během svého působení v Y Combinator?",
        "Který programovací jazyk se autor naučil jako první?",
    ]

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


if __name__ == "__main__":
    main()

Spuštění pipeline

Ulož tento kód jako rag_pipeline.py, exportuj svůj API klíč do prostředí – nikdy ho natvrdo nekóduj do souboru, který se dříve či později dostane do repozitáře – a poté skript spusť. Výstup provede všech šest kroků a následně zpracuje tři otázky s jejich odpověďmi. Pokud se nějaká odpověď zdá být mimo téma, porovnej ji s částmi zobrazenými v kroku 5, než začneš obviňovat generační model.

export MISTRAL_API_KEY="tvuj-api-klíč"
python rag_pipeline.py

Pět směrů pro další vylepšení

Tato pipeline je základem, nikoliv hotovým produktem, a každé její omezení ukazuje na další krok. Tím nejbezprostřednějším je perzistence: v současné podobě skript při každém spuštění znovu zakóduje celý korpus, zatímco uložení FAISS indexu a částí by učinilo následná spuštění téměř okamžitá. Dalším levelem je přehodnocení (re-ranking), které propouští výsledky z FAISS přes cross-encoder, jenž posuzuje relevanci mnohem jemněji než samotná vzdálenost vektorů. Filtrace metadat řeší další potřebu: omezení vyhledávání podle data, kategorie nebo autora navíc k podobnosti. Dvě poslední vylepšení se zaměřují na uživatelskou zkušenost: streamování, které zobrazuje odpověď během jejího generování místo několika sekund ticha, a historie konverzace, která uživatelům umožňuje navazovat dotazy typu „co verze 2?“ bez nutnosti opakovat celou otázku.

# 1. Uložení indexu pro vyhnutí se přepočítávání
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Přidání přehodnocení (re-ranking)
# Po získání z FAISS použij model cross-encoderu
# k přeřazení výsledků podle jemné relevance

# 3. Filtrace metadat
# Přidej filtry (datum, kategorie, autor) navíc
# k vektorové podobnosti

# 4. Streamování odpovědí
# Použij client.chat.stream() pro zobrazení odpovědi
# během jejího generování

# 5. Historie konverzace
# Přidej předchozí výměny do promptu
# pro kontextuálního RAG chatbota

Klíčové poznatky

  • Kompletní RAG pipeline se dělí na 6 kroků: načtení, rozdělení na části, kódování, indexování, vyhledávání, generování
  • Každý krok je nezávislá funkce, snadno testovatelná a nahraditelná
  • Pro faktické odpovědi používej temperature=0.1
  • Ulož FAISS index a vnoření, abys předešel jejich přepočítávání při každém spuštění
  • Tato pipeline je solidním výchozím bodem k obohacení podle tvých potřeb