Document loaders avanzados

TextLoader y DirectoryLoader

Los document loaders de LangChain automatizan el proceso de carga de documentos desde archivos, eliminando la necesidad de crear objetos Document manualmente. Estos loaders no solo cargan el contenido, sino que también generan automáticamente metadatos útiles como la fuente del archivo, que serán fundamentales para el sistema de retrieval.

TextLoader para archivos individuales

El TextLoader es el loader más básico y se utiliza para cargar archivos de texto plano. Su principal ventaja es la simplicidad y la generación automática de metadatos:

from langchain_community.document_loaders import TextLoader

# Cargar un archivo de texto individual
loader = TextLoader("documentos/manual_usuario.txt")
documents = loader.load()

print(f"Documentos cargados: {len(documents)}")
print(f"Contenido: {documents[0].page_content[:200]}...")
print(f"Metadatos: {documents[0].metadata}")

El TextLoader genera automáticamente metadatos que incluyen la ruta del archivo como fuente. Esto es especialmente útil cuando necesitas rastrear de dónde proviene cada fragmento de información en tu sistema RAG:

# Ejemplo con archivo de políticas de empresa
loader = TextLoader("politicas/politica_vacaciones.txt")
documents = loader.load()

# Los metadatos incluyen automáticamente la fuente
for doc in documents:
    print(f"Fuente: {doc.metadata['source']}")
    print(f"Primeras líneas: {doc.page_content[:150]}...")

Configuración de encoding

Uno de los aspectos importantes del TextLoader es la gestión del encoding, especialmente cuando trabajas con archivos que contienen caracteres especiales:

# Especificar encoding explícitamente
loader = TextLoader(
    "documentos/texto_espanol.txt",
    encoding="utf-8"
)
documents = loader.load()

# Para archivos con encoding automático
loader = TextLoader(
    "documentos/archivo_mixto.txt",
    autodetect_encoding=True
)
documents = loader.load()

DirectoryLoader para múltiples archivos

El DirectoryLoader permite cargar múltiples archivos de un directorio de forma eficiente. Es especialmente útil cuando tienes una colección de documentos que necesitas procesar en lote:

from langchain_community.document_loaders import DirectoryLoader

# Cargar todos los archivos .txt de un directorio
loader = DirectoryLoader(
    "documentos/",
    glob="*.txt",
    loader_cls=TextLoader
)
documents = loader.load()

print(f"Total de documentos cargados: {len(documents)}")
for doc in documents:
    print(f"Archivo: {doc.metadata['source']}")

Filtrado y patrones específicos

El DirectoryLoader ofrece flexibilidad para cargar solo los archivos que necesitas mediante patrones glob:

# Cargar solo archivos con patrón específico
loader = DirectoryLoader(
    "manuales/",
    glob="manual_*.txt",
    loader_cls=TextLoader
)
documents = loader.load()

# Cargar múltiples tipos de archivo
loader = DirectoryLoader(
    "documentos/",
    glob="**/*.{txt,md}",  # Archivos .txt y .md en subdirectorios
    loader_cls=TextLoader,
    recursive=True
)
documents = loader.load()

Procesamiento con configuraciones específicas

Puedes pasar argumentos específicos al loader subyacente a través del DirectoryLoader:

# Configurar encoding para todos los archivos
loader = DirectoryLoader(
    "documentos/",
    glob="*.txt",
    loader_cls=TextLoader,
    loader_kwargs={"encoding": "utf-8", "autodetect_encoding": True}
)
documents = loader.load()

# Verificar que todos los documentos tienen metadatos correctos
for doc in documents:
    print(f"Fuente: {doc.metadata['source']}")
    print(f"Tamaño del contenido: {len(doc.page_content)} caracteres")

Ejemplo práctico: Sistema de documentación

Un caso de uso común es cargar toda la documentación de un proyecto para crear un sistema de consulta:

from langchain_community.document_loaders import DirectoryLoader, TextLoader

# Cargar toda la documentación del proyecto
def cargar_documentacion(ruta_docs):
    loader = DirectoryLoader(
        ruta_docs,
        glob="**/*.{txt,md}",
        loader_cls=TextLoader,
        loader_kwargs={"encoding": "utf-8"},
        recursive=True
    )
    
    documents = loader.load()
    
    # Mostrar estadísticas de carga
    print(f"Documentos cargados: {len(documents)}")
    
    archivos_unicos = set(doc.metadata['source'] for doc in documents)
    print(f"Archivos únicos: {len(archivos_unicos)}")
    
    return documents

# Usar la función
docs = cargar_documentacion("proyecto/docs/")

# Los metadatos permiten identificar el origen de cada documento
for doc in docs[:3]:  # Mostrar solo los primeros 3
    nombre_archivo = doc.metadata['source'].split('/')[-1]
    print(f"Archivo: {nombre_archivo}")
    print(f"Contenido: {doc.page_content[:100]}...")
    print("---")

Los metadatos generados automáticamente por estos loaders son fundamentales para el funcionamiento del sistema RAG, ya que permiten al usuario final saber exactamente de qué archivo proviene cada respuesta. Esta información de procedencia será especialmente valiosa cuando implementes el retrieval y necesites mostrar las fuentes de las respuestas generadas.

PyPDFLoader para PDFs

Los archivos PDF representan uno de los formatos más comunes en aplicaciones empresariales y académicas. El PyPDFLoader de LangChain está específicamente diseñado para extraer texto de documentos PDF y generar metadatos enriquecidos que incluyen información sobre páginas individuales.

Instalación y configuración básica

Antes de utilizar PyPDFLoader, necesitas instalar la dependencia correspondiente:

pip install langchain-community pypdf

Una vez instalado, puedes cargar documentos PDF de forma directa:

from langchain_community.document_loaders import PyPDFLoader

# Cargar un documento PDF
loader = PyPDFLoader("informes/reporte_anual.pdf")
documents = loader.load()

print(f"Páginas extraídas: {len(documents)}")
print(f"Primera página: {documents[0].page_content[:200]}...")
print(f"Metadatos: {documents[0].metadata}")

Ejemplo:

Metadatos enriquecidos por página

La característica más valiosa del PyPDFLoader es que divide automáticamente el PDF en documentos individuales por página, generando metadatos específicos para cada una:

# Cargar manual técnico en PDF
loader = PyPDFLoader("manuales/manual_tecnico.pdf")
pages = loader.load()

# Examinar metadatos de cada página
for i, page in enumerate(pages[:3]):  # Primeras 3 páginas
    print(f"Página {i+1}:")
    print(f"  Fuente: {page.metadata['source']}")
    print(f"  Número de página: {page.metadata['page']}")
    print(f"  Contenido: {page.page_content[:150]}...")
    print("---")

Procesamiento de documentos extensos

Los PDFs empresariales suelen ser extensos, y el PyPDFLoader facilita el manejo eficiente de estos documentos:

# Cargar documento extenso
loader = PyPDFLoader("documentos/politicas_empresa.pdf")
pages = loader.load()

# Analizar distribución de contenido
total_caracteres = sum(len(page.page_content) for page in pages)
print(f"Total de páginas: {len(pages)}")
print(f"Total de caracteres: {total_caracteres}")

# Encontrar páginas con contenido específico
paginas_relevantes = []
termino_busqueda = "política de vacaciones"

for page in pages:
    if termino_busqueda.lower() in page.page_content.lower():
        paginas_relevantes.append({
            'pagina': page.metadata['page'],
            'contenido': page.page_content[:200]
        })

print(f"Páginas que contienen '{termino_busqueda}': {len(paginas_relevantes)}")

Manejo de PDFs con diferentes estructuras

Los PDFs pueden tener estructuras complejas con tablas, columnas múltiples o elementos gráficos. El PyPDFLoader extrae el texto disponible manteniendo la información de página:

