Docling für RAG

Eine RAG-Pipeline hat sechs Stufen; Docling besitzt die ersten drei — jene, die Antwortqualität entscheiden, bevor ein Embedding existiert. Zwei Chunking-Philosophien: nach Markdown exportieren und nachsplitten (z. B. LangChains MarkdownHeaderTextSplitter) oder nativ auf dem DoclingDocument chunken. Natives Chunken erhält Tabellen, Überschriften und Provenienz, die Markdown-Nachsplitten still fallen lässt — bevorzugen, sofern kein Grund dagegenspricht.

• Parsen — Layout, Lesereihenfolge, Tabellen, Formeln, Bilder → ein strukturiertes DoclingDocument.
• Serialisieren / chunken — strukturbewusste Chunks mit Überschriften, Captions und Provenienz (oder Markdown-/HTML-/JSON-Export zum Nachsplitten).
• Text anreichern — contextualize() stellt Überschriftenkontext voran, sodass jeder Chunk allein steht.
• Embedden → speichern → retrieven → generieren — eigenes Embedding-Modell, Vektor-Store und Framework; Docling-agnostisch.

Für eine programmatische Pipeline in Python umwandeln und das Dokumentobjekt behalten — Chunker arbeiten darauf, nicht auf Dateien:

from docling.document_converter import DocumentConverter

converter = DocumentConverter()
result = converter.convert("report.pdf")
document = result.document

Exporte sind Kurzformen über Serializer (MarkdownDocSerializer u. a.). Für RAG zählt die Wahl vor allem bei Tabellen. Falls verbundene Header-Zellen Antworten entscheiden, HTML oder JSON statt Markdown bevorzugen — oder Markdown behalten, aber beim Chunken Tabellen-Header wiederholen (Abschnitt 7). Serializer sind anpassbar: BaseTableSerializer u. a. subklassieren für volle Kontrolle (siehe Advanced-Chunking-&-Serialization-Beispiel).

Alle nativen Chunker implementieren BaseChunker (chunk() → Chunk-Strom, contextualize() → angereicherter Text), sodass LlamaIndex-artige Integrationen jeden eingebauten, eigenen oder Dritt-Chunker über dieselbe Schnittstelle nehmen.

So arbeitet er: Von hierarchischen Chunks starten, dann ein Durchlauf splittet nur übergroße Chunks (token-bewusst) und ein weiterer mergt nur untergroße aufeinanderfolgende Peers mit gleichen Überschriften & Captions. Wichtige Parameter:

Den kontextualisierten Text embedden, nicht chunk.text:

Zwei operative Hinweise: Die transformers-Warnung „Token indices sequence length …“ beim Chunken ist ein dokumentierter Fehlalarm (siehe offizielle FAQ), und TOKENIZERS_PARALLELISM=false setzen, um Fork-Warnungen in Servern zu beruhigen.

• tokenizer — auf den Tokenizer des Embedding-Modells abstimmen (Abschnitt 9). Standard leitet Limits vom Tokenizer ab.
• max_tokens — Cap je Chunk; die angereicherte (kontextualisierte) Form sollte passen.
• merge_peers=True — untergroße Peers mergen; für striktes Splitten auf False.
• repeat_table_header=True — jeder Tabellen-Chunk startet mit der Header-Zeile (Abschnitt 7).
• omit_header_on_overflow=False — Header für Zeilen droppen, die ohne passen, mit aber überlaufen (breite Tabellen, strikte Budgets).
• serializer_provider — z. B. Markdown-Tabellen via ChunkingSerializerProvider zur Chunk-Text-Formkontrolle.

from docling.chunking import HybridChunker

chunker = HybridChunker()
chunks = list(chunker.chunk(document))
print(len(chunks), chunks[0].text[:120])

for chunk in chunker.chunk(document):
    enriched = chunker.contextualize(chunk)  # Überschriften vorangestellt — DAS embedden
    vector = embed(enriched)

Ausgearbeitete Demos: Hybrid-Chunking (inkl. Header-Wiederholung an breiter CSV), zeilenbasiertes Chunking, Tabellenextraktion.

• Header wiederholen (repeat_table_header=True, Standard): Jeder Chunk einer geteilten Tabelle startet mit der Header-Zeile, sodass jeder Chunk fürs Embedding-Modell selbstbeschreibend ist.
• Overflow-Notausgang (omit_header_on_overflow=True): Für breite Tabellen überspringen Zeilen, die ohne Header passen, mit aber überlaufen, den Header — Token-Effizienz ohne Zeilenbruch.
• Verbundene Zellen: Markdown flacht Spans ab; falls verbundene Header zählen, Tabellen aus HTML-/JSON-Serialisierung chunken oder eigenen Tabellen-Serializer nutzen.
• Zeilenbasierte Alternative: LineBasedTokenChunker mit wiederholtem Präfix hält CSV-artige Zeilen intakt und kennt dieselbe Overflow-Logik via omit_prefix_on_overflow.

Jeder Chunk trägt dl_meta — im Vektor-Payload behalten; es macht aus „einer Antwort“ eine „Antwort mit Quelle“. Provenienz enthält Seitennummern und Bounding-Boxen je Item — genug für „Seite 3“-Zitate oder Quellregion-Highlighting (siehe Visual Grounding). Metadaten nie zum „Platzsparen“ droppen: ohne sie sind Zitate unmöglich.

