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
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
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.
Aprendizajes de esta lección
- Comprender el uso y ventajas de TextLoader para cargar archivos de texto individuales con metadatos automáticos.
- Aprender a utilizar DirectoryLoader para cargar múltiples archivos de un directorio con filtros y configuraciones específicas.
- Conocer la configuración de encoding y su importancia en la carga de documentos.
- Entender el funcionamiento de PyPDFLoader para extraer texto y metadatos de documentos PDF por página.
- Aplicar loaders en casos prácticos para sistemas RAG, destacando la importancia de los metadatos para la trazabilidad de la información.
Completa LangChain y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs