Trabajar con documentos en distintos formatos es un desafío habitual al construir aplicaciones de IA. Ya sea que estés procesando PDFs, documentos de Word o archivos HTML, extraer texto limpio y estructurado puede resultar sorprendentemente difícil. Docling es una librería de Python que simplifica este proceso.
Esta guía te lleva a través de los fundamentos del uso de Docling para procesar documentos, con foco en ejemplos prácticos y buenas prácticas que puedes aplicar de inmediato.
¿Por qué Docling?
Docling resuelve problemas habituales del procesamiento de documentos de forma unificada. Ofrece soporte multiformato que funciona sin fricciones con PDFs, documentos de Word, presentaciones de PowerPoint, HTML y más. La librería incluye capacidades de OCR que permiten extraer texto incluso de documentos escaneados e imágenes, lo que la hace versátil para distintos tipos de documentos.
Lo que distingue a Docling es su función de fragmentación inteligente ("chunking"), que divide los documentos en piezas con sentido preservando el contexto, en lugar de cortar el texto de forma arbitraria. El resultado es limpio y estructurado, ya sea que necesites formato markdown o texto plano. Y, sobre todo, Docling ofrece una API sencilla e intuitiva, fácil de empezar a usar incluso para desarrolladores nuevos en el procesamiento de documentos.
Primeros pasos
Primero, instala Docling:
pip install doclingUso básico
Convertir un documento
La forma más simple de usar Docling es con el 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)¡Eso es todo! Docling detecta automáticamente el formato del archivo y lo procesa en consecuencia.
Trabajar con distintas fuentes de archivos
Docling puede procesar tanto archivos locales como URLs remotas:
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)¿Qué formatos son compatibles?
Docling funciona con muchos formatos de archivo comunes desde el primer momento. Maneja archivos PDF, incluidos documentos escaneados mediante tecnología OCR. Los formatos de Microsoft Office como Word (.docx) y PowerPoint (.pptx) son totalmente compatibles, al igual que formatos web como HTML. También puedes procesar archivos Markdown, documentos de texto plano e incluso archivos de imagen (.webp, .webp) usando sus capacidades de OCR integradas.
El DocumentConverter detecta automáticamente el formato del archivo y aplica el método de procesamiento adecuado, así que no necesitas preocuparte por especificar el tipo de forma explícita.
Fragmentar documentos
En muchas aplicaciones de IA necesitas dividir los documentos en piezas más pequeñas ("chunks"). El HybridChunker de Docling hace que esto sea inteligente y sencillo.
Fragmentación básica
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]}...")¿Por qué usar HybridChunker?
HybridChunker ofrece una división inteligente de documentos que va más allá del simple conteo de caracteres o palabras. Preserva las estructuras naturales del documento, como párrafos y secciones, garantizando que nunca obtengas fragmentos cortados torpemente a mitad de una oración. Esto es especialmente importante para mantener el significado semántico de tu texto.
- Preserva las estructuras naturales del documento, como párrafos y secciones
- Fragmentación consciente de tokens que respeta los límites del modelo de embeddings
- Tamaños de fragmento configurables según tus necesidades específicas
- Conserva metadatos que rastrean el origen de cada fragmento
Trabajar con metadatos
Docling extrae metadatos útiles de los documentos:
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}")Uniendo todo
Aquí tienes un ejemplo completo que procesa un documento y lo prepara para usarlo en una aplicación de 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]}...")Consejos prácticos
Procesar múltiples documentos
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_chunksPrueba HAQQ AI gratis
Experimenta la redacción e investigación legal con IA
Exportar a distintos formatos
Docling puede exportar documentos a varios formatos:
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)Manejar errores con elegancia
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 NoneConstruir un sistema de búsqueda de documentos
Uno de los casos de uso más comunes de Docling es construir sistemas de búsqueda de documentos potenciados por IA. Al combinar el procesamiento de documentos de Docling con modelos de embeddings, puedes crear potentes capacidades de búsqueda semántica.
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_indexConsejos de rendimiento
Elige el tamaño de fragmento adecuado
Ajusta el tamaño de fragmento a tu modelo de embeddings:
# 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)Procesar archivos en paralelo
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 resultsConclusión
Docling simplifica el procesamiento de documentos al ofrecer una API sencilla que te permite convertir cualquier documento con apenas unas líneas de código. Sus capacidades de fragmentación inteligente dividen los documentos en piezas con sentido que preservan el contexto y la estructura, lo que la hace ideal para aplicaciones de IA.
Ya sea que estés construyendo un sistema de búsqueda, un chatbot, una herramienta de análisis de documentos o cualquier aplicación de IA que necesite trabajar con documentos, Docling te ofrece la base que necesitas.
La combinación de facilidad de uso y funciones potentes de la librería la convierte en una excelente opción tanto para prototipos como para aplicaciones en producción. Con soporte multiformato para PDFs, documentos de Word, HTML y más, además de OCR integrado para documentos escaneados, Docling se encarga de la complejidad del procesamiento de documentos para que tú no tengas que hacerlo.
Recursos
Puedes encontrar el proyecto Docling en GitHub, donde hallarás el código fuente y documentación adicional. Para trabajar con modelos y tokenizadores de transformers, consulta la documentación de Hugging Face Transformers. La documentación de Docling ofrece información más detallada sobre funciones avanzadas y opciones de configuración.
