Kurs Python · Moduł 11: RAG i systemy wieloagentowe

RAG - Rozszerzona Pamięć AI

8 min czytania ·
W tej lekcji6

Wyobraź sobie przewodnika, który zna sawannę tylko z książek wydanych trzy lata temu. Pytasz go o nowy szlak do wodopoju, a on z pełnym przekonaniem opisuje drogę, której już nie ma. Tak zachowuje się model językowy bez dostępu do aktualnej wiedzy. Witaj w przedostatnim etapie Python Safari! W tej lokacji nauczymy model zaglądać do notatnika terenowego, zanim cokolwiek powie.

Tak jak wielkie ssaki ewoluowały, rozwijając większe mózgi i lepszą pamięć, tak modele językowe ewoluują dzięki technologii RAG (Retrieval-Augmented Generation). To technika, która daje AI dostęp do zewnętrznej wiedzy bez ponownego trenowania modelu.

Czego się nauczysz

  • rozpoznawać ograniczenia LLM, które rozwiązuje RAG,
  • opisać trzy kroki pipeline'u: retrieve, augment, generate,
  • zbudować najprostszy RAG w czystym Pythonie z OpenAI i NumPy,
  • dzielić długie dokumenty na fragmenty (chunking),
  • mierzyć jakość wyszukiwania metrykami precision i recall.

Problem z tradycyjnymi LLM

Modele językowe mają fundamentalne ograniczenia, podobnie jak zwierzęta przystosowane tylko do jednego środowiska:

Ograniczenia bazowych LLM:

  1. Knowledge cutoff - wiedza zamrożona w czasie treningu
  2. Halucynacje - generowanie nieprawdziwych informacji
  3. Brak kontekstu firmowego - nie znają Twoich dokumentów
  4. Wysokie koszty fine-tuningu - dostosowanie modelu jest drogie

Najważniejsze jest pierwsze ograniczenie: model nie wie nic o tym, co wydarzyło się po zakończeniu treningu, i nie zna Twoich prywatnych dokumentów. RAG nie zmienia samego modelu. Zmienia to, co model dostaje do przeczytania przed odpowiedzią.

Czym jest RAG?

RAG to architektura, która łączy wyszukiwanie informacji z generowaniem tekstu. Poniższy schemat pokazuje drogę pytania od użytkownika aż do gotowej odpowiedzi:

┌─────────────────────────────────────────────────────────┐
│                    RAG Pipeline                          │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  Pytanie użytkownika                                     │
│         │                                                │
│         ▼                                                │
│  ┌─────────────────┐                                    │
│  │   Embedding     │  ← Zamiana na wektor               │
│  └────────┬────────┘                                    │
│           │                                              │
│           ▼                                              │
│  ┌─────────────────┐     ┌─────────────────┐           │
│  │ Vector Search   │────▶│ Vector Database │           │
│  └────────┬────────┘     └─────────────────┘           │
│           │                                              │
│           ▼                                              │
│  ┌─────────────────┐                                    │
│  │ Retrieved Docs  │  ← Top-K podobnych dokumentów      │
│  └────────┬────────┘                                    │
│           │                                              │
│           ▼                                              │
│  ┌─────────────────┐                                    │
│  │   LLM + Context │  ← Generowanie z kontekstem       │
│  └────────┬────────┘                                    │
│           │                                              │
│           ▼                                              │
│      Odpowiedź                                           │
└─────────────────────────────────────────────────────────┘

Czytaj go od góry. Pytanie zamieniamy na wektor liczb (embedding), szukamy w bazie wektorowej fragmentów o podobnym znaczeniu, bierzemy kilka najlepszych (Top-K) i doklejamy je do promptu. Dopiero wtedy LLM generuje odpowiedź. Model się nie zmienia, zmienia się tylko jego "ściąga" na czas jednego pytania.

Podstawowa implementacja RAG

Zbudujmy cały pipeline w kilkudziesięciu linijkach. Zaczynamy od klienta OpenAI, NumPy i malutkiej bazy wiedzy, czyli listy zdań, które pełnią rolę notatnika terenowego:

from openai import OpenAI
import numpy as np

client = OpenAI()

# Prosta baza wiedzy
knowledge_base = [
    "Python Safari to kurs programowania w Pythonie z 12 modułami.",
    "RAG łączy wyszukiwanie dokumentów z generowaniem tekstu przez LLM.",
    "Embeddings to wektorowe reprezentacje tekstu w przestrzeni semantycznej.",
    "Vector databases przechowują i wyszukują embeddings efektywnie.",
    "LlamaIndex to framework do budowania aplikacji RAG.",
    "CrewAI umożliwia tworzenie systemów multi-agentowych."
]