# Cargar informe con tablas y gráficos
loader = PyPDFLoader("informes/informe_financiero.pdf")
pages = loader.load()

# Filtrar páginas con contenido sustancial
paginas_contenido = []
for page in pages:
    # Filtrar páginas con poco texto (posiblemente solo gráficos)
    if len(page.page_content.strip()) > 100:
        paginas_contenido.append(page)

print(f"Páginas con contenido textual: {len(paginas_contenido)}")

# Mostrar estadísticas por página
for page in paginas_contenido[:5]:
    palabras = len(page.page_content.split())
    print(f"Página {page.metadata['page']}: {palabras} palabras")

Integración con sistemas RAG

Los metadatos de página son especialmente útiles para sistemas RAG donde necesitas proporcionar referencias precisas:

from langchain_community.document_loaders import PyPDFLoader

def procesar_manual_usuario(ruta_pdf):
    """
    Procesa un manual de usuario en PDF para sistema RAG
    """
    loader = PyPDFLoader(ruta_pdf)
    pages = loader.load()
    
    # Enriquecer metadatos con información adicional
    for page in pages:
        page.metadata['tipo_documento'] = 'manual_usuario'
        page.metadata['seccion'] = f"Página {page.metadata['page']}"
        
        # Detectar si es página de índice o contenido
        contenido_lower = page.page_content.lower()
        if 'índice' in contenido_lower or 'tabla de contenidos' in contenido_lower:
            page.metadata['tipo_pagina'] = 'indice'
        elif len(page.page_content.strip()) < 50:
            page.metadata['tipo_pagina'] = 'separador'
        else:
            page.metadata['tipo_pagina'] = 'contenido'
    
    return pages

# Procesar manual
manual_pages = procesar_manual_usuario("manuales/manual_software.pdf")

# Filtrar solo páginas de contenido
contenido_util = [
    page for page in manual_pages 
    if page.metadata['tipo_pagina'] == 'contenido'
]

print(f"Páginas de contenido útil: {len(contenido_util)}")

# Ejemplo de metadatos enriquecidos
for page in contenido_util[:2]:
    print(f"Página {page.metadata['page']} ({page.metadata['tipo_pagina']}):")
    print(f"  Fuente: {page.metadata['source']}")
    print(f"  Sección: {page.metadata['seccion']}")
    print(f"  Contenido: {page.page_content[:150]}...")
    print("---")

Casos de uso empresariales

El PyPDFLoader es especialmente valioso en escenarios empresariales donde los PDFs contienen información crítica:

# Sistema para procesar contratos legales
def analizar_contratos(directorio_contratos):
    import os
    from pathlib import Path
    
    contratos_procesados = []
    
    # Buscar todos los PDFs en el directorio
    for archivo in Path(directorio_contratos).glob("*.pdf"):
        loader = PyPDFLoader(str(archivo))
        pages = loader.load()
        
        # Agregar metadatos específicos del contrato
        nombre_contrato = archivo.stem
        for page in pages:
            page.metadata['contrato'] = nombre_contrato
            page.metadata['tipo_documento'] = 'contrato_legal'
        
        contratos_procesados.extend(pages)
    
    return contratos_procesados

# Procesar contratos
# contratos = analizar_contratos("contratos/")

# Buscar cláusulas específicas
def buscar_clausulas(pages, termino):
    resultados = []
    for page in pages:
        if termino.lower() in page.page_content.lower():
            resultados.append({
                'contrato': page.metadata['contrato'],
                'pagina': page.metadata['page'],
                'contexto': page.page_content[:300]
            })
    return resultados

# Ejemplo de búsqueda
# clausulas_rescision = buscar_clausulas(contratos, "rescisión")

La granularidad por página que proporciona PyPDFLoader es fundamental para crear sistemas RAG precisos, ya que permite a los usuarios obtener referencias exactas sobre dónde se encuentra la información en el documento original. Esta característica será especialmente importante cuando combines estos documentos con técnicas de chunking en la siguiente lección.