Image for post Procesamiento de PDFs para IA: Extracción, Chunking y Preparación de Datos con Python y LangChain

Procesamiento de PDFs para IA: Extracción, Chunking y Preparación de Datos con Python y LangChain

Escrito por Sergio Márquez

En el mundo de la Inteligencia Artificial, la información es el activo más valioso. Sin embargo, gran parte de esta información crítica reside en documentos PDF, un formato que, si bien es excelente para la presentación visual, presenta desafíos significativos para el procesamiento automatizado por parte de modelos de lenguaje grandes (LLMs). ¿Cómo podemos hacer que nuestros LLMs 'lean' y comprendan estos documentos de manera efectiva? La clave está en la extracción, el 'chunking' (división en fragmentos) y la preparación adecuada de los datos.

Este artículo te guiará paso a paso a través del proceso de transformar PDFs complejos en datos estructurados y manejables, listos para ser utilizados en aplicaciones de IA, como sistemas de Preguntas y Respuestas (Q&A) o Generación Aumentada por Recuperación (RAG), utilizando Python y el framework LangChain.

Contexto del Problema: PDFs y LLMs

Imagina que tienes un repositorio de informes técnicos, manuales de usuario o contratos legales, todos en formato PDF. Tu objetivo es construir un sistema de IA que pueda responder preguntas sobre el contenido de estos documentos. El problema es que los LLMs no pueden simplemente 'leer' un PDF como lo haríamos nosotros. Necesitan el texto en un formato que puedan procesar, y ese texto debe estar dividido en fragmentos (chunks) que se ajusten a sus ventanas de contexto limitadas.

Un PDF puede contener texto, imágenes, tablas y diferentes estructuras de diseño. Extraer el texto de forma coherente y luego dividirlo en partes significativas es un paso crucial. Si los chunks son demasiado grandes, el LLM puede perder el foco o exceder su límite de tokens. Si son demasiado pequeños, se pierde el contexto vital.

Conceptos Clave

Para abordar este desafío, LangChain nos proporciona herramientas poderosas:

  • Document Loaders: Son componentes que nos permiten cargar datos de diversas fuentes, como PDFs, archivos de texto, bases de datos, etc., y convertirlos en objetos Document de LangChain. Un Document es una estructura simple que contiene el contenido del texto (page_content) y metadatos asociados (metadata).
  • Text Splitters (Chunking): Una vez que tenemos el texto cargado, los text splitters se encargan de dividirlo en fragmentos más pequeños y manejables. La estrategia de división es fundamental para mantener la coherencia semántica y asegurar que cada chunk contenga suficiente contexto para ser útil.
  • Metadatos: Información adicional asociada a cada documento o chunk, como el número de página, la fuente original, el título, etc. Los metadatos son cruciales para contextualizar la información y mejorar la recuperación.

Implementación Paso a Paso

Vamos a construir un script Python que cargue un PDF, extraiga su texto y lo divida en chunks adecuados para una aplicación de IA.

Paso 1: Configuración del Entorno

Primero, necesitamos instalar las librerías necesarias. Usaremos langchain-community para los loaders, langchain-text-splitters para los splitters, pypdf para el procesamiento de PDFs y tiktoken para un conteo de tokens más preciso (aunque len también funciona para conteo de caracteres).

pip install langchain-community pypdf langchain-text-splitters tiktoken

Paso 2: Carga del Documento PDF

Utilizaremos PyPDFLoader de LangChain para cargar nuestro archivo PDF. Este loader leerá el PDF y lo convertirá en una lista de objetos Document, donde cada página del PDF será un Document.

import os
from langchain_community.document_loaders import PyPDFLoader

# Reemplaza 'ruta/a/tu/documento.pdf' con la ruta real de tu archivo PDF
pdf_path = "./ejemplo.pdf" 

# Asegúrate de que el archivo PDF exista en la ruta especificada
if not os.path.exists(pdf_path):
    print(f"Error: El archivo PDF no se encontró en '{pdf_path}'. Por favor, verifica la ruta.")
    # Puedes crear un PDF de prueba o descargar uno para este ejemplo
    # Por ejemplo, un PDF sencillo con varias páginas de texto.
    # Para este tutorial, asumiremos que tienes un PDF llamado 'ejemplo.pdf' en la misma carpeta.
