Docling pour le RAG

Un pipeline RAG a six étapes ; Docling possède les trois premières — celles qui décident la qualité avant tout embedding. Deux philosophies : exporter en Markdown puis re-splitter (p. ex. MarkdownHeaderTextSplitter de LangChain), ou chunker natif sur le DoclingDocument. Le natif préserve tableaux, en-têtes et provenance que le re-split Markdown perd en silence : préférez-le sauf motif.

• Parsing — layout, ordre de lecture, tableaux, formules, images → un DoclingDocument structuré.
• Sérialisation / chunking — chunks structurels avec en-têtes, captions et provenance (ou export Markdown/HTML/JSON pour re-split).
• Enrichissement texte — contextualize() préfixe le contexte d'en-têtes pour que chaque chunk vaille seul.
• Embeddings → store → retrieval → génération — votre modèle, votre store, votre framework ; agnostiques à Docling.

Pour un pipeline programmatique, convertissez en Python et gardez l'objet document — les chunkers opèrent dessus, pas sur des fichiers :

from docling.document_converter import DocumentConverter

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

Les exports sont des raccourcis sur sérialiseurs (MarkdownDocSerializer etc.). Pour le RAG, le choix compte surtout pour les tableaux. Si les cellules d'en-tête fusionnées décident des réponses, préférez HTML ou JSON à Markdown — ou gardez Markdown mais répétez les en-têtes au chunking (section 7). Sérialiseurs personnalisables : sous-classez BaseTableSerializer et amis pour un contrôle total (voir l'exemple avancé chunking & sérialisation).

Tous les chunkers natifs implémentent BaseChunker (chunk() → flux de chunks, contextualize() → texte enrichi), donc les intégrations style LlamaIndex acceptent tout chunker intégré, propre ou tiers par la même interface.

Fonctionnement : partir des chunks hiérarchiques, puis une passe ne splitte que les surdimensionnés (conscient des tokens) et une autre ne fusionne que les peers sous-dimensionnés successifs aux mêmes en-têtes & captions. Paramètres clés :

Embeddez le texte contextualisé, pas chunk.text :

Deux notes opérationnelles : l'avertissement transformers « Token indices sequence length … » au chunking est une fausse alerte documentée (voir la FAQ officielle), et définissez TOKENIZERS_PARALLELISM=false pour taire les avertissements de fork en serveurs.

• tokenizer — alignez sur le tokenizer de votre modèle d'embeddings (section 9). Par défaut dérive les limites du tokenizer.
• max_tokens — plafond par chunk ; c'est la forme enrichie (contextualisée) qui doit tenir.
• merge_peers=True — fusionne les peers petits ; mettez False pour des splits stricts.
• repeat_table_header=True — chaque chunk de table commence par la ligne d'en-tête (section 7).
• omit_header_on_overflow=False — saute l'en-tête pour les lignes qui tiennent sans mais débordent avec (tables larges, budgets stricts).
• serializer_provider — p. ex. tables Markdown via ChunkingSerializerProvider pour contrôler la forme du texte.

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)  # en-têtes préfixés — EMBEDDEZ CECI
    vector = embed(enriched)

Démos résolues : chunking hybride (répétition sur CSV large incluse), chunking par lignes, extraction de tables.

• Répétez les en-têtes (repeat_table_header=True, défaut) : chaque chunk d'une table divisée commence par la ligne d'en-tête, donc chaque chunk s'auto-décrit pour le modèle.
• Échappatoire de débordement (omit_header_on_overflow=True) : pour tables larges, les lignes qui tiennent sans l'en-tête mais débordent avec la sautent — efficacité sans casser les lignes.
• Cellules fusionnées : Markdown aplatis les spans ; si elles comptent, chunkez depuis la sérialisation HTML/JSON ou un sérialiseur de tables propre.
• Alternative par lignes : LineBasedTokenChunker avec préfixe répété garde les lignes type CSV intactes, avec la même logique via omit_prefix_on_overflow.

