LangChain Document Loader: So kommen Dateien und Webseiten in eine RAG-Pipeline

Ein LLM kann nicht von sich aus durch Ihre Ordner streifen und die Dateien aufnehmen. Retrieval-Augmented Generation gibt es, weil Modelle Ihre privaten Daten nicht kennen, nichts Aktuelles wissen und sich manchmal Dinge ausdenken, wenn Kontext fehlt. Die Lösung: zur Abfragezeit den passenden Text holen. Doch bevor das passiert, muss überhaupt erst ein PDF, eine Webseite, eine CSV- oder Word-Datei in die Pipeline gelangen. Das ist die Aufgabe des Document Loaders – leicht zu übersehen, aber es lohnt sich, ihn richtig einzusetzen.

Was ein Loader macht

Ein Loader liest Daten aus einer Quelle und bringt sie in ein Format, das LangChain versteht. Er ist im Grunde ein Übersetzer. Ihr Material kann an ganz unterschiedlichen Orten liegen:

• PDFs
• Einfache Textdateien
• CSV-Dateien
• Websites
• Word-Dokumente
• Datenbanken

Alles nach dem Loader erwartet eine einheitliche Form, und der Loader schließt genau diese Lücke.

Warum PDFs nicht direkt ins Chunking können

Einsteiger stellen sich den Ablauf oft so vor:

PDF → Chunking → Embeddings

In der Praxis ist es unordentlicher. Ein PDF ist kein Text. Darin stecken Schriften, Bilder, Layoutdaten, Tabellen, Kopf- und Fußzeilen sowie Metadaten. Ein Chunker arbeitet nur mit Text, also muss vorher jemand die Wörter herausholen. Der tatsächliche Ablauf sieht eher so aus:

PDF → Document Loader → Text Extraction → Chunking → Embeddings

Der Loader extrahiert den Text und verpackt ihn in ein gemeinsames Format.

Die Loader, denen Sie am häufigsten begegnen

LangChain bringt Loader für viele Quellen mit. Die Eingabe ändert sich, das Prinzip nicht: irgendwo lesen und LangChain-Documents erzeugen. Diese werden Sie am häufigsten brauchen:

• TextLoader verarbeitet einfache .txt-Dateien.
• PyPDFLoader verarbeitet PDFs.
• WebBaseLoader verarbeitet Webseiten und URLs.
• CSVLoader verarbeitet CSV-Dateien.
• DirectoryLoader verarbeitet viele Dateien in einem Ordner.

Ein Ausgabetyp: Document

Egal welcher Loader läuft, meist bekommen Sie eine Liste von Document-Objekten zurück. Jedes enthält einen Text und ein paar Angaben zur Herkunft:

Document(
    page_content="Employees are eligible for 24 paid leaves per year.",
    metadata={
        "source": "employee_policy.pdf",
        "page": 5
    }
)

Zwei Felder sind entscheidend. page_content ist der Text selbst, und metadata beschreibt die Quelle, hier Dateiname und Seitenzahl. Diese einheitliche Form ist praktisch, weil es späteren Schritten egal ist, woher die Daten stammen. Ein PDF-Loader und ein Web-Loader liefern beide Documents, und der Chunking-Schritt behandelt sie gleich.

TextLoader

Die einfachste Variante liest reine Textdateien. Zuerst importieren:

from langchain_community.document_loaders import TextLoader

Dann auf eine Datei zeigen, laden und das Ergebnis ausgeben:

loader = TextLoader("notes.txt")documents = loader.load()print(documents)

Sie erhalten eine Liste:

[
    Document(...)
]

Selbst bei einer einzigen Datei kommt eine Liste zurück, damit die Schnittstelle einheitlich bleibt. Jedes Element ist ein Document.

Nutzen Sie ihn, wenn Ihre Daten schon als Text vorliegen, etwa Logs, Notizen, Textexporte oder saubere Datensätze. Er ist allerdings sehr simpel. PDFs parsen, Tabellen lesen, Layout verstehen oder Bilder extrahieren kann er nicht. Ist die Quelle kein Text, nehmen Sie etwas anderes.

PyPDFLoader

PDFs sind wohl die häufigste Quelle in RAG-Projekten, und PyPDFLoader ist der übliche Einstieg. Importieren:

from langchain_community.document_loaders import PyPDFLoader

Dann einen Bericht laden:

loader = PyPDFLoader("annual_report.pdf")documents = loader.load()

Angenommen, die Datei hat 25 Seiten. Zählt man das Ergebnis:

len(documents)

bekommt man:

25

Jede Seite wird zu einem eigenen Document. Ein Blick auf das erste:

documents[0]

zeigt Folgendes:

Document(
    page_content="Page 1 text...",
    metadata={
        "source": "annual_report.pdf",
        "page": 0
    }
)

Ein 25-seitiges PDF ergibt also 25 Documents. Intern setzt dieser Loader auf die Bibliothek PyPDF. Bei einfachen PDFs schlägt er sich gut, bei komplexen Layouts, mehrspaltigen Seiten, Tabellen und gescannten Dateien tut er sich aber schwer. Deshalb ist die Wahl des PDF-Loaders wichtig.

Den passenden PDF-Loader wählen

Den einen besten Loader für jede Datei gibt es nicht. Eine grobe Übersicht:

• PyPDFLoader passt zu einfachen, textbasierten PDFs.
• PDFPlumberLoader eignet sich für PDFs mit Tabellen und strukturiertem Layout.
• PyMuPDFLoader ist schnell und eine solide Allzweckwahl.
• UnstructuredPDFLoader zielt auf komplexe Unternehmensdokumente.
• AmazonTextractPDFLoader deckt Scans und OCR-lastige Aufgaben ab.

Eine brauchbare Faustregel: Mit PyPDF anfangen. Sieht der extrahierte Text schlecht aus, auf PyMuPDF oder Unstructured wechseln. Ist das Dokument ein Scan, einen OCR-Dienst wie Textract verwenden.

DirectoryLoader

Eine Datei zu laden ist trivial. 5.000 PDFs oder 10.000 Textdateien von Hand zu laden nicht – dafür gibt es DirectoryLoader. Importieren:

from langchain_community.document_loaders import DirectoryLoader

Dann einen Ordner und ein Glob-Muster übergeben:

loader = DirectoryLoader(
    "data/",
    glob="**/*.pdf"
)documents = loader.load()

Damit werden alle PDFs im Verzeichnis erfasst. Stellen Sie sich eine Struktur wie diese vor:

data/
├── report1.pdf
├── report2.pdf
├── report3.pdf

Der Loader geht jede passende Datei durch und lädt sie, und Sie erhalten:

[
    Document(...),
    Document(...),
    ...
]

Bei einem großen Ordner können das Hunderte oder Tausende Documents sein.

Das Problem mit riesigen Ordnern

Stellen Sie sich 20.000 PDFs oder 100.000 Textdateien vor und diesen Aufruf:

documents = loader.load()

LangChain liest sofort alles in den Speicher. Das ist Eager Loading. Es ist bequem und für kleine Datensätze in Ordnung, kostet aber viel Speicher und verlangsamt den Start.

Eager oder Lazy

Es gibt eine Alternative:

loader.lazy_load()

In der Eager-Variante wird alles auf einmal geladen:

documents = loader.load()

und der Rückgabetyp ist:

List[Document]

Die Lazy-Variante erzeugt Documents erst, wenn sie gebraucht werden:

documents = loader.lazy_load()

und liefert einen Generator:

Generator[Document]

Denken Sie an Video-Streaming. Ein Dienst lädt nicht den ganzen Film herunter, bevor Sie auf Play drücken, sondern liefert die Daten nach Bedarf. Lazy Loading funktioniert genauso.

load() eignet sich für kleine bis mittlere Sammlungen und für Prototypen. lazy_load() eignet sich für große Sammlungen und Umgebungen mit knappem Speicher.

WebBaseLoader

Nicht alles Wissen steckt in Dateien. Manchmal liegt es auf einer Website, und dafür ist WebBaseLoader da. Importieren:

from langchain_community.document_loaders import WebBaseLoader

Dann eine URL übergeben:

loader = WebBaseLoader(
    "https://python.langchain.com"
)documents = loader.load()

Intern parst er das HTML mit BeautifulSoup und zieht den Text heraus. Das passt für Blogs, Dokumentationen, Artikel, Wissensdatenbanken und Firmenwebsites.

Am besten funktioniert er mit statischen Seiten. JavaScript-lastige Sites, dynamische Inhalte und clientseitiges Rendering machen ihm zu schaffen. Für solche Fälle kann SeleniumURLLoader die Seite zuerst im Browser rendern und erst dann etwas extrahieren.

CSVLoader

Strukturierte Daten kommen oft als CSV. Nehmen wir eine kleine Mitarbeiterdatei:

employee_id,name,department
1,John,Engineering
2,Sarah,HR

Den Loader importieren:

from langchain_community.document_loaders import CSVLoader

Und die Datei laden:

loader = CSVLoader(
    file_path="employees.csv"
)documents = loader.load()

Jede Zeile wird zu einem Document, wobei Spaltennamen und Werte als Text ausgeschrieben werden und die Zeilennummer in den Metadaten landet:

Document(
    page_content="""
employee_id: 1
name: John
department: Engineering
""",
    metadata={
        "source": "employees.csv",
        "row": 0
    }
)

Das passt zu Produktkatalogen, Kundendaten, Lagerbeständen, Finanzdaten und ähnlichen Geschäftsdaten.

Drei Dinge zum Mitnehmen

1. Jede RAG-Pipeline beginnt mit dem Laden. Vor Chunking, Embeddings oder Retrieval müssen die Daten erst hinein.
2. Unterschiedliche Quellen brauchen unterschiedliche Loader: Textdateien TextLoader, PDFs PyPDFLoader, Websites WebBaseLoader, CSVs CSVLoader und Ordner DirectoryLoader.
3. Fast alles landet am Ende als Document-Objekt, und diese gemeinsame Form sorgt dafür, dass der Rest der Pipeline einheitlich arbeitet.

Den vollständigen Katalog der Loader finden Sie in der Integrations-Dokumentation von LangChain.

Sind die Dokumente geladen, wartet das nächste Rätsel: wie man sie aufteilt – nach Zeichen, Wörtern, Sätzen, Absätzen oder Tokens, und in welcher Größe bei einer 100-seitigen Datei. Zu klein geschnitten, geht Kontext verloren. Zu groß, und Sie holen Rauschen heraus. Diese Entscheidung verdient eine eigene, sorgfältige Betrachtung, denn es ist die Kunst, Dokumente zu zerlegen, ohne das RAG-System kaputtzumachen.