Kompletný RAG pipeline
Na tejto strane
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