Chaque chunk porte dl_meta — gardez-le dans le payload vectoriel ; il transforme « une réponse » en « une réponse avec source ». La provenance inclut pages et bounding boxes par item : assez pour des citations « page 3 » ou du surlignage de région (voir visual grounding). Ne sacrifiez jamais les métadonnées pour « gagner de la place » : sans elles, citer est impossible.

La règle est absolue : dimensionnez les chunks avec le tokenizer de votre modèle d'embeddings. Des tokenizers disparates dimensionnent mal en silence et cassent les décisions de fusion/split. À grande échelle, le pipeline chunk+tokenize de Data Prep Kit applique le même principe en batch.

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 : Deux modes : DOC_CHUNKS (défaut — un Document LangChain par chunk natif, métadonnées intactes) et MARKDOWN (un Document par fichier ; splitter ensuite, p. ex. avec MarkdownHeaderTextSplitter sur #/##/###). Flow complet dans l'exemple officiel RAG LangChain (Milvus + Mixtral) et le guide LangChain.

LlamaIndex — Reader + Node Parser : DoclingReader peuple des Documents LlamaIndex (JSON sans perte ou Markdown avec perte) ; le Docling Node Parser les convertit en Nodes connaissant le format. Toute implémentation BaseChunker s'emboîte dans la même interface. Voir l'exemple officiel RAG LlamaIndex.

Haystack et le reste : Haystack fournit Docling comme composant convertisseur (exemple, docs d'intégration). Au-delà des trois grands : txtai, Kotaemon, DocETL, Vectara, Semantica, Hector, haiku.rag, Bee, CrewAI, Langflow, Open WebUI, spaCy, NVIDIA, RAG du cookbook Granite et Data Prep Kit intègrent tous Docling — parcourez l'index officiel des intégrations.

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,  # chunks natifs (défaut)
    chunker=HybridChunker(tokenizer=tokenizer),
)
docs = loader.load()  # un Document LangChain par chunk, dl_meta en metadata

from llama_index.readers.docling import DoclingReader

reader = DoclingReader(export_type="json")  # sans perte ; "markdown" avec perte
documents = reader.load_data("report.pdf")

Le store n'affecte jamais Docling — chunks + embeddings s'upsertent partout. Exemples officiels pour :

--chunks-type accepte hybrid (défaut) ou hierarchical ; le tokenizer par défaut est sentence-transformers/all-MiniLM-L6-v2. La conversion distante (docling convert-remote / docling-serve) supporte les mêmes options côté serveur. Voir le chercheur de commandes.

• Tokenizer == modèle d'embeddings. Toujours. Revérifiez à chaque changement de modèle.
• Embeddez la sortie de contextualize() ; gardez chunk.text à part pour l'affichage.
• Gardez DocMeta (headings, page_no, bbox, origin) dans le payload pour les citations.
• Répétez les en-têtes de table ; pour les tables à cellules fusionnées utilisez la source HTML/JSON.
• Taillez le coût de conversion : --no-ocr pour les PDF numériques, sautez les enrichissements inutiles, convertissez en batch et pré-téléchargez les modèles (docling-tools models download --all).
• Scale-out : chunk+tokenize de Data Prep Kit pour les corpus ; /v1/convert/source de docling-serve avec --to chunks derrière une file pour les services.
• PII d'abord : détectez et obfusquez les PII avant d'embedder (voir l'exemple PII) — une fuite ne se dés-embedde pas.

• Réponses sans contexte / chunks « orphelins » — vous avez embeddé chunk.text ; passez à contextualize() et vérifiez les en-têtes.
• Tables mal répondues — activez repeat_table_header ; vérifiez les cellules fusionnées (Markdown aplatis les spans → utilisez HTML/JSON).
• Avertissement transformers de longueur — fausse alerte documentée, ignorable (FAQ officielle).
• Chunks trop gros/petits pour le modèle — mismatch de tokenizers ; fixez celui du modèle et ajustez max_tokens.
• Citations impossibles — métadonnées perdues à l'upsert ; persistez dl_meta (page_no, headings, origin).
• Ingestion trop lente — voir conversion lente : coupez OCR/enrichissements inutiles, utilisez le GPU, batchez.

Vérifié avec Docling v2.129.0 · Dernière vérification 2026-09-22 · Source officielle