Cjeloviti RAG pipeline
Na ovoj stranici
Spajanje svih dijelova u cjelinu
Prethodne lekcije obrađivale su svaku kariku lanca zasebno: učitavanje, dijeljenje na dijelove (chunking), kodiranje, indeksiranje, dohvat i generiranje. Sada je vrijeme da ih spojiš u jedan cjelovit, end-to-end program koji možeš pokrenuti odmah, a zatim prilagoditi svojim dokumentima. Ova skripta staje u jednu datoteku i zahtijeva samo četiri ovisnosti.
pip install mistralai faiss-cpu numpy requests
Cjeloviti pipeline
Kodom upravljaju dva dizajnerska izbora. Prvo, sve konfiguracije grupiramo na vrhu datoteke: modeli, veličina dijela (chunk size), veličina serije (batch size) i TOP_K su imenovane konstante. To te spašava od traženja tvrdokodiranih vrijednosti zakopanih unutar funkcija kada trebaš podesiti ponašanje. Drugo, logiku dijelimo na šest neovisnih funkcija, od kojih svaka odgovara jednom koraku i ispisuje svoj napredak kao [n/6]. Taj trag nije dekorativan: kada pipeline zakaže ili vrati čudan odgovor, odmah ti govori leži li problem u učitavanju, dijeljenju na dijelove ili dohvatu. Svaku funkciju možeš i izolirano zamijeniti – možeš ubaciti PDF loader za load_data bez diranja ostatka koda.
Funkcija main povezuje korake u lanac, a zatim ispituje korpus s tri pitanja o eseju Paula Grahama koji koristimo kao demo skup podataka. Primijeti da se dohvat i generiranje izvršavaju unutar petlje, dok se indeksiranje događa samo jednom unaprijed: ponovno kodiranje cijelog korpusa za svako pitanje bilo bi apsurdno i s obzirom na trošak i s obzirom na kašnjenje.
import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral
# ============================================================
# Configuration
# ============================================================
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)
# ============================================================
# Step 1: Load Data
# ============================================================
def load_data(url):
"""Load a text document from a URL."""
print("[1/6] Loading data...")
response = requests.get(url)
response.raise_for_status()
text = response.text
print(f" -> {len(text)} characters loaded")
return text
# ============================================================
# Step 2: Create Chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
"""Split text into chunks."""
print("[2/6] Creating chunks...")
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" -> {len(chunks)} chunks created (avg size: {sum(len(c) for c in chunks) // len(chunks)} chars)")
return chunks
# ============================================================
# Step 3: Generate Embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
"""Encode chunks into embeddings via mistral-embed."""
print("[3/6] Generating embeddings...")
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" -> Batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encoded")
embeddings = np.array(all_embeddings, dtype=np.float32)
print(f" -> Matrix: {embeddings.shape}")
return embeddings
# ============================================================
# Step 4: Create FAISS Index
# ============================================================
def create_index(embeddings):
"""Create and populate a FAISS index."""
print("[4/6] Creating FAISS index...")
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)
print(f" -> Index: {index.ntotal} vectors, dimension {dimension}")
return index
# ============================================================
# Step 5: Retrieve Relevant Chunks
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
"""Retrieve the most relevant chunks."""
print(f"[5/6] Searching for: '{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" -> {len(results)} chunks retrieved")
return results
# ============================================================
# Step 6: Generate Answer
# ============================================================
def generate(question, context_chunks):
"""Generate the answer using retrieved context."""
print("[6/6] Generating answer...")
context = "\n\n---\n\n".join([c["text"] for c in context_chunks])
prompt = f"""Informative context:
{context}
---
Based ONLY on the context above, answer the following question precisely and completely.
Question: {question}"""
response = client.chat.complete(
model=CHAT_MODEL,
messages=[
{"role": "system", "content": "You are an assistant that answers based on the provided context."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
answer = response.choices[0].message.content
print(f" -> Answer generated ({len(answer)} characters)")
return answer
# ============================================================
# Main Pipeline
# ============================================================
def main():
"""Run the complete RAG pipeline."""
# 1. Load
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. Chunk
chunks = create_chunks(text)
# 3. Encode
embeddings = create_embeddings(chunks)
# 4. Index
index = create_index(embeddings)
# 5+6. Question -> Answer
questions = [
"What were the two main things the author worked on before college?",
"What did the author do during their time at Y Combinator?",
"What programming language did the author learn first?",
]
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()
Pokretanje pipelinea
Spremi ovaj kod kao rag_pipeline.py, izvezi svoj API ključ u okolinu – nikada ga nemoj tvrdokodirati u datoteku jer će završiti u repozitoriju – i zatim pokreni skriptu. Izlaz prolazi kroz šest koraka, a zatim obrađuje tri pitanja s njihovim odgovorima. Ako se neki odgovor čini izvan teme, usporedi ga s dijelovima (chunks) prikazanima u koraku 5 prije nego što okriviš model za generiranje.
export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py
Pet smjerova za daljnje poboljšanje
Ovaj pipeline je temelj, a ne gotov proizvod, a svako njegovo ograničenje pokazuje na sljedeći korak. Najhitnije je trajno pohranjivanje (persistencija): u sadašnjem obliku skripta ponovno kodira cijeli korpus pri svakom pokretanju, dok bi spremanje FAISS indeksa i dijelova (chunks) učinilo naknadna izvršavanja gotovo trenutnima. Ponovno rangiranje (re-ranking) je sljedeća razina: prolaženje rezultata iz FAISS-a kroz unakrsni enkoder (cross-encoder) koji procjenjuje relevantnost puno preciznije od same udaljenosti vektora. Filtriranje metapodataka rješava drugu potrebu: ograničavanje pretraživanja po datumu, kategoriji ili autoru, uz sličnost. Dva konačna poboljšanja fokusiraju se na korisničko iskustvo: strujanje (streaming), koje prikazuje odgovor dok se generira umjesto nakon nekoliko sekundi tišine, i povijest razgovora, koja korisnicima omogućuje da nastave s pitanjima poput „što je s verzijom 2?“ bez ponovnog navođenja cijelog pitanja.
# 1. Save the index to avoid recalculating
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))
# 2. Add re-ranking
# After FAISS retrieval, use a cross-encoder model
# to re-order results by fine-grained relevance
# 3. Metadata filtering
# Add filters (date, category, author) in addition
# to vector similarity
# 4. Response streaming
# Use client.chat.stream() to display the answer
# as it generates
# 5. Conversation history
# Add previous exchanges to the prompt
# for a contextual RAG chatbot
Ključne točke
- Cjeloviti RAG pipeline razlaže se na 6 koraka: učitaj, podijeli na dijelove, kodiraj, indeksiraj, dohvati, generiraj
- Svaki korak je neovisna funkcija, laka za testiranje i zamjenu
- Koristi
temperature=0.1za činjenične odgovore - Spremi FAISS indeks i embeddinge kako bi izbjegao ponovno izračunavanje pri svakom pokretanju
- Ovaj pipeline čvrsta je polazna točka koju možeš obogatiti prema svojim potrebama