Die Regel ist absolut: Chunks mit dem Tokenizer des Embedding-Modells bemessen. Gemischte Tokenizer bemessen Chunks still falsch und brechen Merge-/Split-Entscheidungen. Im großen Maßstab wendet die Data-Prep-Kit-Chunk+Tokenize-Pipeline dasselbe Prinzip im Batch an.

from transformers import AutoTokenizer
from docling_core.transforms.chunker.tokenizer.huggingface import HuggingFaceTokenizer
from docling.chunking import HybridChunker

EMBED_MODEL_ID = "sentence-transformers/all-MiniLM-L6-v2"
tokenizer = HuggingFaceTokenizer(
    tokenizer=AutoTokenizer.from_pretrained(EMBED_MODEL_ID),
    max_tokens=512,
)
chunker = HybridChunker(tokenizer=tokenizer, merge_peers=True)

LangChain — langchain-docling: Zwei Modi: DOC_CHUNKS (Standard — ein LangChain-Document je nativem Chunk, Metadaten erhalten) und MARKDOWN (ein Document je Datei; downstream splitten, z. B. mit MarkdownHeaderTextSplitter auf #/##/###). Voller Flow im offiziellen LangChain-RAG-Beispiel (Milvus + Mixtral) und der LangChain-Anleitung.

LlamaIndex — Reader + Node Parser: DoclingReader befüllt LlamaIndex-Documents (verlustfrei JSON oder verlustbehaftet Markdown); der Docling Node Parser macht daraus mit Formatwissen Nodes. Jede BaseChunker-Implementierung passt an dieselbe Schnittstelle. Siehe offizielles LlamaIndex-RAG-Beispiel.

Haystack und der Rest: Haystack liefert Docling als Konverter-Komponente (Beispiel, Integrations-Docs). Jenseits der großen drei: txtai, Kotaemon, DocETL, Vectara, Semantica, Hector, haiku.rag, Bee, CrewAI, Langflow, Open WebUI, spaCy, NVIDIA, Granite-Cookbook-RAG und Data Prep Kit integrieren alle Docling — stöbern im offiziellen Integrationsindex.

from transformers import AutoTokenizer
from docling_core.transforms.chunker.tokenizer.huggingface import HuggingFaceTokenizer
from docling.chunking import HybridChunker
from langchain_docling import DoclingLoader
from langchain_docling.loader import ExportType

tokenizer = HuggingFaceTokenizer(
    tokenizer=AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
)
loader = DoclingLoader(
    file_path=["https://arxiv.org/pdf/2408.09869"],
    export_type=ExportType.DOC_CHUNKS,  # native Chunks (Standard)
    chunker=HybridChunker(tokenizer=tokenizer),
)
docs = loader.load()  # ein LangChain-Document je Chunk, dl_meta in metadata

from llama_index.readers.docling import DoclingReader

reader = DoclingReader(export_type="json")  # verlustfrei; "markdown" für verlustbehaftet
documents = reader.load_data("report.pdf")

Der Store beeinflusst Docling nie — Chunks + Embeddings upserten überall. Offizielle Beispiele existieren für:

--chunks-type nimmt hybrid (Standard) oder hierarchical; der Tokenizer steht standardmäßig auf sentence-transformers/all-MiniLM-L6-v2. Remote-Conversion (docling convert-remote / docling-serve) unterstützt dieselben Chunk-Optionen serverseitig. Siehe die Befehlssuche.

• Tokenizer == Embedding-Modell. Immer. Bei jedem Modellwechsel erneut prüfen.
• contextualize()-Output embedden, chunk.text daneben für Anzeige speichern.
• DocMeta behalten (headings, page_no, bbox, origin) im Payload für Zitate.
• Tabellen-Header wiederholen; für Merged-Cell-Tabellen HTML-/JSON-Quelle nutzen.
• Conversions-Kosten trimmen: --no-ocr für digitale PDFs, ungenutzte Enrichments überspringen, batch-umwandeln und Modelle vorab laden (docling-tools models download --all).
• Scale-out: Data-Prep-Kit-Chunk+Tokenize für Korpora; docling-serve-/v1/convert/source mit --to chunks hinter einer Queue für Services.
• PII zuerst: PII vor dem Embedden erkennen und obfuskieren (siehe PII-Beispiel) — ein Leak lässt sich nicht un-embedden.

• Antworten ohne Kontext / „Waisen“-Chunks — chunk.text geembeddet; auf contextualize() wechseln und Überschriften prüfen.
• Tabellenantworten falsch — repeat_table_header aktivieren; Merged Cells prüfen (Markdown flacht Spans ab → HTML/JSON nutzen).
• Transformers-Sequenzlängen-Warnung — dokumentierter Fehlalarm, gefahrlos ignorierbar (offizielle FAQ).
• Chunks zu groß/klein fürs Embedding-Modell — Tokenizer-Mismatch; Chunker-Tokenizer aufs Embedding-Modell setzen und max_tokens justieren.
• Keine Zitate möglich — Metadaten beim Upsert gedroppt; dl_meta (page_no, headings, origin) persistieren.
• Ingestion zu langsam — siehe Umwandlung ist langsam: ungenutzte OCR/Enrichments deaktivieren, GPU nutzen, batchen.

Verifiziert mit Docling v2.129.0 · Zuletzt geprüft 2026-09-22 · Offizielle Quelle