Travailler avec des documents dans différents formats est un défi courant lorsqu'on développe des applications d'IA. Qu'il s'agisse de traiter des PDF, des documents Word ou des fichiers HTML, extraire un texte propre et structuré peut s'avérer étonnamment difficile. Docling est une bibliothèque Python qui simplifie considérablement ce processus.
Ce guide vous présente l'essentiel de l'utilisation de Docling pour traiter des documents, en mettant l'accent sur des exemples pratiques et des bonnes pratiques directement applicables.
Pourquoi Docling ?
Docling résout de manière unifiée les problèmes courants de traitement documentaire. Il offre une prise en charge multi-format qui fonctionne aussi bien avec les PDF, les documents Word, les présentations PowerPoint que les fichiers HTML. La bibliothèque intègre des fonctionnalités d'OCR capables d'extraire le texte même à partir de documents scannés ou d'images, ce qui la rend polyvalente pour de nombreux types de documents.
Ce qui distingue Docling, c'est son découpage intelligent (« chunking ») qui fragmente les documents en portions cohérentes tout en préservant le contexte, plutôt que de couper le texte de manière arbitraire. Le résultat est propre et structuré, que vous ayez besoin d'un format markdown ou de texte brut. Enfin, Docling propose une API simple et intuitive, facile à prendre en main même pour les développeurs découvrant le traitement documentaire.
Prise en main
Commencez par installer Docling :
pip install doclingUtilisation de base
Convertir un document
La façon la plus simple d'utiliser Docling est de passer par le DocumentConverter :
from docling.document_converter import DocumentConverter
# Create a converter
converter = DocumentConverter()
# Convert a document
result = converter.convert("document.pdf")
document = result.document
# Export to markdown
markdown_text = document.export_to_markdown()
print(markdown_text)C'est tout ! Docling détecte automatiquement le format du fichier et le traite en conséquence.
Travailler avec différentes sources de fichiers
Docling peut traiter aussi bien des fichiers locaux que des URL distantes :
from docling.document_converter import DocumentConverter
import requests
import tempfile
converter = DocumentConverter()
# Local file
result = converter.convert("/path/to/document.pdf")
# Remote URL - download first
url = "https://example.com/document.pdf"
response = requests.get(url)
with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp:
tmp.write(response.content)
tmp_path = tmp.name
result = converter.convert(tmp_path)
# Don't forget to clean up
import os
os.unlink(tmp_path)Quels formats sont pris en charge ?
Docling fonctionne nativement avec de nombreux formats de fichiers courants. Il gère les fichiers PDF, y compris les documents scannés grâce à la technologie OCR. Les formats Microsoft Office comme Word (.docx) et PowerPoint (.pptx) sont entièrement pris en charge, tout comme les formats web tels que HTML. Vous pouvez également traiter des fichiers Markdown, des documents en texte brut et même des fichiers image (.webp, .webp) grâce à ses capacités d'OCR intégrées.
Le DocumentConverter détecte automatiquement le format du fichier et applique la méthode de traitement appropriée, vous n'avez donc pas besoin de préciser le type de fichier manuellement.
Découper les documents en chunks
Pour de nombreuses applications d'IA, il est nécessaire de fragmenter les documents en petites portions (« chunks »). Le HybridChunker de Docling rend cette opération intelligente et simple.
Découpage de base
from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer
# Convert document
converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document
# Set up chunker with your tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
chunker = HybridChunker(
tokenizer=tokenizer,
max_tokens=512 # Maximum tokens per chunk
)
# Get chunks
chunks = list(chunker.chunk(document))
# Process chunks
for i, chunk in enumerate(chunks):
print(f"Chunk {i}: {chunk.text[:100]}...")Pourquoi utiliser HybridChunker ?
Le HybridChunker propose un découpage intelligent des documents, bien au-delà d'un simple comptage de caractères ou de mots. Il préserve les structures naturelles du document, comme les paragraphes et les sections, garantissant qu'aucun chunk ne se termine maladroitement en plein milieu d'une phrase. C'est particulièrement important pour préserver le sens sémantique de votre texte.
- Préserve les structures naturelles du document, comme les paragraphes et les sections
- Un découpage sensible aux tokens, qui respecte les limites du modèle d'embedding
- Des tailles de chunk configurables selon vos besoins spécifiques
- Conserve les métadonnées permettant de retracer l'origine de chaque chunk
Travailler avec les métadonnées
Docling extrait des métadonnées utiles des documents :
from docling.document_converter import DocumentConverter
converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document
# Access document metadata
if hasattr(document, 'meta'):
print(f"Document metadata: {document.meta}")
# Chunk with metadata
from docling.chunking import HybridChunker
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)
for chunk in chunker.chunk(document):
print(f"Text: {chunk.text[:50]}...")
if hasattr(chunk, 'meta'):
print(f"Metadata: {chunk.meta}")Assembler le tout
Voici un exemple complet qui traite un document et le prépare pour une utilisation dans une application d'IA :
from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer
def process_document(file_path, max_tokens=512):
"""Process a document and return chunks ready for embedding."""
# Step 1: Convert document
converter = DocumentConverter()
result = converter.convert(file_path)
document = result.document
# Step 2: Set up chunker
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
chunker = HybridChunker(
tokenizer=tokenizer,
max_tokens=max_tokens
)
# Step 3: Get chunks
chunks = []
for i, chunk in enumerate(chunker.chunk(document)):
chunks.append({
'text': chunk.text,
'index': i,
'source': file_path
})
return chunks
# Usage
chunks = process_document("my_document.pdf")
print(f"Created {len(chunks)} chunks")
for chunk in chunks:
print(f"Chunk {chunk['index']}: {chunk['text'][:50]}...")Conseils pratiques
Traiter plusieurs documents
import os
from pathlib import Path
def process_folder(folder_path, max_tokens=512):
"""Process all PDFs in a folder."""
all_chunks = []
for file_path in Path(folder_path).glob("*.pdf"):
try:
chunks = process_document(str(file_path), max_tokens)
all_chunks.extend(chunks)
print(f"Processed {file_path.name}: {len(chunks)} chunks")
except Exception as e:
print(f"Failed to process {file_path.name}: {e}")
return all_chunksEssayer HAQQ AI gratuitement
Découvrez la rédaction et la recherche juridique par IA
Exporter vers différents formats
Docling peut exporter les documents vers différents formats :
from docling.document_converter import DocumentConverter
converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document
# Export to markdown
markdown = document.export_to_markdown()
with open("output.md", "w", encoding="utf-8") as f:
f.write(markdown)
# Export to plain text
text = document.export_to_text()
with open("output.txt", "w", encoding="utf-8") as f:
f.write(text)Gérer les erreurs correctement
def safe_process_document(file_path):
"""Process document with error handling."""
try:
converter = DocumentConverter()
result = converter.convert(file_path)
return result.document
except FileNotFoundError:
print(f"File not found: {file_path}")
return None
except Exception as e:
print(f"Error processing {file_path}: {e}")
return NoneConstruire un système de recherche documentaire
L'un des cas d'usage les plus courants de Docling est la construction de systèmes de recherche documentaire pilotés par l'IA. En combinant le traitement documentaire de Docling avec des modèles d'embedding, vous pouvez créer de puissantes capacités de recherche sémantique.
from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer, AutoModel
import torch
# Process and embed documents
def build_document_index(file_paths):
converter = DocumentConverter()
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased")
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)
document_index = []
for file_path in file_paths:
# Convert and chunk
result = converter.convert(file_path)
chunks = list(chunker.chunk(result.document))
# Create embeddings for each chunk
for chunk in chunks:
inputs = tokenizer(chunk.text, return_tensors="pt",
truncation=True, max_length=512)
with torch.no_grad():
embedding = model(**inputs).last_hidden_state.mean(dim=1)
document_index.append({
'text': chunk.text,
'embedding': embedding,
'source': file_path
})
return document_indexConseils de performance
Choisir la bonne taille de chunk
Adaptez la taille de vos chunks à votre modèle d'embedding :
# For most sentence transformers (512 token limit)
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)
# For models with larger context windows
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=2048)Traiter les fichiers en parallèle
from concurrent.futures import ThreadPoolExecutor
def process_multiple_files(file_paths, max_workers=4):
with ThreadPoolExecutor(max_workers=max_workers) as executor:
results = list(executor.map(process_document, file_paths))
return resultsConclusion
Docling simplifie considérablement le traitement documentaire en proposant une API simple qui permet de convertir n'importe quel document en quelques lignes de code seulement. Son découpage intelligent fragmente les documents en portions cohérentes qui préservent le contexte et la structure, ce qui en fait un choix idéal pour les applications d'IA.
Que vous construisiez un système de recherche, un chatbot, un outil d'analyse documentaire ou toute autre application d'IA devant traiter des documents, Docling vous apporte la base nécessaire.
L'association d'une grande simplicité d'utilisation et de fonctionnalités puissantes en fait un excellent choix, aussi bien pour le prototypage que pour les applications en production. Avec sa prise en charge multi-format des PDF, documents Word, HTML et bien d'autres, ainsi que son OCR intégré pour les documents scannés, Docling absorbe la complexité du traitement documentaire à votre place.
Ressources
Vous trouverez le projet Docling sur GitHub, où sont disponibles le code source et une documentation complémentaire. Pour travailler avec les modèles de transformers et les tokenizers, consultez la documentation de Hugging Face Transformers. La documentation de Docling fournit des informations plus détaillées sur les fonctionnalités avancées et les options de configuration.
