Die Arbeit mit Dokumenten in unterschiedlichen Formaten ist eine häufige Herausforderung beim Aufbau von KI-Anwendungen. Ob PDFs, Word-Dokumente oder HTML-Dateien – sauberen, strukturierten Text daraus zu extrahieren, kann überraschend schwierig sein. Docling ist eine Python-Bibliothek, die diesen Prozess deutlich vereinfacht.
Dieser Leitfaden führt Sie durch die wichtigsten Grundlagen der Dokumentverarbeitung mit Docling – mit Fokus auf praktische Beispiele und Best Practices, die Sie sofort anwenden können.
Warum Docling?
Docling löst gängige Probleme der Dokumentverarbeitung auf einheitliche Weise. Die Bibliothek bietet Multi-Format-Unterstützung, die nahtlos mit PDFs, Word-Dokumenten, PowerPoint-Präsentationen, HTML und mehr funktioniert. Zudem enthält sie OCR-Funktionen, die Text selbst aus gescannten Dokumenten und Bildern extrahieren können, was sie vielseitig für unterschiedlichste Dokumenttypen macht.
Was Docling besonders auszeichnet, ist das intelligente Chunking: Dokumente werden in sinnvolle Abschnitte zerlegt, wobei der Kontext erhalten bleibt, statt Text willkürlich zu zerschneiden. Die Ausgabe ist sauber und strukturiert, egal ob Sie Markdown oder reinen Textformat benötigen. Und nicht zuletzt bietet Docling eine einfache, intuitive API, mit der auch Entwickler ohne Vorerfahrung in der Dokumentverarbeitung schnell loslegen können.
Erste Schritte
Installieren Sie zunächst Docling:
pip install doclingGrundlegende Verwendung
Ein Dokument konvertieren
Der einfachste Weg, Docling zu nutzen, ist über den 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)Das war's schon! Docling erkennt das Dateiformat automatisch und verarbeitet es entsprechend.
Mit unterschiedlichen Dateiquellen arbeiten
Docling kann sowohl lokale Dateien als auch entfernte URLs verarbeiten:
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)Welche Formate werden unterstützt?
Docling arbeitet von Haus aus mit vielen gängigen Dateiformaten. Es verarbeitet PDF-Dateien, einschließlich gescannter Dokumente mittels OCR-Technologie. Microsoft-Office-Formate wie Word (.docx) und PowerPoint (.pptx) werden vollständig unterstützt, ebenso Webformate wie HTML. Darüber hinaus können Sie Markdown-Dateien, reine Textdokumente und sogar Bilddateien (.webp, .webp) über die integrierten OCR-Funktionen verarbeiten.
Der DocumentConverter erkennt das Dateiformat automatisch und wendet die passende Verarbeitungsmethode an, sodass Sie den Typ nicht explizit angeben müssen.
Dokumente in Chunks aufteilen
Für viele KI-Anwendungen müssen Sie Dokumente in kleinere Teile („Chunks") aufteilen. Der HybridChunker von Docling macht das intelligent und einfach.
Grundlegendes Chunking
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]}...")Warum den HybridChunker verwenden?
Der HybridChunker bietet eine intelligente Dokumentaufteilung, die über eine einfache Zeichen- oder Wortzählung hinausgeht. Er bewahrt natürliche Dokumentstrukturen wie Absätze und Abschnitte und stellt sicher, dass Sie nie Chunks erhalten, die mitten im Satz unbeholfen abbrechen. Das ist besonders wichtig, um die semantische Bedeutung Ihres Textes zu erhalten.
- Bewahrt natürliche Dokumentstrukturen wie Absätze und Abschnitte
- Token-bewusstes Chunking, das die Grenzen des Embedding-Modells respektiert
- Konfigurierbare Chunk-Größen, angepasst an Ihre spezifischen Anforderungen
- Bewahrt Metadaten, die den Ursprung jedes Chunks nachverfolgen
Mit Metadaten arbeiten
Docling extrahiert nützliche Metadaten aus Dokumenten:
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}")Alles zusammenfügen
Hier ein vollständiges Beispiel, das ein Dokument verarbeitet und für den Einsatz in einer KI-Anwendung vorbereitet:
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]}...")Praktische Tipps
Mehrere Dokumente verarbeiten
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_chunksHAQQ AI kostenlos testen
Erleben Sie KI-gestützte juristische Recherche und Entwurf
In verschiedene Formate exportieren
Docling kann Dokumente in verschiedene Formate exportieren:
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)Fehler elegant behandeln
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 NoneEin Dokumentsuchsystem aufbauen
Einer der häufigsten Anwendungsfälle für Docling ist der Aufbau KI-gestützter Dokumentsuchsysteme. Durch die Kombination der Dokumentverarbeitung von Docling mit Embedding-Modellen lassen sich leistungsstarke semantische Suchfunktionen realisieren.
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_indexPerformance-Tipps
Die richtige Chunk-Größe wählen
Stimmen Sie Ihre Chunk-Größe auf Ihr Embedding-Modell ab:
# 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)Dateien parallel verarbeiten
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 resultsFazit
Docling vereinfacht die Dokumentverarbeitung durch eine schlichte API, mit der Sie jedes Dokument mit nur wenigen Zeilen Code konvertieren können. Die intelligenten Chunking-Funktionen zerlegen Dokumente in sinnvolle Abschnitte, die Kontext und Struktur bewahren, und machen die Bibliothek damit ideal für KI-Anwendungen.
Ob Sie ein Suchsystem, einen Chatbot, ein Dokumentanalyse-Tool oder eine andere KI-Anwendung bauen, die mit Dokumenten arbeiten muss – Docling liefert die Grundlage, die Sie brauchen.
Die Kombination aus einfacher Bedienung und leistungsstarken Funktionen macht die Bibliothek zu einer ausgezeichneten Wahl sowohl für Prototypen als auch für Produktionsanwendungen. Mit Multi-Format-Unterstützung für PDFs, Word-Dokumente, HTML und mehr sowie integriertem OCR für gescannte Dokumente übernimmt Docling die Komplexität der Dokumentverarbeitung, damit Sie es nicht müssen.
Ressourcen
Das Docling-Projekt finden Sie auf GitHub, wo Sie den Quellcode und weiterführende Dokumentation finden. Für die Arbeit mit Transformer-Modellen und Tokenizern lohnt sich ein Blick in die Dokumentation von Hugging Face Transformers. Die Docling-Dokumentation bietet weiterführende Informationen zu erweiterten Funktionen und Konfigurationsoptionen.
