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

Przygotowanie danych

Lekcja 10 z 18 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Jakość RAG zależy od Twoich danych
  2. Pobieranie danych
  3. Czyszczenie danych
  4. Strategie podziału na fragmenty (Chunking)
  5. Kompletny potok przygotowania
  6. Kluczowe wnioski

Jakość RAG zależy od Twoich danych

Potok RAG jest tak dobry, jak dane, które indeksujesz. Możesz stworzyć idealny prompt i wybrać najlepszy model generatywny, ale jeśli pobrany fragment ucina definicję w połowie lub wciąga powtarzający się stopkę zamiast użytecznego tekstu, Twoja odpowiedź ucierpi. Przygotowanie odbywa się w trzech etapach: pobranie danych z ich źródła, usunięcie wszystkiego, co bez znaczenia, i podział na fragmenty zoptymalizowane pod kątem indeksowania.

Pobieranie danych

Zbiory danych ze świata rzeczywistego rzadko są jednorodne. Zazwyczaj masz dokumentację Markdown w repozytorium, kilka stron z publicznej witryny i garść plików PDF z przepisami. Każde źródło wymaga własnego loadera, ale wszystkie muszą produkować tę samą strukturę – treść, źródło i typ – aby reszta potoku pozostała niezależna od pochodzenia tekstu.

Dla plików tekstowych wystarczy rekurencyjne przeszukiwanie katalogu, a filtrowanie po rozszerzeniu zapobiega przypadkowemu ładowaniu plików binarnych.

import os

def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
    """Load all text files from a directory."""
    documents = []
    for root, dirs, files in os.walk(directory):
        for f in files:
            if any(f.endswith(ext) for ext in extensions):
                filepath = os.path.join(root, f)
                with open(filepath, "r", encoding="utf-8") as fh:
                    content = fh.read()
                documents.append({
                    "content": content,
                    "source": filepath,
                    "type": "text",
                })
    return documents

docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")

Strony internetowe przychodzą przez HTTP, ale tym, co otrzymujesz, jest HTML. Poniższa ekstrakcja usuwa tagi za pomocą wyrażeń regularnych i scala wielokrotne spacje. To wystarczy do prototypu, ale komentarz przypomina, że w środowisku produkcyjnym BeautifulSoup poradzi sobie znacznie lepiej z tabelami i zagnieżdżonymi listami.

import requests

def fetch_web_page(url):
    """Fetch the text content of a web page."""
    response = requests.get(url)
    response.raise_for_status()

    # Basic text extraction (use BeautifulSoup for production)
    text = response.text
    # Remove HTML tags
    import re
    text = re.sub(r'<[^>]+>', ' ', text)
    text = re.sub(r'\s+', ' ', text).strip()

    return {
        "content": text,
        "source": url,
        "type": "web",
    }

# Example
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")

Pliki PDF zasługują na specjalne traktowanie. Zamiast łączyć cały dokument w jedną całość, zachowaj jeden wpis na stronę i zakoduj numer strony w źródle jako file.pdf#page=12. Gdy Twój asystent zacytuje ten fragment, użytkownik będzie wiedział dokładnie, gdzie go zweryfikować.

# pip install PyPDF2
from PyPDF2 import PdfReader

def load_pdf(filepath):
    """Extract text from a PDF."""
    reader = PdfReader(filepath)
    pages = []
    for i, page in enumerate(reader.pages):
        text = page.extract_text()
        if text.strip():
            pages.append({
                "content": text,
                "source": f"{filepath}#page={i+1}",
                "type": "pdf",
                "page": i + 1,
            })
    return pages

Czyszczenie danych

Czyszczenie jest kluczowe dla jakości wyszukiwania, ponieważ każdy zbędny znak zużywa miejsce we fragmencie i zanieczyszcza wynikowy wektor. Poniższa funkcja łączy cztery zabiegi: usuwa znaki kontrolne pozostałe po konwersji formatów, normalizuje sekwencje nowych linii i spacji, usuwa znaczniki paginacji typowe dla plików PDF i zastępuje nieskończone adresy URL prostym symbolem zastępczym, aby nie zjadały całego fragmentu.

import re

def clean_text(text):
    """Clean text for RAG indexing."""
    # Remove control characters
    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)

    # Normalize spaces and newlines
    text = re.sub(r'\n{3,}', '\n\n', text)
    text = re.sub(r' {2,}', ' ', text)

    # Remove repetitive headers/footers (PDF)
    text = re.sub(r'Page \d+ of \d+', '', text)

    # Remove very long URLs
    text = re.sub(r'https?://\S{100,}', '[URL]', text)

    return text.strip()

