Příprava dat
Na této stránce
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í