Kompletní pipeline RAG
Na této stránce
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