Przejdź do głównej treści
Polski— Wybierz język
Menu

Kompletny potok RAG

Lekcja 14 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Łączymy wszystko w całość
  2. Kompletny potok
  3. Uruchamianie potoku
  4. Pięć kierunków dalszej poprawy
  5. Kluczowe wnioski

Łą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.1 dla 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