Kompletny potok RAG
Na tej stronie
Łączymy wszystko w całość
Poprzednie lekcje omawiały każde ogniwo łańcucha osobno: ładowanie, dzielenie na fragmenty, kodowanie, indeksowanie, wyszukiwanie i generowanie. Teraz czas zespawać je w jeden, kompletny program typu end-to-end, który możesz uruchomić tak jak jest, a następnie dostosować do własnych dokumentów. Ten skrypt mieści się w jednym pliku i wymaga tylko czterech zależności.
pip install mistralai faiss-cpu numpy requests
Kompletny potok
Kod ten opiera się na dwóch wyborach projektowych. Po pierwsze, grupujemy całą konfigurację na początku pliku: modele, rozmiar fragmentu, rozmiar partii i TOP_K to nazwane stałe. Dzięki temu nie musisz szukać sztywno zakodowanych wartości ukrytych wewnątrz funkcji, gdy chcesz dostroić działanie. Po drugie, dzielimy logikę na sześć niezależnych funkcji, z których każda odpowiada za jeden krok i wypisuje postęp jako [n/6]. Ten ślad nie jest ozdobnikiem: gdy potok zawiedzie lub zwróci dziwną odpowiedź, natychmiast dowiesz się, czy problem leży po stronie ładowania, dzielenia na fragmenty, czy wyszukiwania. Każdą funkcję można też wymienić w izolacji – możesz podstawić loader PDF do load_data, nie ruszając reszty.
Funkcja main łączy kroki w sekwencję, a następnie zadaje korpusowi trzy pytania dotyczące eseju Paula Grahama użytego jako nasz zestaw demonstracyjny. Zauważ, że wyszukiwanie i generowanie działają w pętli, podczas gdy indeksowanie odbywa się tylko raz wcześniej: ponowne kodowanie całego korpusu dla każdego pytania byłoby absurdem zarówno pod względem kosztów, jak i opóźnień.
import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral
# ============================================================
# Konfiguracja
# ============================================================
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: Ładowanie danych
# ============================================================
def load_data(url):
"""Ładuje dokument tekstowy z adresu URL."""
print("[1/6] Ładowanie danych...")
response = requests.get(url)
response.raise_for_status()
text = response.text
print(f" -> Załadowano {len(text)} znaków")
return text
# ============================================================
# Krok 2: Tworzenie fragmentów
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
"""Dzieli tekst na fragmenty."""
print("[2/6] Tworzenie fragmentów...")
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" -> Utworzono {len(chunks)} fragmentów (śr. rozmiar: {sum(len(c) for c in chunks) // len(chunks)} znaków)")
return chunks
# ============================================================
# Krok 3: Generowanie osadzeń
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
"""Koduje fragmenty na osadzenia za pomocą mistral-embed."""
print("[3/6] Generowanie osadzeń...")
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" -> Przetworzono partię {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1}")
embeddings = np.array(all_embeddings, dtype=np.float32)
print(f" -> Macierz: {embeddings.shape}")
return embeddings
# ============================================================
# Krok 4: Tworzenie indeksu FAISS
# ============================================================
def create_index(embeddings):
"""Tworzy i wypełnia indeks FAISS."""
print("[4/6] Tworzenie indeksu FAISS...")
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)
print(f" -> Indeks: {index.ntotal} wektorów, wymiar {dimension}")
return index
# ============================================================
# Krok 5: Wyszukiwanie odpowiednich fragmentów
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
"""Wyszukuje najbardziej odpowiednie fragmenty."""
print(f"[5/6] Wyszukiwanie dla: '{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" -> Pobrano {len(results)} fragmentów")
return results
# ============================================================
# Krok 6: Generowanie odpowiedzi
# ============================================================
def generate(question, context_chunks):
"""Generuje odpowiedź na podstawie pobranego kontekstu."""
print("[6/6] Generowanie odpowiedzi...")
context = "\n\n---\n\n".join([c["text"] for c in context_chunks])
prompt = f"""Kontekst informacyjny:
{context}
---
Na podstawie WYŁĄCZNIE powyższego kontekstu, odpowiedz precyzyjnie i wyczerpująco na następujące pytanie.
Pytanie: {question}"""
response = client.chat.complete(
model=CHAT_MODEL,
messages=[
{"role": "system", "content": "Jesteś asystentem, który odpowiada na podstawie dostarczonego kontekstu."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
answer = response.choices[0].message.content
print(f" -> Wygenerowano odpowiedź ({len(answer)} znaków)")
return answer
# ============================================================
# Główny potok
# ============================================================
def main():
"""Uruchamia kompletny potok RAG."""
# 1. Ładowanie
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. Dzielenie na fragmenty
chunks = create_chunks(text)
# 3. Kodowanie
embeddings = create_embeddings(chunks)
# 4. Indeksowanie
index = create_index(embeddings)
# 5+6. Pytanie -> Odpowiedź
questions = [
"Jakie były dwie główne rzeczy, którymi autor zajmował się przed studiami?",
"Co autor robił podczas swojego pobytu w Y Combinator?",
"Jakiego języka programowania autor nauczył się jako pierwszego?",
]
for question in questions:
print(f"\n{'='*60}")
context = retrieve(question, index, chunks)
answer = generate(question, context)
print(f"\nP: {question}")
print(f"O: {answer}")
if __name__ == "__main__":
main()
Uruchamianie potoku
Zapisz ten kod jako rag_pipeline.py, wyeksportuj swój klucz API w środowisku – nigdy nie hardkoduj go w pliku, który prędzej czy później trafi do repozytorium – a następnie uruchom skrypt. Wyjście przeprowadzi cię przez sześć kroków, a następnie przetworzy trzy pytania wraz z odpowiedziami. Jeśli któraś odpowiedź wydaje się nie na temat, porównaj ją z fragmentami wyświetlonymi w kroku 5, zanim obwinisz model generujący.
export MISTRAL_API_KEY="twój-klucz-api"
python rag_pipeline.py
Pięć kierunków dalszej poprawy
Ten potok to fundament, a nie gotowy produkt, a każde z jego ograniczeń wskazuje kolejny krok. Najbardziej oczywisty to trwałość: w obecnej formie skrypt ponownie koduje cały korpus przy każdym uruchomieniu, podczas gdy zapisanie indeksu FAISS i fragmentów sprawiłoby, że kolejne wykonania byłyby niemal natychmiastowe. Kolejny poziom to reranking: przepuszczenie wyników z FAISS przez model cross-encoder, który ocenia trafność znacznie dokładniej niż sama odległość wektorowa. Filtrowanie metadanych rozwiązuje inną potrzebę: ograniczanie wyszukiwania według daty, kategorii lub autora, oprócz podobieństwa. Dwie ostatnie poprawki skupiają się na doświadczeniu użytkownika: strumieniowanie, które wyświetla odpowiedź w trakcie jej generowania, zamiast po kilku sekundach ciszy, oraz historia rozmowy, która pozwala użytkownikom zadawać pytania typu „a co z wersją 2?“, bez konieczności powtarzania całego pytania.
# 1. Zapisz indeks, aby uniknąć ponownych obliczeń
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))
# 2. Dodaj reranking
# Po wyszukiwaniu FAISS użyj modelu cross-encoder
# do ponownego uporządkowania wyników według szczegółowej trafności
# 3. Filtrowanie metadanych
# Dodaj filtry (data, kategoria, autor) oprócz
# podobieństwa wektorowego
# 4. Strumieniowanie odpowiedzi
# Użyj client.chat.stream(), aby wyświetlać odpowiedź
# w trakcie jej generowania
# 5. Historia rozmowy
# Dodaj poprzednie wymiany do promptu
# dla kontekstowego chatbota RAG
Kluczowe wnioski
- Kompletny potok RAG dzieli się na 6 kroków: ładuj, dziel na fragmenty, koduj, indeksuj, wyszukuj, generuj
- Każdy krok to niezależna funkcja, łatwa do testowania i wymiany
- Używaj
temperature=0.1dla odpowiedzi faktograficznych - Zapisz indeks FAISS i osadzenia, aby uniknąć ponownych obliczeń przy każdym uruchomieniu
- Ten potok to solidny punkt wyjścia do wzbogacania go zgodnie z twoimi potrzebami