else:
    loader = PyPDFLoader(pdf_path)
    documents = loader.load()
    print(f"Documento cargado. Total de páginas: {len(documents)}")
    # Opcional: Imprimir el contenido de la primera página para verificar
    # if documents:
    #     print("\n--- Contenido de la primera página ---")
    #     print(documents[0].page_content[:500]) # Imprime los primeros 500 caracteres
    #     print("\n--- Metadatos de la primera página ---")
    #     print(documents[0].metadata)

Paso 3: Estrategias de Chunking con RecursiveCharacterTextSplitter

Una vez que tenemos los documentos cargados, el siguiente paso es dividirlos en chunks. RecursiveCharacterTextSplitter es el splitter recomendado para texto genérico, ya que intenta dividir el texto de forma inteligente utilizando una lista de separadores (como saltos de párrafo, saltos de línea, espacios) para mantener la coherencia semántica.

Los parámetros clave son chunk_size (el tamaño máximo de cada fragmento) y chunk_overlap (la cantidad de caracteres que se superponen entre chunks adyacentes para preservar el contexto).

from langchain.text_splitter import RecursiveCharacterTextSplitter
import tiktoken # Para un conteo de tokens más preciso

if 'documents' in locals() and documents: # Asegurarse de que los documentos se cargaron
    # Inicializamos el splitter
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000, # Tamaño máximo de cada chunk en caracteres
        chunk_overlap=200, # Caracteres de superposición entre chunks
        length_function=len, # Función para medir la longitud del chunk (len para caracteres, tiktoken para tokens)
        add_start_index=True, # Añade el índice de inicio del chunk en el documento original
    )

    # Si prefieres contar por tokens (más preciso para LLMs):
    # tokenizer = tiktoken.encoding_for_model("gpt-3.5-turbo")
    # text_splitter = RecursiveCharacterTextSplitter(
    #     chunk_size=1000, # Tamaño máximo de cada chunk en tokens
    #     chunk_overlap=200, # Tokens de superposición
    #     length_function=lambda text: len(tokenizer.encode(text)),
    #     add_start_index=True,
    # )

    chunks = text_splitter.split_documents(documents)

    print(f"\nTotal de chunks generados: {len(chunks)}")

    # Imprimir los primeros 5 chunks para inspección
    for i, chunk in enumerate(chunks[:5]):
        print(f"\n--- Chunk {i+1} ---")
        print(f"Página: {chunk.metadata.get('page', 'N/A') + 1}") # +1 porque las páginas suelen ser base 0
        print(f"Fuente: {chunk.metadata.get('source', 'N/A')}")
        print(f"Contenido (primeros 300 chars):\n{chunk.page_content[:300]}...")
        print(f"Longitud del chunk: {len(chunk.page_content)} caracteres")
else:
    print("No se pudieron generar chunks porque no se cargaron documentos.")

Paso 4: Manejo de Metadatos

Como puedes ver en la salida del código anterior, cada Document (y por lo tanto cada chunk) viene con metadatos. PyPDFLoader añade automáticamente la página de origen (page) y la ruta del archivo (source). Estos metadatos son increíblemente útiles para:

  • Atribución: Saber de qué parte del documento original proviene la información.
  • Filtrado: En un sistema RAG, puedes filtrar chunks por página, autor o cualquier otro metadato relevante antes de pasarlos al LLM.

Mini Proyecto: Procesador de PDFs para RAG

Vamos a consolidar lo aprendido en un script que procesa un PDF y guarda sus chunks en un archivo de texto, simulando la preparación para una base de datos vectorial.

import os
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import tiktoken # Opcional, para conteo de tokens

def process_pdf_for_rag(pdf_path: str, output_dir: str = "./chunks_output"):
    """
    Carga un PDF, lo divide en chunks y guarda cada chunk en un archivo de texto.
    """
    if not os.path.exists(pdf_path):
        print(f"Error: El archivo PDF no se encontró en '{pdf_path}'.")
        return

    os.makedirs(output_dir, exist_ok=True)
    print(f"Procesando PDF: {pdf_path}")

    # 1. Cargar el documento PDF
    loader = PyPDFLoader(pdf_path)
    documents = loader.load()
    print(f"Total de páginas cargadas: {len(documents)}")

    # 2. Inicializar el Text Splitter
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000, # Ajusta según tus necesidades
        chunk_overlap=200, # Ajusta según tus necesidades
        length_function=len, # len para caracteres, o función tiktoken para tokens
        add_start_index=True,
    )

    # 3. Dividir los documentos en chunks
    chunks = text_splitter.split_documents(documents)
    print(f"Total de chunks generados: {len(chunks)}")

    # 4. Guardar cada chunk en un archivo separado
    pdf_filename = os.path.basename(pdf_path).replace(".pdf", "")
    for i, chunk in enumerate(chunks):
        chunk_filename = os.path.join(output_dir, f"{pdf_filename}_chunk_{i+1}.txt")
        with open(chunk_filename, "w", encoding="utf-8") as f:
            f.write(f"--- Chunk {i+1} ---\n")
            f.write(f"Página: {chunk.metadata.get('page', 'N/A') + 1}\n")
            f.write(f"Fuente: {chunk.metadata.get('source', 'N/A')}\n")
            f.write(f"Contenido:\n{chunk.page_content}\n")
        print(f"Guardado: {chunk_filename}")

    print(f"\nProcesamiento completado. Chunks guardados en '{output_dir}'.")

# --- Ejemplo de uso ---
# Crea un archivo PDF de prueba llamado 'mi_documento.pdf' en la misma carpeta
# o ajusta la ruta a un PDF existente.
# Puedes usar un generador de PDF online o un documento de texto guardado como PDF.
# Por ejemplo, un PDF con varias páginas de texto.

# Ruta al PDF de ejemplo
example_pdf_path = "./mi_documento.pdf"

# Llama a la función para procesar el PDF
# process_pdf_for_rag(example_pdf_path)

# Para ejecutar, descomenta la línea anterior y asegúrate de tener 'mi_documento.pdf'
# en la misma carpeta o ajusta la ruta.

Errores Comunes y Depuración

  • PDFs Escaneados o Protegidos: PyPDFLoader (y pypdf) puede tener dificultades con PDFs que son imágenes (escaneados) o que tienen restricciones de seguridad. Para PDFs escaneados, necesitarías una solución de OCR (Reconocimiento Óptico de Caracteres) como UnstructuredFileLoader (que integra OCR) o preprocesar el PDF con una herramienta de OCR.
  • Problemas de Codificación: Al guardar o leer archivos de texto, asegúrate de usar la codificación correcta (generalmente utf-8) para evitar caracteres extraños.
  • chunk_size y chunk_overlap Incorrectos: Elegir los valores óptimos para estos parámetros es un arte y depende del tipo de documento y del LLM que usarás. Experimenta. Un chunk_size muy pequeño puede romper el contexto, mientras que uno muy grande puede exceder la ventana de contexto del LLM o hacer que la recuperación sea menos precisa.
  • Dependencias Faltantes: Asegúrate de que todas las librerías estén instaladas correctamente.
  • Fallo de Extracción de Contenido: PDFs con formato incorrecto o errores de renderizado pueden causar fallos en la extracción.

Aprendizaje Futuro

Este es solo el primer paso en el procesamiento de documentos para IA. Aquí hay algunas ideas para llevar tu conocimiento al siguiente nivel:

  • Integración con Bases de Datos Vectoriales: Una vez que tienes los chunks, el siguiente paso natural es generar embeddings para ellos y almacenarlos en una base de datos vectorial (como Chroma, Pinecone, Qdrant o FAISS) para realizar búsquedas semánticas eficientes.
  • Construcción de un Sistema RAG Completo: Combina la extracción y el chunking con una base de datos vectorial y un LLM para construir un sistema de Preguntas y Respuestas que pueda consultar tus propios documentos.
  • Estrategias de Chunking Avanzadas: Explora técnicas como el chunking semántico o el chunking basado en la estructura del documento para mejorar aún más la calidad de tus fragmentos.
  • Procesamiento de Otros Tipos de Documentos: LangChain ofrece loaders para muchos otros formatos (Markdown, HTML, CSV, etc.). Aplica los mismos principios a diferentes fuentes de datos.
  • Extracción de Información Estructurada: Utiliza LLMs para extraer entidades o datos específicos en formato JSON de tus chunks, lo cual es útil para análisis más profundos.

Dominar el procesamiento de PDFs es una habilidad esencial para cualquier desarrollador de IA que trabaje con datos del mundo real. Con LangChain y Python, tienes las herramientas para convertir documentos estáticos en fuentes dinámicas de conocimiento para tus aplicaciones inteligentes.

Volver al blog