# Apply cleaning
for doc in docs:
    doc["content"] = clean_text(doc["content"])

Strategie podziału na fragmenty (Chunking)

Podział na fragmenty to najważniejszy krok w przygotowaniu: rozmiar fragmentu i metoda mają bezpośredni wpływ na jakość wyszukiwania. Istnieją trzy podejścia, od mechanicznego po świadome struktury.

Podział o stałym rozmiarze przesuwa się przez tekst w regularnych kawałkach. Ignoruje całkowicie znaczenie, co czyni go zastosowalnym do dowolnego źródła, ale często ucina zdania w połowie. Nakładanie się częściowo naprawia tę wadę: przy overlap=200 koniec każdego fragmentu powtarza się na początku następnego, zapewniając, że podzielona myśl pozostanie nienaruszona przynajmniej w jednym z dwóch kawałków.

def chunk_fixed_size(text, chunk_size=2048, overlap=200):
    """Fixed-size chunking with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + chunk_size, len(text))
        chunk = text[start:end]
        if chunk.strip():
            chunks.append(chunk.strip())
        start += chunk_size - overlap
    return chunks

Podział oparty na akapitach, zalecany dla dokumentacji, polega zamiast tego na naturalnych granicach tekstu. Akumuluje akapity, dopóki mieszczą się w max_size, a następnie otwiera nowy fragment. Próg min_size zapobiega indeksowaniu osieroconego nagłówka lub izolowanej linii, co wygenerowałoby wektor bez użytecznej treści.

def chunk_by_paragraphs(text, max_size=1500, min_size=100):
    """Intelligent paragraph-based chunking."""
    paragraphs = text.split("\n\n")
    chunks = []
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue

        if len(current) + len(para) + 2 <= max_size:
            current = current + "\n\n" + para if current else para
        else:
            if len(current) >= min_size:
                chunks.append(current)
            current = para

    if current and len(current) >= min_size:
        chunks.append(current)

    return chunks

Podział na sekcje Markdown wykorzystuje informacje, które autor już dostarczył: swoje nagłówki. Każda sekcja staje się samodzielnym fragmentem, gwarantując, że pytanie o „uwierzytelnianie“ pobierze całą sekcję, a nie jej fragment. Sekcje, które są zbyt długie, wracają do podziału na akapity, zapewniając, że żaden fragment nie przekroczy limitu.

def chunk_by_markdown_sections(text, max_size=2000):
    """Chunking by Markdown headings (## and ###)."""
    sections = re.split(r'\n(?=##\s)', text)
    chunks = []

    for section in sections:
        section = section.strip()
        if not section:
            continue
        if len(section) <= max_size:
            chunks.append(section)
        else:
            # Sub-chunk overly long sections
            sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
            chunks.extend(sub_chunks)

    return chunks

Kompletny potok przygotowania

Na koniec połącz trzy operacje razem i wybierz strategię podziału w zależności od typu pliku: pliki .md przechodzą przez sekcje, wszystko inne przez akapity. Każdy fragment niesie wtedy swoje metadane – źródło, pozycję w dokumencie i całkowitą liczbę fragmentów z tego dokumentu. Bez tego nie będziesz w stanie wskazać źródła odpowiedzi. Ostatnie dwie linie wyświetlają współczynnik ekspansji i średni rozmiar: jeśli ta średnia spadnie znacznie poniżej Twojego chunk_size, dokument jest bardziej pofragmentowany niż oczekiwano i musisz ponownie przeanalizować swoją strategię podziału.

def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
    """Complete pipeline: clean, chunk, enrich with metadata."""
    all_chunks = []

    for doc in raw_docs:
        # 1. Clean
        clean = clean_text(doc["content"])

        # 2. Chunk based on type
        if doc.get("source", "").endswith(".md"):
            chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
        else:
            chunks = chunk_by_paragraphs(clean, max_size=chunk_size)

        # 3. Enrich with metadata
        for i, chunk in enumerate(chunks):
            all_chunks.append({
                "text": chunk,
                "source": doc["source"],
                "chunk_index": i,
                "total_chunks": len(chunks),
            })

    return all_chunks

# Execution
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")

Kluczowe wnioski

  • Jakość RAG zależy bezpośrednio od jakości danych i strategii podziału na fragmenty
  • Wyczyść dane przed indeksowaniem (usuń zbędne znaki, długie adresy URL, duplikaty)
  • Podział na akapity lub sekcje Markdown zachowuje spójność semantyczną
  • Nakładanie się fragmentów na poziomie 10–15% zapobiega dzieleniu myśli
  • Zachowaj metadane (źródło, strona, pozycja) dla możliwości śledzenia odpowiedzi