Skip to content

Comece com LangChain Document Loaders: guia passo a passo (atualizado para 2025)

Akira Sakamoto
Name
Akira Sakamoto

Updated on

LangChain evoluiu rapidamente desde 2023. Se você está explorando Retrieval-Augmented Generation (RAG), construindo aplicações de chat ou integrando conhecimento externo em pipelines de LLM, os Document Loaders agora são um dos componentes mais importantes.

Este guia oferece uma compreensão clara, precisa e moderna de como os LangChain Document Loaders funcionam (versão 2025), como usá‑los corretamente e como construir aplicações reais em cima deles.

O que é LangChain?

LangChain é um framework projetado para ajudar desenvolvedores a construir aplicações com LLMs usando ferramentas como:

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

No LangChain moderno (0.1–0.2+), o pipeline para construir aplicações se parece com isto:

Load → Split → Embed → Store → Retrieve → Generate

Os Document Loaders cuidam da primeira etapa:
trazer conteúdo do mundo real para objetos “Document” amigáveis a LLMs.

O que são LangChain Document Loaders?

Um Document em LangChain tem dois campos:

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

Document Loaders convertem fontes externas — arquivos, URLs, APIs, PDFs, CSV, transcrições do YouTube — em uma lista de objetos Document.

Exemplo: carregar um arquivo .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 no LangChain

LangChain oferece dezenas de loaders, mas eles se encaixam em três categorias principais.

1. Transform Loaders (formatos de arquivos locais)

Carregam arquivos estruturados ou não estruturados:

Exemplo CSV (import moderno)

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

Cada linha do CSV vira um Document.

Outros transform loaders incluem:

  • PyPDFLoader
  • JSONLoader
  • Docx2txtLoader
  • UnstructuredFileLoader
  • PandasDataFrameLoader

2. Loaders de datasets públicos ou web services

Buscam texto diretamente de fontes online.

Exemplo Wikipedia

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

3. Loaders para fontes proprietárias / autenticadas

Usados para serviços internos, como:

  • APIs da empresa
  • CMS interno
  • Bancos de dados SQL
  • SharePoint
  • Slack
  • Gmail

Eles exigem credenciais e, muitas vezes, loaders personalizados.

Como os Document Loaders se encaixam em um pipeline RAG moderno

Document Loaders apenas carregam texto bruto.
Eles NÃO:

  • geram embeddings
  • criam “chains”
  • produzem “memory vectors”

(Um equívoco comum.)

Pipeline correto:

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

Exemplo com 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 para LangChain Document Loaders modernos

Exemplo 1: carregar e dividir arquivos para indexação

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)

Exemplo 2: ingestão de CSV para entendimento de dados

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

Exemplo 3: carregar transcrições do YouTube (versão correta para 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()

Nenhum tokenizer/modelo manual é necessário — LangChain cuida apenas do carregamento de texto.

Exemplo 4: Pandas DataFrame → Documents

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

Aplicações reais para LangChain Document Loaders

Abaixo estão três exemplos úteis e modernos.

Construir um app de perguntas e respostas sobre PDF ao 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.")

Construir um app de QA sobre transcrições do 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")

Construir um chatbot de QA sobre um site (via sitemap)

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

Execute o mesmo pipeline chunk → embed → retrieve → chat usado para PDF/YouTube.

Conclusão

LangChain Document Loaders são a base de qualquer workflow de RAG. Eles ajudam você a:

  • Carregar dados de qualquer fonte
  • Normalizar texto em um formato Document consistente
  • Construir datasets prontos para recuperação
  • Habilitar chat, sumarização e QA sobre o seu próprio conteúdo

Com loaders atualizados e padrões corretos do LangChain em 2025, você pode criar aplicações de IA poderosas em cima de PDFs, sites, vídeos do YouTube, CSVs e muito mais.

FAQ

O que é um LangChain Document Loader?
Um Document Loader converte arquivos, URLs, APIs e outras fontes em objetos Document do LangChain para uso posterior no pipeline.

Document Loaders criam embeddings ou índices?
Não. Loaders apenas carregam texto bruto. Embeddings e indexação são etapas separadas.

Qual loader devo usar para PDFs?
PyPDFLoader é a escolha mais confiável para extração de texto no LangChain.

Como funcionam os loaders do YouTube?
Eles obtêm transcrições usando a API do YouTube ou legendas da comunidade, retornando uma transcrição textual como um Document.