Lavorare con documenti in formati diversi è una sfida comune nello sviluppo di applicazioni di intelligenza artificiale. Che si tratti di elaborare PDF, documenti Word o file HTML, estrarre testo pulito e strutturato può rivelarsi sorprendentemente difficile. Docling è una libreria Python che rende questo processo semplice.
Questa guida illustra gli elementi essenziali per usare Docling nell'elaborazione dei documenti, con particolare attenzione a esempi pratici e best practice applicabili da subito.
Perché Docling?
Docling risolve in modo unificato i problemi più comuni dell'elaborazione documentale. Offre un supporto multi-formato che funziona senza soluzione di continuità con PDF, documenti Word, presentazioni PowerPoint, HTML e altro ancora. La libreria include funzionalità OCR in grado di estrarre testo anche da documenti scansionati e immagini, rendendola versatile per diversi tipi di documento.
Ciò che distingue Docling è la funzione di chunking intelligente, che suddivide i documenti in segmenti significativi preservando il contesto, invece di spezzare il testo in modo arbitrario. L'output è pulito e strutturato, sia che si abbia bisogno del formato markdown sia del testo semplice. Infine, Docling offre un'API semplice e intuitiva, facile da usare anche per gli sviluppatori alle prime armi con l'elaborazione documentale.
Per iniziare
Per prima cosa, installa Docling:
pip install doclingUtilizzo di base
Convertire un documento
Il modo più semplice di usare Docling è tramite il 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)Tutto qui! Docling rileva automaticamente il formato del file e lo elabora di conseguenza.
Lavorare con fonti di file diverse
Docling può elaborare sia file locali sia URL remoti:
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)Quali formati sono supportati?
Docling funziona pronto all'uso con molti formati di file comuni. Gestisce file PDF, inclusi i documenti scansionati tramite tecnologia OCR. I formati Microsoft Office come Word (.docx) e PowerPoint (.pptx) sono pienamente supportati, così come formati web come l'HTML. È inoltre possibile elaborare file Markdown, documenti in testo semplice e persino file immagine (.webp, .webp) grazie alle funzionalità OCR integrate.
Il DocumentConverter rileva automaticamente il formato del file e applica il metodo di elaborazione appropriato, quindi non è necessario preoccuparsi di specificare esplicitamente il tipo.
Suddivisione dei documenti in chunk
Per molte applicazioni di intelligenza artificiale è necessario suddividere i documenti in porzioni più piccole (i cosiddetti "chunk"). L'HybridChunker di Docling rende questa operazione intelligente e semplice.
Chunking di 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]}...")Perché usare HybridChunker?
L'HybridChunker offre una suddivisione intelligente dei documenti che va oltre il semplice conteggio di caratteri o parole. Preserva le strutture naturali del documento, come paragrafi e sezioni, garantendo che nessun chunk venga interrotto in modo maldestro a metà frase. Questo aspetto è particolarmente importante per mantenere il significato semantico del testo.
- Preserva le strutture naturali del documento, come paragrafi e sezioni
- Chunking consapevole dei token, che rispetta i limiti del modello di embedding
- Dimensioni dei chunk configurabili in base alle esigenze specifiche
- Preserva i metadati che tracciano l'origine di ciascun chunk
Lavorare con i metadati
Docling estrae metadati utili dai documenti:
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}")Mettere tutto insieme
Ecco un esempio completo che elabora un documento e lo prepara per l'uso in un'applicazione di intelligenza artificiale:
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]}...")Consigli pratici
Elaborare più documenti
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_chunksProva HAQQ AI gratis
Sperimenta la redazione e ricerca legale con IA
Esportare in formati diversi
Docling può esportare i documenti in vari formati:
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)Gestire gli errori in modo controllato
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 NoneCostruire un sistema di ricerca documentale
Uno dei casi d'uso più comuni per Docling è la costruzione di sistemi di ricerca documentale basati sull'intelligenza artificiale. Combinando l'elaborazione documentale di Docling con i modelli di embedding, è possibile creare potenti funzionalità di ricerca semantica.
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_indexConsigli sulle prestazioni
Scegliere la dimensione corretta dei chunk
Adatta la dimensione dei chunk al tuo modello di 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)Elaborare i file in parallelo
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 resultsConclusione
Docling semplifica l'elaborazione documentale offrendo un'API semplice che consente di convertire qualsiasi documento con poche righe di codice. Le sue funzionalità di chunking intelligente suddividono i documenti in segmenti significativi che preservano contesto e struttura, rendendolo ideale per le applicazioni di intelligenza artificiale.
Che tu stia costruendo un sistema di ricerca, un chatbot, uno strumento di analisi documentale o qualsiasi applicazione di intelligenza artificiale che debba lavorare con i documenti, Docling fornisce le fondamenta di cui hai bisogno.
La combinazione di facilità d'uso e funzionalità avanzate rende questa libreria una scelta eccellente sia per la prototipazione sia per le applicazioni in produzione. Con il supporto multi-formato per PDF, documenti Word, HTML e altro ancora, oltre all'OCR integrato per i documenti scansionati, Docling gestisce la complessità dell'elaborazione documentale al posto tuo.
Risorse
Puoi trovare il progetto Docling su GitHub, dove sono disponibili il codice sorgente e documentazione aggiuntiva. Per lavorare con modelli transformer e tokenizer, consulta la documentazione di Hugging Face Transformers. La documentazione di Docling fornisce informazioni più dettagliate sulle funzionalità avanzate e sulle opzioni di configurazione.
