Erste Schritte mit LangChain Document Loaders: Schritt-für-Schritt-Anleitung (Update 2025)

Name

Akira Sakamoto

Updated on 15.11.2025

LangChain hat sich seit 2023 rasant weiterentwickelt. Wenn du Retrieval-Augmented Generation (RAG) erkundest, Chat-Anwendungen baust oder externes Wissen in LLM-Pipelines integrierst, sind Document Loaders inzwischen eine der wichtigsten Komponenten.

In dieser Anleitung erhältst du ein klares, präzises und modernes Verständnis davon, wie LangChain Document Loaders (Version 2025) funktionieren, wie du sie korrekt verwendest und wie du darauf aufbauend reale Anwendungen entwickelst.

Was ist LangChain?

LangChain ist ein Framework, das Entwicklern hilft, LLM-basierte Anwendungen zu bauen – unter Verwendung von Bausteinen wie:

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

In modernem LangChain (0.1–0.2+) sieht die Pipeline zum Bau von Anwendungen so aus:

Load → Split → Embed → Store → Retrieve → Generate

Document Loaders übernehmen den allerersten Schritt:
sie bringen Inhalte aus der realen Welt in LLM-freundliche „Document“-Objekte.

Was sind LangChain Document Loaders?

Ein LangChain-Document hat zwei Felder:

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

Document Loaders wandeln externe Quellen – Dateien, URLs, APIs, PDFs, CSV, YouTube-Transkripte – in eine Liste von Document-Objekten um.

Beispiel: Eine .txt-Datei laden

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

Resultat:

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

Typen von Document Loaders in LangChain

LangChain stellt Dutzende von Loadern bereit, die sich grob in drei Hauptkategorien einteilen lassen.

1. Transform Loader (lokale Dateiformate)

Laden strukturierter oder unstrukturierter Dateien:

CSV-Beispiel (moderner Import)

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

Jede CSV-Zeile wird zu einem Document.

Weitere Transform Loader sind:

• PyPDFLoader
• JSONLoader
• Docx2txtLoader
• UnstructuredFileLoader
• PandasDataFrameLoader

2. Loader für öffentliche Datensätze oder Webservices

Diese holen Text direkt aus Online-Quellen.

Wikipedia-Beispiel

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

3. Loader für proprietäre / authentifizierte Quellen

Eingesetzt für interne Dienste wie:

• Unternehmens-APIs
• interne CMS
• SQL-Datenbanken
• SharePoint
• Slack
• Gmail

Diese erfordern Zugangsdaten und oft auch eigene, angepasste Loader.

Wie Document Loaders in eine moderne RAG-Pipeline passen

Document Loaders laden nur Rohtext.
Sie tun NICHT Folgendes:

• Embeddings erzeugen
• „Chains“ erstellen
• „Memory Vectors“ erzeugen

(Das ist ein häufiges Missverständnis.)

Korrekte Pipeline:

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

Beispiel mit 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)

Anwendungsfälle für moderne LangChain Document Loaders

Beispiel 1: Dateien zum Indexieren laden und in Chunks aufteilen

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)

Beispiel 2: CSV-Daten zur Analyse einlesen

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

Beispiel 3: YouTube-Transkripte laden (2025-korrekte Version)

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()

Keine manuellen Tokenizer/Modelle nötig – LangChain übernimmt ausschließlich das Laden des Textes.

Beispiel 4: Pandas DataFrame → Documents

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

Praxisnahe Anwendungen für LangChain Document Loaders

Im Folgenden drei nützliche, moderne Beispiele.

Bau einer ChatGPT-ähnlichen PDF-QA-App (moderner RAG-Ansatz)

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.")

Bau einer YouTube-Transcript-QA-App

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")

Bau eines Website-QA-Chatbots (über Sitemap)

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

Nutze dieselbe Pipeline chunk → embed → retrieve → chat wie bei PDF/YouTube.

Fazit

LangChain Document Loaders sind das Fundament jeder RAG-Workflow. Sie helfen dir:

• Daten aus beliebigen Quellen zu laden
• Text in ein einheitliches Document-Format zu bringen
• retrieval-fähige Datensätze aufzubauen
• Chat, Zusammenfassungen und QA über deine eigenen Inhalte zu ermöglichen

Mit aktuellen Loadern und den korrekten LangChain-Patterns für 2025 kannst du leistungsfähige KI-Anwendungen auf Basis von PDFs, Websites, YouTube-Videos, CSVs und mehr entwickeln.

FAQ

Was ist ein LangChain Document Loader?
Ein Document Loader wandelt Dateien, URLs, APIs und andere Quellen in LangChain-Document-Objekte um, die anschließend weiterverarbeitet werden können.

Erstellen Document Loaders Embeddings oder Indexe?
Nein. Loader laden nur Rohtext. Embeddings und Indexierung sind separate Schritte.

Welchen Loader sollte ich für PDFs verwenden?
PyPDFLoader ist in LangChain die zuverlässigste Wahl für die Textextraktion aus PDFs.

Wie funktionieren YouTube Loader?
Sie holen Transkripte über die YouTube-API oder Community-Captions und geben das Transkript als Document zurück.