Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Příprava dat

Lekce 10 z 18 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Kvalita RAG závisí na tvých datech
  2. Získávání dat
  3. Čištění dat
  4. Strategie dělení na úseky (Chunking)
  5. Kompletní pipeline přípravy
  6. Klíčové poznatky

Kvalita RAG závisí na tvých datech

RAG pipeline je jen tak dobrá, jako jsou data, která indexuje. Můžeš vytvořit dokonalý prompt a vybrat ten nejlepší generační model, ale pokud získaný úsek (chunk) půlí definici napůl nebo táhne za sebou opakující se zápatí místo užitečného textu, tvá odpověď bude trpět. Příprava probíhá ve třech fázích: získání dat tam, kde sídlí, odstranění všeho bezvýznamného a rozdělení na úseky optimalizované pro indexaci.

Získávání dat

Reálná korpora jsou zřídka homogenní. Obvykle budeš mít dokumentaci v Markdownu v repozitáři, několik stránek z veřejného webu a hrstku regulačních PDF. Každý zdroj potřebuje svůj vlastní načítač, ale všechny musí produkovat stejnou strukturu – obsah, zdroj a typ – aby zbytek pipeline zůstal lhostejný k původu textu.

Pro textové soubory stačí rekurzivní procházení adresáře a filtrování podle přípony zabrání náhodnému načtení binárních souborů.

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")

Webové stránky přicházejí přes HTTP, ale to, co dostaneš, je HTML. Následující extrakce odstraní tagy pomocí regulárních výrazů a sloučí více mezer. To stačí pro prototyp, ale komentář ti připomíná, že v produkci odvede BeautifulSoup mnohem lepší práci s tabulkami a vnořenými seznamy.

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")

PDF si zaslouží zvláštní zacházení. Místo spojení celého dokumentu si ponech jeden záznam na stránku a zakóduj číslo stránky ve zdroji jako file.pdf#page=12. Když tvůj asistent cituje tento úsek, uživatel bude přesně vědět, kde si ho má ověřit.

# 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

Čištění dat

Čištění je kritické pro kvalitu vyhledávání, protože každý nežádoucí znak spotřebovává místo v úseku a kalí výsledný vektor. Následující funkce řetězí čtyři úpravy: odstraní řídicí znaky zbylé po konverzích formátů, normalizuje sekvence nových řádků a mezer, vymaže označení stránkování typická pro PDF a nahradí nekonečné URL jednoduchým zástupným symbolem, aby nesnědly celý úsek.

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 dělení na úseky (Chunking)

Dělení na úseky je nejdůležitějším krokem přípravy: velikost úseku a metoda přímo ovlivňují kvalitu vyhledávání. Existují tři přístupy, od mechanických až po ty respektující strukturu.

Dělení na úseky pevné velikosti prochází textem v pravidelných řezech. Zcela ignoruje význam, což jej činí použitelným pro jakýkoli zdroj, ale často půlí věty napůl. Překryv tuto chybu částečně opravuje: s overlap=200 se konec každého úseku opakuje na začátku dalšího, což zajišťuje, že rozdělená myšlenka zůstane celistvá alespoň v jednom ze dvou kusů.

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

Dělení založené na odstavcích, doporučené pro dokumentaci, spoléhá místo toho na přirozené hranice textu. Akumuluje odstavce, dokud zůstávají pod max_size, a poté otevírá nový úsek. Prahová hodnota min_size zabraňuje indexování osamoceného nadpisu nebo izolovaného řádku, což by vytvořilo vektor bez použitelného obsahu.

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

Dělení podle sekcí Markdownu využívá informace, které autor již poskytl: své nadpisy. Každá sekce se stane samostatným úsekem, což zaručuje, že dotaz na „autentizaci“ získá celou sekci, nikoli jen fragment. Sekce, které jsou příliš dlouhé, se vrátí k dělení po odstavcích, čímž se zajistí, že žádný úsek nepřekročí limit.

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

Kompletní pipeline přípravy

Nakonec tyto tři operace seřaď za sebe a vyber strategii dělení na úseky na základě typu souboru: soubory .md projdou sekcemi, vše ostatní odstavci. Každý úsek pak nese svá metadata – zdroj, pozici v dokumentu a celkový počet úseků z daného dokumentu. Bez toho nebudeš schopen dohledat zdroj odpovědi. Poslední dva řádky zobrazují míru expanze a průměrnou velikost: pokud tento průměr klesne hluboko pod tvou chunk_size, je dokument fragmentovanější, než se očekávalo, a musíš svou strategii dělení přehodnotit.

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")

Klíčové poznatky

  • Kvalita RAG přímo závisí na kvalitě dat a strategii dělení na úseky
  • Před indexováním data vyčisti (odstraň nežádoucí znaky, dlouhé URL, duplicity)
  • Dělení po odstavcích nebo sekcích Markdownu zachovává sémantickou soudržnost
  • Překryv 10–15 % mezi úseky zabraňuje půlení myšlenek
  • Uchovávej metadata (zdroj, stránka, pozice) pro dohledatelnost odpovědí