OpenAI() czyta klucz API ze zmiennej środowiskowej OPENAI_API_KEY, więc nie wpisujemy go w kod. Sama baza wiedzy to zwykła lista stringów, nic magicznego.

Teraz dwie funkcje pomocnicze. Pierwsza wysyła tekst do modelu text-embedding-3-small i zwraca wektor, druga liczy podobieństwo kosinusowe, czyli jak bardzo dwa wektory "patrzą" w tę samą stronę:

def get_embedding(text: str) -> list[float]:
    """Generuje embedding dla tekstu."""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(vec1: list, vec2: list) -> float:
    """Oblicza podobieństwo kosinusowe dwóch wektorów."""
    vec1, vec2 = np.array(vec1), np.array(vec2)
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

Podobieństwo kosinusowe przyjmuje wartości od -1 do 1, a im bliżej 1, tym bliższe znaczenie tekstów. Dokładniej rozłożymy je na części w następnej lekcji.

Trzeci krok to wyszukiwarka. Dla każdego dokumentu liczymy podobieństwo do pytania, sortujemy malejąco i zwracamy top_k najlepszych:

def retrieve_relevant_docs(query: str, docs: list, top_k: int = 3) -> list[str]:
    """Wyszukuje najbardziej podobne dokumenty."""
    query_embedding = get_embedding(query)

    similarities = []
    for doc in docs:
        doc_embedding = get_embedding(doc)
        similarity = cosine_similarity(query_embedding, doc_embedding)
        similarities.append((doc, similarity))

    # Sortuj po podobieństwie
    similarities.sort(key=lambda x: x[1], reverse=True)

    return [doc for doc, _ in similarities[:top_k]]

Zwróć uwagę na jedną słabość: ta funkcja liczy embedding każdego dokumentu przy każdym pytaniu. Przy sześciu zdaniach to nie boli, przy tysiącach dokumentów byłoby drogie i wolne. Dlatego w kolejnych lekcjach embeddingi dokumentów liczymy raz i przechowujemy w bazie wektorowej.

Na koniec składamy wszystko w funkcję rag_query, w której widać trzy litery skrótu: Retrieve, Augment, Generate:

def rag_query(question: str) -> str:
    """Pełny pipeline RAG."""
    # 1. Retrieve - znajdź relevantne dokumenty
    relevant_docs = retrieve_relevant_docs(question, knowledge_base)

    # 2. Augment - zbuduj prompt z kontekstem
    context = "\n".join(relevant_docs)

    prompt = f"""Odpowiedz na pytanie używając TYLKO poniższego kontekstu.
Jeśli nie możesz odpowiedzieć na podstawie kontekstu, powiedz "Nie wiem".

Kontekst:
{context}

Pytanie: {question}
"""

    # 3. Generate - wygeneruj odpowiedź
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

# Test
answer = rag_query("Co to jest RAG?")
print(answer)

Kluczowa jest instrukcja w prompcie: "używając TYLKO poniższego kontekstu" oraz prawo do odpowiedzi "Nie wiem". To właśnie ogranicza halucynacje. Sam model gpt-4o-mini pozostał dokładnie taki sam jak przed chwilą, zmienił się tylko prompt.

Chunking - dzielenie dokumentów

Długie dokumenty trzeba podzielić na mniejsze fragmenty (chunks), bo embedding całej książki rozmywa znaczenie, a prompt ma ograniczoną długość. Najprostsza metoda tnie tekst co określoną liczbę znaków, z zakładką (overlap):

from typing import Generator

def simple_chunker(text: str, chunk_size: int = 500, overlap: int = 100) -> Generator[str, None, None]:
    """Prosta funkcja do dzielenia tekstu na chunki."""
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        yield chunk
        start = end - overlap  # Overlap dla zachowania kontekstu

Zakładka sprawia, że zdanie przecięte na granicy trafi w całości przynajmniej do jednego fragmentu. Pilnuj tylko, żeby overlap był mniejszy niż chunk_size, inaczej pętla nigdy się nie skończy. Ostatni fragment bywa też bardzo krótki, bo to końcówka tekstu.

Lepiej zachowuje sens podział po zdaniach. Wyrażenie regularne rozcina tekst po kropce, wykrzykniku lub pytajniku, a potem sklejamy po kilka zdań:

