Parent-Child- und Small-to-Big-Retrieval
Speichern Sie kleine untergeordnete Chunks für einen präzisen Abruf, geben Sie dem LLM jedoch die größeren übergeordneten Chunks als Kontext zurück. So bringen Sie Abrufpräzision und Generierungsqualität ins Gleichgewicht.
Parent-Child- und Small-to-Big-Retrieval ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Das Dilemma zwischen Präzision und Kontext
RAG-Systeme stehen vor einem Zielkonflikt: kleine Chunks werden mit hoher Präzision abgerufen, weil sich jeder Chunk auf eine einzelne Idee konzentriert, aber ihnen fehlt der umgebende Kontext, den das LLM benötigt, um eine vollständige Antwort zu erzeugen. Große Chunks liefern umfangreichen Kontext, verringern jedoch die Abrufpräzision, weil sie zu vielen Abfragen nur schwach statt zu einer Abfrage stark passen. Parent-Child-Chunking löst dieses Dilemma.
Die Parent-Child-Architektur
Beim Parent-Child-Chunking erstellen Sie aus demselben Dokument zwei Chunk-Ebenen. Child-Chunks sind klein (z. B. 1–3 Sätze) und werden für den Abruf eingebettet und indiziert. Parent-Chunks sind größere Abschnitte (z. B. ganze Absätze oder Seiten), die separat gespeichert werden. Wenn ein Child abgerufen wird, geben Sie stattdessen dessen Parent an das LLM zurück.
Die Chunk-Hierarchie aufbauen
Im ersten Schritt teilen Sie das Dokument in große Parent-Chunks auf und teilen anschließend jeden Parent in kleinere Child-Chunks. Jeder Child-Chunk enthält eine Referenz – typischerweise ein parent_id-Metadatenfeld –, die auf seinen Parent verweist. Über diese Zuordnung können Sie ausgehend von jedem abgerufenen Child den vollständigen Parent-Abschnitt nachschlagen.
from langchain.text_splitter import RecursiveCharacterTextSplitter
parent_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=0)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=30)
parent_chunks = parent_splitter.split_documents(docs)
child_chunks = []
for i, parent in enumerate(parent_chunks):
children = child_splitter.split_documents([parent])
for child in children:
child.metadata['parent_id'] = i
child_chunks.extend(children)Nur Child-Chunks indizieren
Nur die Child-Chunks werden eingebettet und in der Vektordatenbank gespeichert. Die Parent-Chunks werden in einem separaten Key-Value-Store gespeichert (einem In-Memory-Wörterbuch, Redis oder einer Dokumentdatenbank). Dadurch bleibt der Vektorindex kompakt und präzise, während sich der umfangreiche Kontext außerhalb davon befindet.
# Store parents in a docstore
parent_store = {i: chunk.page_content for i, chunk in enumerate(parent_chunks)}
# Embed and index only children
vectorstore = Chroma.from_documents(
child_chunks,
embedding=OpenAIEmbeddings()
)Abruf: Child hinein, Parent heraus
Beim Abruf wird die Benutzerabfrage eingebettet und mit den Child-Chunks abgeglichen. Die Top-k-Child-Chunks werden ermittelt und ihre parent_id-Referenzen durch eine Suche im Parent-Store aufgelöst. Anschließend werden die Parent-Abschnitte – nicht die Childs – in den LLM-Prompt eingefügt. Das LLM erhält umfassenden Kontext, während der Abruf präzise war.
def retrieve_with_parents(query, vectorstore, parent_store, k=5):
child_results = vectorstore.similarity_search(query, k=k)
seen_parent_ids = set()
parent_contexts = []
for child in child_results:
pid = child.metadata['parent_id']
if pid not in seen_parent_ids:
parent_contexts.append(parent_store[pid])
seen_parent_ids.add(pid)
return parent_contextsLangChain ParentDocumentRetriever
LangChain stellt die Klasse ParentDocumentRetriever bereit, die dieses Muster direkt implementiert. Sie geben einen Parent-Splitter, einen Child-Splitter, einen Vectorstore für die Child-Einbettungen und einen Docstore für die Parent-Dokumente an. Die Klasse erstellt die Hierarchie und übernimmt den Abruf transparent.
from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore
store = InMemoryStore()
retriever = ParentDocumentRetriever(
vectorstore=vectorstore,
docstore=store,
child_splitter=child_splitter,
parent_splitter=parent_splitter
)
retriever.add_documents(docs)
results = retriever.invoke('What is the refund policy?')Small-to-Big-Retrieval erklärt
Small-to-Big-Retrieval ist eine weitere Bezeichnung für dasselbe Konzept: Sie rufen kleine, präzise Chunks ab und erweitern sie anschließend um ihren umgebenden Kontext, bevor Sie sie an das LLM senden. Manche Implementierungen erweitern nicht auf einen festen Parent, sondern auf ein Fenster benachbarter Sätze – das Modell erhält also die Sätze vor und nach dem gefundenen Chunk, um den Kontextzusammenhang zu wahren.
def retrieve_with_window(query, vectorstore, sentences, window=2, k=5):
results = vectorstore.similarity_search(query, k=k)
expanded = []
for r in results:
idx = r.metadata['sentence_index']
start = max(0, idx - window)
end = min(len(sentences), idx + window + 1)
expanded.append(' '.join(sentences[start:end]))
return expandedParent-Chunks deduplizieren
Für eine Abfrage können mehrere Child-Chunks desselben Parents abgerufen werden. Ohne Deduplizierung würde derselbe Parent-Abschnitt mehrfach im Prompt erscheinen und dabei Tokens verschwenden. Führen Sie vor dem Zusammenstellen des Kontexts immer eine Deduplizierung nach der Parent-ID durch. Das Codebeispiel in der oben gezeigten retrieve-Funktion erledigt dies mit einem seen_parent_ids-Set.
Wann Sie Parent-Child-Chunking verwenden sollten
Parent-Child-Retrieval funktioniert am besten, wenn Ihre Dokumente eine klare hierarchische Struktur aufweisen: Kapitel mit Abschnitten, Artikel mit Absätzen oder Wikis mit Unterabschnitten. Besonders wirksam ist es bei langen technischen Dokumentationen, in denen präzise Fragen lokal begrenzte Antworten erfordern, diese Antworten aber nur im Kontext eines umfassenderen Abschnitts sinnvoll sind.
Child- und Parent-Größen festlegen
Eine typische Konfiguration besteht aus Child-Chunks mit 200–400 Tokens (konzentrierte Einzelideen) und Parent-Chunks mit 1000–2000 Tokens (vollständige Abschnitte). Sind Child-Chunks zu klein, werden sie zu einzelnen Sätzen, die für sich genommen keine ausreichende Bedeutung haben. Sind Parent-Chunks zu groß, führen Sie das Problem der Kontextverwässerung wieder ein, das Sie eigentlich vermeiden wollten.
Ansätze im Vergleich: Eine Zusammenfassung
Zusammenfassung der bisherigen Chunking-Strategien: Chunking mit fester Größe ist schnell, unterbricht jedoch den Kontext; semantisches Chunking bewahrt den thematischen Zusammenhang; Parent-Child-Chunking optimiert sowohl die Abrufpräzision als auch den Kontextreichtum des LLMs. Für die meisten produktiven RAG-Systeme mit langen Dokumenten liefert Parent-Child-Chunking bei überschaubarer Komplexität die beste Abrufqualität.
Kurze Überprüfung
Testen Sie Ihr Verständnis des Parent-Child-Chunkings aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Child-Chunks ermöglichen einen präzisen Abruf, während Parent-Chunks umfangreichen Kontext liefern, LangChains ParentDocumentRetriever implementiert dies automatisch und die Deduplizierung nach der Parent-ID verhindert wiederholten Kontext. Als Nächstes untersuchen wir dokumentspezifische Chunking-Strategien für Codedateien und HTML-Dokumente.
Häufig gestellte Fragen
Ist die Lektion „Parent-Child- und Small-to-Big-Retrieval“ kostenlos?
Ja — der vollständige Text von „Parent-Child- und Small-to-Big-Retrieval“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Parent-Child- und Small-to-Big-Retrieval“?
Speichern Sie kleine untergeordnete Chunks für einen präzisen Abruf, geben Sie dem LLM jedoch die größeren übergeordneten Chunks als Kontext zurück. So bringen Sie Abrufpräzision und Generierungsqual… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Parent-Child- und Small-to-Big-Retrieval“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Warum naives Chunking den Abruf verschlechtert
- Semantisches Chunking mit Embedding-Ähnlichkeit
- Parent-Child- und Small-to-Big-Retrieval
- Dokumentspezifische Strategien für Code und HTML