Empieza con los Document Loaders de LangChain: Guía paso a paso (Actualización 2025)

Name

Akira Sakamoto

Updated on 15/11/2025

LangChain ha evolucionado rápidamente desde 2023. Si estás explorando Retrieval-Augmented Generation (RAG), construyendo aplicaciones conversacionales o integrando conocimiento externo en pipelines de LLM, los Document Loaders se han convertido en uno de los componentes más importantes.

Esta guía te ofrece una comprensión clara, precisa y moderna de cómo funcionan los LangChain Document Loaders (versión 2025), cómo utilizarlos correctamente y cómo construir aplicaciones reales sobre ellos.

¿Qué es LangChain?

LangChain es un framework diseñado para ayudar a desarrolladores a crear aplicaciones potenciadas por LLM utilizando herramientas como:

• Document Loaders
• Text Splitters
• Vector Stores
• Retrievers
• Runnables y LCEL (LangChain Expression Language)

En el LangChain moderno (0.1–0.2+), el pipeline para construir aplicaciones luce así:

Load → Split → Embed → Store → Retrieve → Generate

Los Document Loaders se encargan del primer paso:
obtener contenido del mundo real y convertirlo en objetos “Document” amigables para el LLM.

¿Qué son los LangChain Document Loaders?

Un Document de LangChain tiene dos campos:

{
  "page_content": "<raw text>",
  "metadata": {...}
}

Los Document Loaders convierten fuentes externas (archivos, URLs, APIs, PDFs, CSV, transcripciones de YouTube) en una lista de objetos Document.

Ejemplo: Cargar un archivo .txt

from langchain_community.document_loaders import TextLoader
 
loader = TextLoader("./data/sample.txt")
docs = loader.load()

Resultado:

{
    "page_content": "Welcome to LangChain!",
    "metadata": { "source": "./data/sample.txt" }
}

Tipos de Document Loaders en LangChain

LangChain ofrece docenas de loaders, pero se agrupan en tres categorías principales.

1. Transform Loaders (formatos de archivo locales)

Cargan archivos estructurados o no estructurados:

Ejemplo con CSV (import moderno)

from langchain_community.document_loaders import CSVLoader
 
loader = CSVLoader("./data/data.csv")
docs = loader.load()

Cada fila del CSV se convierte en un Document.

Otros transform loaders incluyen:

• PyPDFLoader
• JSONLoader
• Docx2txtLoader
• UnstructuredFileLoader
• PandasDataFrameLoader

2. Loaders de datasets públicos o servicios web

Obtienen texto directamente de fuentes en línea.

Ejemplo con Wikipedia

from langchain_community.document_loaders import WikipediaLoader
 
loader = WikipediaLoader("Machine_learning")
docs = loader.load()

3. Loaders de fuentes propietarias / autenticadas

Se usan para servicios internos como:

• APIs de empresa
• CMS internos
• Bases de datos SQL
• SharePoint
• Slack
• Gmail

Estos requieren credenciales y, a menudo, loaders personalizados.

Cómo encajan los Document Loaders en un pipeline RAG moderno

Los Document Loaders solo cargan texto bruto.
No:

• generan embeddings
• crean “chains”
• producen “memory vectors”

(Una confusión muy común.)

Pipeline correcto:

Loader → Splitter → Embeddings → Vector Store → Retriever → LLM

Ejemplo con PDF:

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
 
loader = PyPDFLoader("file.pdf")
docs = loader.load()
 
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)
 
embeddings = OpenAIEmbeddings()
db = Chroma.from_documents(chunks, embeddings)

Casos de uso de los LangChain Document Loaders modernos

Ejemplo 1: Cargar y fragmentar archivos para indexación

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
 
loader = TextLoader("article.txt")
docs = loader.load()
 
splitter = RecursiveCharacterTextSplitter(
    chunk_size=800, chunk_overlap=150
)
chunks = splitter.split_documents(docs)

Ejemplo 2: Ingestar CSV para entendimiento de datos

from langchain_community.document_loaders import CSVLoader
 
loader = CSVLoader("data.csv")
docs = loader.load()
 
for doc in docs:
    print(doc.page_content)

Ejemplo 3: Cargar transcripciones de YouTube (versión correcta 2025)

from langchain_community.document_loaders import YoutubeLoader
 
loader = YoutubeLoader.from_youtube_url(
    "https://www.youtube.com/watch?v=O5nskjZ_GoI",
    add_video_info=True
)
docs = loader.load()

No necesitas tokenizers ni modelos manuales: LangChain se encarga únicamente de la carga de texto.

Ejemplo 4: DataFrame de Pandas → Documents

from langchain_community.document_loaders import DataFrameLoader
 
loader = DataFrameLoader(dataframe, page_content_column="text")
docs = loader.load()

Aplicaciones reales para LangChain Document Loaders

A continuación, tres ejemplos útiles y modernos.

Crear una app de QA sobre PDF estilo ChatGPT (RAG moderno)

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
 
# 1. Load
pages = PyPDFLoader("./SpaceX.pdf").load()
 
# 2. Split
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, overlap=150)
chunks = splitter.split_documents(pages)
 
# 3. Embed & store
db = Chroma.from_documents(chunks, OpenAIEmbeddings())
 
# 4. Ask questions
retriever = db.as_retriever()
llm = ChatOpenAI(model="gpt-4.1")
 
from langchain.chains import RetrievalQA
qa = RetrievalQA.from_chain_type(llm, retriever=retriever)
 
qa.run("Summarize the mission in 3 bullet points.")

Crear una app de QA sobre transcripciones de YouTube

loader = YoutubeLoader.from_youtube_url(url)
docs = loader.load()
 
chunks = RecursiveCharacterTextSplitter.from_tiktoken_encoder().split_documents(docs)
db = Chroma.from_documents(chunks, OpenAIEmbeddings())
 
qa.run("Explain the main argument of this video")

Crear un chatbot de QA sobre un sitio web (vía sitemap)

from langchain_community.document_loaders.sitemap import SitemapLoader
 
loader = SitemapLoader("https://docs.chainstack.com/sitemap.xml")
docs = loader.load()

Ejecuta el mismo pipeline de fragmentar → generar embeddings → recuperar → chatear que usas para PDF/YouTube.

Conclusión

Los LangChain Document Loaders son la base de cualquier flujo de trabajo RAG. Te ayudan a:

• Cargar datos desde cualquier fuente
• Normalizar texto en un formato Document consistente
• Construir datasets listos para recuperación
• Habilitar chat, resumen y QA sobre tu propio contenido

Con loaders actualizados y los patrones correctos de LangChain en 2025, puedes crear potentes aplicaciones de IA sobre PDFs, sitios web, videos de YouTube, CSVs y más.

FAQ

¿Qué es un LangChain Document Loader?
Un Document Loader convierte archivos, URLs, APIs y otras fuentes en objetos Document de LangChain para usarlos en etapas posteriores.

¿Los Document Loaders crean embeddings o índices?
No. Los loaders solo cargan texto bruto. Las etapas de embeddings e indexación son pasos separados.

¿Qué loader debería usar para PDFs?
PyPDFLoader es la opción más fiable para extracción de texto en LangChain.

¿Cómo funcionan los loaders de YouTube?
Obtienen transcripciones usando la API de YouTube o subtítulos de la comunidad, devolviendo la transcripción como un Document.