def sentence_chunker(text: str, sentences_per_chunk: int = 5) -> list[str]:
    """Dzieli tekst na chunki po zdaniach."""
    import re

    # Prosta segmentacja zdań
    sentences = re.split(r'(?<=[.!?])\s+', text)

    chunks = []
    for i in range(0, len(sentences), sentences_per_chunk):
        chunk = ' '.join(sentences[i:i + sentences_per_chunk])
        chunks.append(chunk)

    return chunks

# Przykład użycia
document = """
Python to język programowania wysokiego poziomu. Został stworzony przez
Guido van Rossuma. Jest bardzo popularny w Data Science i Machine Learning.
RAG to technika łącząca retrieval z generowaniem. Pozwala modelom LLM
korzystać z zewnętrznych źródeł wiedzy. Jest kluczowa dla enterprise AI.
"""

chunks = sentence_chunker(document, sentences_per_chunk=2)
for i, chunk in enumerate(chunks):
    print(f"Chunk {i}: {chunk[:50]}...")

Każdy wypisany chunk zawiera teraz pełne zdania, a treść dokumentu się nie zmieniła, zmieniło się tylko jej opakowanie. Polecam zaczynać od podziału po zdaniach, bo fragmenty ucięte w połowie myśli dają słabsze embeddingi.

Metryki jakości RAG

Jak sprawdzić, czy RAG działa dobrze? Oceniamy dwa etapy osobno: czy wyszukiwanie znalazło właściwe fragmenty i czy odpowiedź trzyma się kontekstu. Oto szkielet klasy z trzema typowymi metrykami:

from dataclasses import dataclass

@dataclass
class RAGMetrics:
    """Metryki do ewaluacji systemu RAG."""

    def relevance_score(self, query: str, retrieved_doc: str) -> float:
        """Czy dokument jest relevantny do pytania?"""
        # W praktyce używamy LLM do oceny
        pass

    def faithfulness_score(self, answer: str, context: str) -> float:
        """Czy odpowiedź opiera się na kontekście?"""
        # Sprawdza halucynacje
        pass

    def answer_correctness(self, answer: str, ground_truth: str) -> float:
        """Czy odpowiedź jest poprawna?"""
        # Porównanie z ground truth
        pass

Metody mają tylko pass, bo w praktyce ocenę trafności (relevance), wierności kontekstowi (faithfulness) i poprawności odpowiedzi robi zwykle drugi model w roli sędziego. To szkielet do uzupełnienia, nie gotowe narzędzie.

Wyszukiwanie da się za to zmierzyć zwykłą arytmetyką zbiorów. Precision mówi, jaka część znalezionych dokumentów jest trafna, recall, jaką część trafnych dokumentów znaleźliśmy:

# Przykład prostej ewaluacji
def evaluate_retrieval(query: str, retrieved: list[str], relevant: list[str]) -> dict:
    """Oblicza precision i recall dla retrieval."""
    retrieved_set = set(retrieved)
    relevant_set = set(relevant)

    true_positives = len(retrieved_set & relevant_set)

    precision = true_positives / len(retrieved_set) if retrieved_set else 0
    recall = true_positives / len(relevant_set) if relevant_set else 0

    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

    return {
        "precision": precision,
        "recall": recall,
        "f1": f1
    }

Przykład: jeśli system zwrócił ["a", "b", "c"], a trafne były ["a", "d"], to precision wynosi 1/3, recall 1/2, a F1, czyli średnia harmoniczna obu, 0.4.

RAG to fundament nowoczesnych aplikacji AI enterprise. W następnej lekcji poznasz embeddings - serce całego systemu wyszukiwania - i zobaczysz, dlaczego podobne znaczenia lądują blisko siebie.

Zapamiętaj z tej wyprawy: RAG to przewodnik, który przed każdą odpowiedzią zagląda do swojego notatnika terenowego.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co oznacza skrót RAG w kontekście AI?

  2. 2. Które ograniczenie tradycyjnych LLM RAG pomaga rozwiązać?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj podstawowy pipeline RAG

  • Układanie w pionie

    Uporządkuj kroki:

  • Klikanie w kolejności

    Ułóż kroki pipeline RAG:

  • Układanie w pionie

    Ułóż kroki pipeline RAG w prawidłowej kolejności:

  1. PytanieCzym jest RAG?
  2. PytanieProblem LLM
  3. Zadanie z kodemPodstawowy RAG
  4. Ułóż w kolejnościRAG Ingest Pipeline
  5. Kliknij w kolejnościRAG Query Pipeline
  6. Ułóż w kolejnościRAG Query Pipeline

Przydatne artykuły