LangChain einrichten: 12 Schritte, 146.000 Stars

LangChain zählt im September 2026 zu den meistgenutzten Python-Frameworks für den Bau von LLM-Anwendungen. Das Projekt von langchain-ai bringt es auf GitHub mittlerweile auf 146.320 Sterne und wird laut PyPI aktuell in Version 1.4.0 ausgeliefert, veröffentlicht am 3. September 2026. Wer heute einen Chatbot, einen Such-Assistenten oder eine Automatisierung mit einem Sprachmodell bauen will, kommt an dem Framework kaum vorbei. Dieses Tutorial zeigt Schritt für Schritt, wie du LangChain lokal einrichtest, die wichtigsten Bausteine verstehst und am Ende einen funktionierenden RAG-Chatbot mit Werkzeug-Zugriff selbst zusammensetzt.

Das aktuelle Release bringt zudem eine handfeste Neuerung mit: Laut Changelog wandert das Model Context Protocol mit Version 1.4.0 direkt in das Kernpaket, statt wie zuvor als separates Zusatzpaket gepflegt zu werden. Für dich als Entwickler bedeutet das weniger Abhängigkeiten zu verwalten und eine Integration, die von Anfang an zum restlichen Framework passt.

Der Artikel richtet sich an Python-Entwickler mit Grundkenntnissen, die noch keine oder wenig Erfahrung mit LangChain haben. Du brauchst keinen Cloud-Account und kein teures GPU-Setup: Alles läuft mit einer normalen Python-Umgebung und einem API-Schlüssel eines beliebigen LLM-Anbieters. Am Ende hast du ein lauffähiges Projekt, das du direkt erweitern kannst, etwa für interne Wissensdatenbanken oder einen Support-Bot.

Weitere Grundlagen zu einzelnen Bausteinen findest du in unseren separaten Tutorials aus dem Bereich KI & Machine Learning, etwa zum Aufsetzen von Sprachmodellen über Ollama oder zur Anbindung von Claude über die Anthropic-API. Dieses Tutorial konzentriert sich bewusst auf LangChain selbst, von der Installation bis zum fertigen Agenten.

Was ist LangChain? Einordnung im September 2026

LangChain ist ein Open-Source-Framework, das Bausteine für LLM-Anwendungen bereitstellt: Prompt-Vorlagen, Modell-Wrapper, Speicher für Konversationen, Anbindungen an Vektordatenbanken und Werkzeuge für Agenten. Statt jede Integration selbst zu schreiben, greifst du auf fertige Adapter für Anbieter wie OpenAI, Anthropic oder lokale Modelle über Ollama zurück und verbindest sie über eine einheitliche Schnittstelle. Das Projekt steht laut PyPI-Paketeintrag unter MIT-Lizenz und ist damit kostenlos für kommerzielle Nutzung.

Seit dem Sprung auf die 1.x-Reihe hat sich die Architektur spürbar verändert. Das aktuelle Release 1.4.0 bringt laut Changelog von LangChain einen neuen langchain.mcp-Namespace samt MCPAdapter direkt im Kernpaket mit, wodurch das Model Context Protocol vom reinen Zusatzpaket zu einem festen Bestandteil des Frameworks wird. Parallel dazu liegt langchain-core, das Fundament mit den Runnable-Abstraktionen, in Version 1.6.3 vor (Stand 11. September 2026). Die Integrationspakete langchain-openai (1.6.2) und langchain-anthropic (1.7.2) werden unabhängig davon versioniert und aktualisiert, was in der Praxis bedeutet: Du kannst dein Kernframework aktuell halten, ohne bei jedem Update alle Provider-Anbindungen neu zu testen.

Wichtig für die Einordnung: LangChain ist längst nicht mehr nur eine Chain-Bibliothek. Rund um den Kern hat sich ein Ökosystem aus drei Teilen gebildet, die getrennt entwickelt und lizenziert werden. Das schauen wir uns im nächsten Abschnitt genauer an, bevor es an die eigentliche Installation geht.

In der Praxis trifft man LangChain heute vor allem in drei Szenarien an. Erstens als Klebstoff zwischen mehreren Sprachmodellen, etwa wenn eine Anwendung parallel OpenAI-Modelle für Textgenerierung und ein günstigeres Modell für Klassifikation nutzt. Zweitens als Grundlage für interne Suchsysteme, die Firmenunterlagen durchsuchbar machen, ohne Daten an ein einzelnes Modell zu binden. Drittens als Basis für Agenten, die mehrere Schritte selbstständig planen, etwa das Durchsuchen einer Datenbank gefolgt von einer Berechnung und einer Zusammenfassung. Alle drei Szenarien bauen auf denselben Grundbausteinen auf, die du im Rest dieses Tutorials selbst zusammensetzt.

Kernkonzepte: Chains, LCEL, Agents, Tools und Memory

Wer LangChain zum ersten Mal öffnet, stolpert schnell über eine Handvoll Fachbegriffe. Hier die wichtigsten kurz erklärt, bevor wir sie im Tutorial praktisch einsetzen:

Chain: Eine Verkettung von Schritten, zum Beispiel Prompt formatieren, Modell aufrufen, Antwort parsen. Chains lassen sich beliebig kombinieren.
LCEL (LangChain Expression Language): Eine Syntax, mit der du Chains über den Pipe-Operator | zusammensteckst, ähnlich wie bei Unix-Pipes. Sie ersetzt viele der älteren, klassenbasierten Chain-Konstrukte.
Agent: Eine Komponente, die selbst entscheidet, welche Werkzeuge sie in welcher Reihenfolge aufruft, um eine Aufgabe zu lösen, statt einem starren Ablauf zu folgen.
Tool: Eine Funktion, die ein Agent aufrufen kann, etwa eine Websuche, eine Datenbankabfrage oder ein Taschenrechner.
Memory: Ein Mechanismus, der den Gesprächsverlauf zwischen mehreren Aufrufen speichert, damit ein Chatbot sich an vorherige Nachrichten erinnert.
Retriever / Vector Store: Eine Komponente, die Dokumente in Vektoren umwandelt und bei einer Anfrage die passendsten Textabschnitte zurückgibt, das Kernprinzip hinter Retrieval-Augmented Generation (RAG).

Für komplexe Agenten mit mehreren Schritten, Schleifen oder parallelen Pfaden reicht die klassische LCEL-Chain oft nicht aus. Dafür gibt es LangGraph, eine eigenständige Bibliothek, die Agenten als Zustandsgraphen modelliert. Wer heute einen produktiven Agenten baut, landet in der Regel bei LangGraph statt bei den älteren AgentExecutor-Klassen, die in der 1.x-Reihe nur noch als Legacy-Pfad geführt werden.

Alle sechs Konzepte greifen im Tutorial ineinander: Du startest mit einer einzelnen Chain aus Prompt und Modell, ergänzt einen Output Parser für strukturierte Daten, fügst Memory für den Gesprächsverlauf hinzu und erweiterst das Ganze schließlich um Tools und einen Retriever. Am Ende von Schritt 12 laufen alle sechs Bausteine gemeinsam in einem einzigen Chatbot-Skript.

LangChain, LangGraph und LangSmith: Rollen und Kosten im Ökosystem

Ein häufiger Stolperstein für Einsteiger: LangChain, LangGraph und LangSmith klingen ähnlich, lösen aber unterschiedliche Probleme und haben getrennte Preismodelle. LangChain und LangGraph sind Open-Source-Bibliotheken unter MIT-Lizenz und damit kostenlos, LangSmith ist eine separate, kostenpflichtige SaaS-Plattform für Tracing, Debugging und Monitoring, wie aus der offiziellen Preisseite von LangChain hervorgeht. Wer nur die Kernbibliothek installiert, zahlt also grundsätzlich nichts an LangChain selbst, unabhängig davon, wie viele Chains oder Agenten er damit baut. Die folgende Tabelle fasst den aktuellen Stand zusammen.

Komponente	Version (Sept. 2026)	Lizenz / Preis	Funktion
langchain	1.4.0	MIT, kostenlos	Kernframework: Chains, Agents, Integrationen
langchain-core	1.6.3	MIT, kostenlos	Basis-Abstraktionen, Runnables, LCEL
langchain-openai	1.6.2	MIT, kostenlos (API-Kosten separat)	Anbindung an OpenAI-Modelle
langchain-anthropic	1.7.2	MIT, kostenlos (API-Kosten separat)	Anbindung an Claude-Modelle
LangGraph	1.2.x-Reihe	MIT, kostenlos	Orchestrierung von Agenten als Zustandsgraph
LangSmith Developer	SaaS	0 $/Monat, bis 5.000 Traces	Tracing und Debugging für kleine Projekte
LangSmith Plus	SaaS	39 $/Sitz/Monat, bis 10.000 Traces	Tracing für Teams in der Produktion

Über die enthaltenen Trace-Kontingente hinaus rechnet LangSmith nutzungsbasiert ab: 1,50 $ pro LangChain Compute Unit (LCU) und 1,00 $ pro LangSmith Unit (LSU), so die aktuelle Preisseite von LangChain. Für dieses Tutorial brauchst du LangSmith nicht zwingend, es lohnt sich aber, sobald du Agenten mit mehreren Schritten debuggen willst. Dazu mehr in Schritt 11.

Typische Anwendungsfälle für LangChain in Unternehmen

Bevor wir mit der Installation starten, lohnt sich ein kurzer Blick darauf, wofür Teams das Framework tatsächlich einsetzen. Der mit Abstand häufigste Anwendungsfall bleibt der interne Wissens-Assistent: Ein Unternehmen füttert LangChain mit Handbüchern, Support-Tickets oder Vertragsvorlagen und lässt Mitarbeiter in natürlicher Sprache Fragen dazu stellen, statt manuell durch Ordnerstrukturen zu klicken. Das Prinzip dahinter ist Retrieval-Augmented Generation, wie du es in Schritt 11 selbst aufbaust.

Ein zweiter großer Bereich sind Support-Bots, die erste Anfragen automatisch kategorisieren und nur die kniffligen Fälle an Menschen weiterreichen, ähnlich dem Ticket-Beispiel aus Schritt 6. Drittens setzen Entwicklerteams LangChain für interne Automatisierung ein, etwa um Log-Dateien zusammenzufassen, Code-Reviews vorzufiltern oder Reports aus mehreren Datenquellen zu generieren. Alle drei Fälle lassen sich mit den in diesem Tutorial gezeigten Bausteinen abbilden, oft reicht schon die Kombination aus einer LCEL-Chain und einem einzigen Tool.

Wer über den reinen Prompt-Aufruf hinausgehen und ein Modell auf eigene Daten spezialisieren will, findet in unserem Tutorial zu LLM-Fine-Tuning mit LoRA eine passende Ergänzung. LangChain und Fine-Tuning schließen sich dabei nicht aus, in der Praxis kombiniert man oft ein fein abgestimmtes Modell mit den Orchestrierungs-Werkzeugen aus diesem Artikel.

Voraussetzungen für dieses Tutorial

Bevor es losgeht, brauchst du folgende Grundausstattung. LangChain 1.4.0 setzt laut PyPI-Metadaten Python 3.10 oder neuer (bis unter 4.0) voraus, ältere Python-Versionen funktionieren nicht mehr zuverlässig.

Python 3.10, 3.11, 3.12 oder 3.13 (aktuell getestet mit 3.12.3)
pip 23 oder neuer, idealerweise in einer virtuellen Umgebung
Ein API-Schlüssel eines LLM-Anbieters (OpenAI, Anthropic oder ein lokales Modell über Ollama)
Mindestens 2 GB freier Arbeitsspeicher für Vektordatenbank und Embeddings
Ein Terminal unter Linux, macOS oder Windows mit WSL2
Optional: ein kostenloser LangSmith-Account für Schritt 11

Ein GPU-Server ist für dieses Tutorial nicht nötig, da die eigentliche Modell-Inferenz bei einem externen Anbieter läuft. Wenn du komplett offline arbeiten willst, ersetzt du in den Codebeispielen einfach ChatOpenAI durch ChatOllama aus dem Paket langchain-ollama, der Rest der Chains funktioniert identisch, da LangChain alle Modelle über dieselbe Runnable-Schnittstelle anspricht. Eine Schritt-für-Schritt-Anleitung für die reine Ollama-Installation findest du separat in unserem Ollama-Setup-Tutorial, falls du zuerst ein lokales Modell zum Laufen bringen willst, bevor du es mit LangChain verbindest.

Rechne bei der Wahl deines Anbieters auch die laufenden Kosten ein. Jeder Aufruf einer Chain verbraucht Tokens, und bei Agenten mit mehreren Zwischenschritten können daraus schnell drei bis fünf Modellaufrufe pro Nutzeranfrage werden. Für die ersten Tests in diesem Tutorial reichen die günstigsten verfügbaren Modelle eines Anbieters völlig aus, ein größeres oder teureres Modell lohnt sich meist erst, wenn die Chain-Logik bereits steht und nur noch die Antwortqualität optimiert werden muss.

Schritt 1 bis 3: Umgebung einrichten, Pakete installieren, API-Schlüssel konfigurieren

Starte mit einer sauberen virtuellen Umgebung. Das verhindert Versionskonflikte mit anderen Projekten auf deinem Rechner, ein Fehler, der bei LangChain-Einsteigern besonders häufig vorkommt, weil das Framework viele Abhängigkeiten mitbringt.

# Schritt 1: Projektordner und virtuelle Umgebung
mkdir langchain-projekt && cd langchain-projekt
python3 -m venv .venv
source .venv/bin/activate   # unter Windows: .venv\Scripts\activate

# Schritt 2: LangChain und Kernpakete installieren
pip install --upgrade pip
pip install langchain langchain-core langchain-openai langchain-community
pip install chromadb python-dotenv langgraph

# Version pruefen
python -c "import langchain; print(langchain.__version__)"

Die Ausgabe des letzten Befehls sollte 1.4.0 oder eine neuere Version zeigen. Falls stattdessen ein ModuleNotFoundError erscheint, prüfe, ob die virtuelle Umgebung wirklich aktiv ist, das erkennst du am Präfix (.venv) vor deinem Terminal-Prompt.

Im dritten Schritt legst du eine .env-Datei an, in der dein API-Schlüssel liegt. Schreibe niemals Schlüssel direkt in den Quellcode, das ist einer der häufigsten Sicherheitsfehler in LLM-Projekten und wurde auch in unserem Tutorial zum Absichern von LLM-Secrets ausführlich behandelt.

# Datei: .env
OPENAI_API_KEY=sk-dein-schluessel-hier
LANGSMITH_API_KEY=lsv2-optional-fuer-schritt-11
LANGSMITH_TRACING=false

Füge die Datei sofort zu deiner .gitignore hinzu, bevor du irgendetwas committest. Ein versehentlich gepushter API-Schlüssel lässt sich zwar widerrufen, taucht aber trotzdem in der Git-Historie auf, wenn du nicht aufpasst.

Schritt 4 und 5: Erster LLM-Aufruf und Prompt Templates mit LCEL

Jetzt folgt der erste echte Aufruf an ein Sprachmodell. LangChain kapselt jeden Provider in einer eigenen Chat-Modell-Klasse, sodass der Code für OpenAI, Anthropic oder ein lokales Modell fast identisch aussieht.

# Datei: 01_erster_aufruf.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(
    model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
    temperature=0.3,
)

antwort = llm.invoke("Erklaere in zwei Saetzen, was Retrieval-Augmented Generation ist.")
print(antwort.content)

Erwartete Ausgabe (kann je nach Modellversion leicht variieren):

Retrieval-Augmented Generation kombiniert ein Sprachmodell mit einer
Suche in externen Dokumenten, bevor eine Antwort generiert wird. So
kann das Modell aktuelle oder firmenspezifische Informationen nutzen,
die nicht Teil seines Trainings waren.

Damit du nicht jedes Mal einen Prompt fest in den Code schreibst, nutzt du Prompt Templates. Kombiniert mit LCEL entsteht daraus eine Chain, die du wie eine Pipeline liest: Eingabe rein, Prompt formatieren, an das Modell schicken, Antwort zurück.

# Datei: 02_lcel_chain.py
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein praeziser Assistent fuer deutsche Entwickler."),
    ("human", "Fasse folgenden Text in einem Satz zusammen: {text}"),
])

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser()

chain = prompt | llm | parser

ergebnis = chain.invoke({"text": "LangChain ist ein Framework fuer LLM-Anwendungen ..."})
print(ergebnis)

Der Operator | verkettet drei Runnables zu einer neuen Chain. Jede einzelne Komponente lässt sich austauschen, ohne die anderen anzufassen, etwa den Prompt gegen eine andere Vorlage oder das Modell gegen ChatAnthropic.

Dieses Austauschprinzip ist der eigentliche Kern von LCEL. Da prompt, llm und parser alle dasselbe Runnable-Interface implementieren, kannst du zusätzliche Schritte einfach in die Pipe einfügen, etwa einen zweiten Parser oder einen Guardrail-Check, ohne die bestehende Logik umzuschreiben. Genau diese Komponierbarkeit meint die offizielle Kurzbeschreibung des Pakets auf PyPI, wenn sie von “Building applications with LLMs through composability” spricht.

Schritt 6 und 7: Output Parser und Konversationsspeicher

Für viele Anwendungen reicht ein reiner Textstring als Antwort nicht aus, du brauchst strukturierte Daten, etwa ein JSON-Objekt mit festen Feldern. Dafür kombinierst du ein Pydantic-Modell mit dem strukturierten Output-Modus von LangChain.

# Datei: 03_strukturierte_ausgabe.py
from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI

class Ticket(BaseModel):
    titel: str = Field(description="Kurzer Titel des Support-Tickets")
    prioritaet: str = Field(description="niedrig, mittel oder hoch")
    kategorie: str = Field(description="z.B. Abrechnung, Technik, Konto")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
strukturiertes_llm = llm.with_structured_output(Ticket)

ergebnis = strukturiertes_llm.invoke(
    "Mein Login funktioniert seit heute Morgen nicht mehr, ich brauche dringend Zugriff."
)
print(ergebnis.model_dump())

{'titel': 'Login funktioniert nicht', 'prioritaet': 'hoch', 'kategorie': 'Technik'}

Für den Gesprächsverlauf reicht in aktuellen LangChain-Versionen eine einfache Nachrichtenliste, die du selbst verwaltest und bei jedem Aufruf mitschickst. Die älteren ConversationBufferMemory-Klassen gelten inzwischen als Legacy-Pfad, das manuelle Verwalten der Nachrichtenhistorie über RunnableWithMessageHistory oder direkt in LangGraph ist der empfohlene Weg für neue Projekte. Der Vorteil dieses Ansatzes: Du entscheidest selbst, wo der Verlauf liegt, etwa in einer Datenbank pro Nutzer-Session statt nur im Arbeitsspeicher, was für Chatbots mit mehreren gleichzeitigen Nutzern in der Praxis ohnehin notwendig ist.

# Datei: 04_gespraechsspeicher.py
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

verlauf_speicher = {}

def get_verlauf(session_id: str):
    if session_id not in verlauf_speicher:
        verlauf_speicher[session_id] = InMemoryChatMessageHistory()
    return verlauf_speicher[session_id]

chain_mit_verlauf = RunnableWithMessageHistory(chain, get_verlauf)

chain_mit_verlauf.invoke(
    {"text": "Mein Name ist Anna."},
    config={"configurable": {"session_id": "nutzer-1"}},
)

Schritt 8 und 9: Tools, Function Calling und ein erster Agent

Ein Agent wird erst dann nützlich, wenn er auf Werkzeuge zugreifen kann. Ein Tool ist in LangChain schlicht eine Python-Funktion mit einem Decorator und einer Beschreibung, die das Modell versteht.

# Datei: 05_tools.py
from langchain_core.tools import tool

@tool
def rechne(ausdruck: str) -> str:
    """Wertet einen einfachen mathematischen Ausdruck aus, z.B. '12 * 4'."""
    try:
        return str(eval(ausdruck, {"__builtins__": {}}))
    except Exception as fehler:
        return f"Fehler bei der Berechnung: {fehler}"

@tool
def aktuelles_datum() -> str:
    """Gibt das heutige Datum im Format TT.MM.JJJJ zurueck."""
    from datetime import date
    return date.today().strftime("%d.%m.%Y")

Beachte die Docstrings: Das Modell liest genau diesen Text, um zu entscheiden, wann welches Tool sinnvoll ist. Ein unklarer oder fehlender Docstring ist einer der häufigsten Gründe, warum ein Agent das falsche Werkzeug wählt oder gar keins aufruft.

Ebenso wichtig sind die Typ-Annotationen der Parameter. Der @tool-Decorator liest die Funktionssignatur aus und generiert daraus automatisch ein Schema, das dem Modell mitteilt, welche Argumente in welchem Format erwartet werden. Fehlt eine Typannotation oder ist sie zu allgemein gehalten, etwa ein reines Any statt str, steigt die Fehlerquote bei den generierten Aufrufen spürbar, weil das Modell raten muss, welches Format gemeint ist.

Schritt 10: Agenten mit LangGraph orchestrieren

Für einen produktionsnahen Agenten setzt du auf LangGraph statt auf die ältere AgentExecutor-Klasse. LangGraph modelliert den Agenten als Graph aus Zuständen, was Schleifen, Wiederholungsversuche und komplexere Abläufe deutlich einfacher macht als die klassische Chain-Struktur.

# Datei: 06_agent_langgraph.py
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

agent = create_react_agent(
    model=llm,
    tools=[rechne, aktuelles_datum],
    prompt="Du bist ein hilfsbereiter Assistent. Nutze Tools, wenn sie helfen.",
)

antwort = agent.invoke({
    "messages": [{"role": "user", "content": "Was ist 18 mal 24, und welches Datum haben wir heute?"}]
})
print(antwort["messages"][-1].content)

18 mal 24 ergibt 432. Heute ist der 14.09.2026.

Im Hintergrund läuft hier ein kompletter ReAct-Zyklus: Das Modell entscheidet, ruft rechne und aktuelles_datum auf, liest die Ergebnisse zurück und formuliert daraus eine zusammenhängende Antwort. Das ist derselbe Mechanismus, der auch komplexeren Multi-Agenten-Systemen wie CrewAI zugrunde liegt, nur direkt im LangChain-Ökosystem.

LangGraph speichert den Zustand des Agenten zwischen jedem Schritt in einem sogenannten Checkpoint. Das erlaubt es, einen unterbrochenen Lauf später fortzusetzen oder einen einzelnen Zwischenschritt zu wiederholen, ohne den gesamten Agenten neu zu starten. Für unser einfaches Beispiel reicht der In-Memory-Checkpointer aus create_react_agent, für produktive Deployments bietet LangGraph zusätzlich Checkpointer, die den Zustand in einer Datenbank wie PostgreSQL ablegen.

Schritt 11: Vector Store und Retrieval-Augmented Generation

Damit dein Agent auf eigene Dokumente statt nur auf Trainingsdaten zugreift, brauchst du einen Vector Store. Chroma eignet sich für lokale Tests, weil es ohne separaten Server läuft und alle Daten auf der Festplatte ablegt.

# Datei: 07_rag_setup.py
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

loader = TextLoader("wissensdatenbank.txt", encoding="utf-8")
dokumente = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(dokumente)

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")

retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
treffer = retriever.invoke("Wie kuendige ich mein Abo?")
for d in treffer:
    print(d.page_content[:120])

Wenn du einen vollständigen RAG-Aufbau mit mehreren Datenquellen und Reranking brauchst, lohnt sich ein Blick in unser separates Tutorial zum Aufbau einer RAG-Pipeline, das genau diesen Teil vertieft. Für unser Beispielprojekt reicht der einfache Retriever oben völlig aus.

Achte bei der Wahl des Embedding-Modells auf die Balance zwischen Genauigkeit und Kosten. Kleinere Embedding-Modelle wie das hier verwendete text-embedding-3-small reichen für die meisten internen Wissensdatenbanken aus und sind deutlich günstiger als größere Varianten. Die Chunk-Größe von 500 Zeichen mit 50 Zeichen Überlappung ist ein guter Startwert, für sehr technische Dokumente mit langen Tabellen oder Code-Blöcken lohnt sich aber oft ein Test mit größeren Chunks von 800 bis 1.000 Zeichen.

Schritt 12: LangSmith-Tracing für Debugging aktivieren

Sobald eine Chain oder ein Agent mehrere Schritte durchläuft, wird es ohne Tracing schwer nachzuvollziehen, wo genau eine Antwort falsch abbiegt. LangSmith protokolliert jeden Zwischenschritt, jeden Prompt und jede Modellantwort in einer Weboberfläche.

# In der .env-Datei ergaenzen
LANGSMITH_TRACING=true
LANGSMITH_API_KEY=lsv2-dein-schluessel
LANGSMITH_PROJECT=langchain-tutorial-2026

Mehr Code brauchst du nicht. Sobald die Umgebungsvariablen gesetzt sind, erscheinen alle Aufrufe automatisch im LangSmith-Dashboard, inklusive Latenz, Token-Verbrauch und geschätzten Kosten pro Aufruf. Der Developer-Tarif deckt bis zu 5.000 Traces pro Monat kostenlos ab, für ein einzelnes Entwicklerprojekt meist ausreichend.

Komplettes Projekt: RAG-Chatbot mit Tool-Zugriff zusammenbauen

Jetzt führen wir alle Bausteine zu einem lauffähigen Projekt zusammen: einem Chatbot, der Fragen zu einer lokalen Wissensdatenbank beantwortet und zusätzlich einen Taschenrechner als Tool nutzen kann.

Lege dazu zuerst eine kurze Textdatei namens wissensdatenbank.txt mit ein paar Absätzen zu deinem Produkt oder Prozess an, etwa Rückgabebedingungen, Öffnungszeiten oder eine FAQ-Sammlung. Der folgende Code liest diese Datei automatisch beim Start ein, zerlegt sie in Chunks und baut daraus den Vektorindex auf, den der Agent anschließend über das Tool dokumente_durchsuchen abfragt.

Projektstruktur

langchain-projekt/
├── .venv/
├── .env
├── wissensdatenbank.txt
├── chroma_db/           # wird automatisch erzeugt
└── chatbot.py

Vollständiger Code

# Datei: chatbot.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

load_dotenv()

# 1. Wissensdatenbank laden und indexieren
loader = TextLoader("wissensdatenbank.txt", encoding="utf-8")
chunks = RecursiveCharacterTextSplitter(
    chunk_size=500, chunk_overlap=50
).split_documents(loader.load())

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 2. Tools definieren
@tool
def dokumente_durchsuchen(frage: str) -> str:
    """Durchsucht die interne Wissensdatenbank nach relevanten Textstellen."""
    treffer = retriever.invoke(frage)
    return "\n---\n".join(d.page_content for d in treffer)

@tool
def rechne(ausdruck: str) -> str:
    """Wertet einen einfachen mathematischen Ausdruck aus."""
    try:
        return str(eval(ausdruck, {"__builtins__": {}}))
    except Exception as fehler:
        return f"Fehler: {fehler}"

# 3. Agent zusammenbauen
llm = ChatOpenAI(model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"), temperature=0)

agent = create_react_agent(
    model=llm,
    tools=[dokumente_durchsuchen, rechne],
    prompt=(
        "Du bist ein Support-Assistent. Nutze dokumente_durchsuchen fuer "
        "Fragen zum Produkt und rechne fuer Berechnungen. Antworte auf Deutsch."
    ),
)

# 4. Interaktive Schleife
if __name__ == "__main__":
    print("Chatbot bereit. Tippe 'exit' zum Beenden.")
    while True:
        frage = input("Du: ")
        if frage.strip().lower() == "exit":
            break
        ergebnis = agent.invoke({"messages": [{"role": "user", "content": frage}]})
        print("Bot:", ergebnis["messages"][-1].content)

Ausführen und testen

python chatbot.py

Chatbot bereit. Tippe 'exit' zum Beenden.
Du: Wie viele Tage habe ich Rueckgaberecht laut Wissensdatenbank?
Bot: Laut den hinterlegten Dokumenten hast du 14 Tage Rueckgaberecht
ab Erhalt der Ware.
Du: Und was sind 14 mal 3?
Bot: 14 mal 3 ergibt 42.

Damit hast du in unter 100 Zeilen Code einen Agenten, der zwischen zwei Werkzeugen wählt, auf eigene Daten zugreift und einen Gesprächsverlauf pro Sitzung führen kann, wenn du zusätzlich RunnableWithMessageHistory aus Schritt 7 einbaust. Von hier aus lässt sich das Projekt beliebig erweitern, etwa um eine Websuche, eine Datenbank-Anbindung oder ein zweites spezialisiertes Modell für Klassifikation.

Häufige Fehler beim Einstieg in LangChain

Die meisten Probleme mit LangChain entstehen nicht durch Bugs im Framework selbst, sondern durch veraltete Muster oder unsaubere Fehlerbehandlung im eigenen Code. Die folgende Liste sammelt die Fehler, die in Foren, GitHub Issues und Entwickler-Communities am häufigsten auftauchen, und zeigt jeweils, wie du sie vermeidest.

Veraltete Tutorials nachbauen: Viele Anleitungen im Netz stammen noch aus der 0.x-Reihe und nutzen Klassen wie LLMChain oder ConversationChain, die inzwischen als Legacy gelten. Prüfe bei jedem Codebeispiel, ob es zu deiner installierten Version passt.
API-Schlüssel im Quellcode: Schlüssel gehören in Umgebungsvariablen oder einen Secret-Manager, nie direkt in .py-Dateien, die versehentlich ins Repository wandern können.
Zu große Chunk-Größen beim Text-Splitting: Wer Dokumente in 2.000 Zeichen großen Blöcken zerteilt, bekommt bei der Suche oft zu viel irrelevanten Kontext. Kleinere Chunks mit etwas Überlappung liefern meist präzisere Treffer.
Fehlende oder vage Tool-Beschreibungen: Ein Tool ohne aussagekräftigen Docstring wird vom Agenten oft ignoriert oder falsch eingesetzt, weil das Modell nur den Text zur Entscheidung hat.
Keine Fehlerbehandlung in Tools: Wenn ein Tool bei einer Ausnahme einfach abstürzt, bricht der gesamte Agentenlauf ab. Fange Fehler ab und gib eine verständliche Fehlermeldung als String zurück, wie im rechne-Tool oben.
Synchron statt asynchron in Produktionsumgebungen: Wer viele parallele Anfragen bedienen muss, aber nur invoke() statt ainvoke() nutzt, verschenkt Durchsatz und blockiert den Event-Loop unnötig.
Kein Limit für Agenten-Schleifen: Ein Agent, der ein Tool wiederholt mit ähnlichen Argumenten aufruft, kann in eine Endlosschleife geraten und dabei unbemerkt hohe Kosten verursachen. Setze bei LangGraph ein Recursion-Limit, damit ein Lauf nach einer festen Anzahl von Schritten kontrolliert abbricht.

Troubleshooting: Die häufigsten Probleme und Lösungen

Auch mit sauberem Code läuft nicht jeder erste Versuch fehlerfrei durch. Die folgende Tabelle sammelt neun Probleme, die beim Einrichten von LangChain immer wieder auftauchen, zusammen mit der jeweils wahrscheinlichsten Ursache und einer konkreten Lösung. Wenn dein Fehler nicht dabei ist, hilft in der Regel ein Blick in die Ausgabe von pip list, um Versionskonflikte zwischen den installierten Paketen auszuschließen, oder ein aktiviertes LangSmith-Tracing aus Schritt 12, um genau zu sehen, an welcher Stelle die Chain abbricht.

Problem	Wahrscheinliche Ursache	Lösung
ModuleNotFoundError: langchain_openai	Paket nicht installiert oder falsche venv aktiv	pip install langchain-openai erneut ausführen, venv-Aktivierung prüfen
AuthenticationError beim Modellaufruf	API-Schlüssel fehlt, ist falsch oder .env wird nicht geladen	load_dotenv() aufrufen, Schlüssel in .env ohne Anführungszeichen prüfen
Agent ruft Tool nie auf	Docstring des Tools zu unklar oder Prompt widerspricht sich	Docstring präzisieren, im System-Prompt explizit auf das Tool hinweisen
ImportError bei langchain.agents.AgentExecutor	Klasse existiert noch, gilt aber als Legacy in 1.x	Auf langgraph.prebuilt.create_react_agent umsteigen
Chroma-Fehler “no such table” nach Update	Inkompatible Datenbankversion nach Chroma-Upgrade	Ordner chroma_db löschen und Index neu aufbauen
Sehr langsame Antworten	Synchrone Aufrufe, kein Streaming, große Kontextfenster	streaming=True setzen, ainvoke für Parallelität, Kontext kürzen
RateLimitError vom Provider	Zu viele Anfragen in kurzer Zeit	Exponentielles Backoff einbauen, LangChain-eigene Retry-Logik nutzen
Strukturierte Ausgabe schlägt fehl	Pydantic-Modell zu komplex oder Modell unterstützt kein Function Calling	Modell mit Function-Calling-Support wählen, Felder vereinfachen
Hohe Kosten pro Test-Lauf	Zu häufige, unbeobachtete Aufrufe während der Entwicklung	LangSmith-Tracing aktivieren, Kosten pro Trace im Dashboard prüfen

Sicherheit und Datenschutz beim Einsatz von LangChain

Sobald ein Agent Tools aufrufen oder Dokumente aus unsicheren Quellen verarbeiten kann, wird Sicherheit zum eigenen Thema, nicht nur zum Nebenaspekt. Das rechne-Tool aus diesem Tutorial nutzt bewusst ein eingeschränktes eval() ohne Zugriff auf Built-ins, trotzdem gilt: In einer echten Produktivanwendung ersetzt du eine solche Funktion besser durch eine dedizierte Mathe-Bibliothek wie numexpr, um jede Form von Code-Injection auszuschließen.

Ein zweites Risiko betrifft RAG-Anwendungen direkt: Wenn dein Retriever Dokumente aus einer Quelle liest, die Dritte befüllen können, etwa hochgeladene Support-Tickets oder gescrapte Webseiten, kann ein Angreifer versteckte Anweisungen in diese Dokumente schmuggeln. Das Modell liest sie beim Abruf mit und führt sie im schlimmsten Fall aus, ein klassischer Fall von indirekter Prompt Injection. Begrenze deshalb, was ein Agent nach einem Retrieval-Schritt automatisch ausführen darf, und validiere kritische Aktionen wie das Versenden von E-Mails oder das Ändern von Datensätzen über eine zusätzliche Bestätigung außerhalb des Sprachmodells.

Für deutsche und europäische Unternehmen kommt die Frage der Datenverarbeitung hinzu. Jeder Aufruf an einen Cloud-Anbieter wie OpenAI oder Anthropic schickt die eingegebenen Texte an dessen Server, was bei personenbezogenen oder vertraulichen Daten eine Auftragsverarbeitungsvereinbarung nach DSGVO notwendig macht. Wer diesen Weg vermeiden will, bleibt bei lokal über Ollama laufenden Modellen, verliert dabei allerdings etwas an Antwortqualität gegenüber den größten verfügbaren Cloud-Modellen. LangSmith speichert zusätzlich alle getracten Prompts und Antworten in der Cloud, was bei sensiblen Daten ebenfalls vorab geprüft werden sollte, bevor Tracing in der Produktion aktiviert wird.

Performance-Tipps und Best Practices für den Produktivbetrieb

Für den Einstieg reicht der Code aus diesem Tutorial. Sobald ein Projekt aber echte Nutzer bedient, lohnen sich einige zusätzliche Kniffe, die in der Dokumentation oft nur am Rande erwähnt werden. Wenn du mehrere Modelle oder Konfigurationen systematisch gegeneinander testen willst, bevor du dich für eine Produktivversion entscheidest, hilft dir zusätzlich unser Tutorial zum Aufbau eines eigenen LLM-Benchmarks, das sich gut mit den hier gezeigten Chains kombinieren lässt.

Streaming aktivieren: Mit chain.stream(...) statt chain.invoke(...) bekommt der Nutzer Tokens laufend angezeigt, statt auf die komplette Antwort zu warten. Das senkt die gefühlte Latenz deutlich, auch wenn die Gesamtzeit gleich bleibt.
Asynchrone Ausführung: Für Webserver mit vielen parallelen Anfragen sind ainvoke(), abatch() und astream() Pflicht, damit ein einzelner langsamer LLM-Aufruf nicht den gesamten Prozess blockiert.
Caching für wiederkehrende Anfragen: LangChain unterstützt einfache In-Memory- und SQLite-Caches für Modellantworten, was bei sich wiederholenden Prompts während der Entwicklung viele API-Aufrufe spart.
Batching statt Einzelaufrufe: Wenn du mehrere unabhängige Prompts verarbeitest, etwa beim Indexieren vieler Dokumente, nutzt batch() statt einer Schleife mit einzelnen invoke()-Aufrufen, das reduziert Overhead spürbar.
Kosten im Blick behalten: LangSmith zeigt Token-Verbrauch pro Trace an, das hilft, teure Prompts oder unnötig große Kontextfenster frühzeitig zu erkennen, bevor die Rechnung eskaliert.
Modelle je nach Aufgabe mischen: Ein kleines, günstiges Modell für einfache Klassifikation und ein größeres Modell nur für komplexe Antworten senkt die Gesamtkosten oft deutlich, ohne die Qualität spürbar zu verschlechtern.
Timeouts konsequent setzen: Ohne explizites Timeout kann ein einzelner hängender API-Aufruf eine ganze Anfrage blockieren. Setze bei jedem Chat-Modell einen realistischen Timeout-Wert, damit dein Service bei Ausfällen des Anbieters nicht selbst unresponsiv wird.

LangChain im Vergleich zu Alternativen

LangChain ist nicht die einzige Option, um LLM-Anwendungen zu bauen. Die Wahl hängt stark davon ab, wie viel Kontrolle du brauchst und wie komplex dein Agent werden soll.

Ansatz	Stärke	Schwäche	Ideal für
LangChain + LangGraph	Breites Ökosystem, viele fertige Integrationen, aktive Weiterentwicklung	Steile Lernkurve durch viele Abstraktionsebenen	Agenten mit mehreren Tools und Datenquellen
LlamaIndex	Stark spezialisiert auf Indexierung und Retrieval großer Dokumentenmengen	Weniger ausgereifte Agenten-Funktionen als LangGraph	Reine RAG- und Such-Anwendungen
Haystack	Klare Pipeline-Architektur, gut für produktionsreife Suchsysteme	Kleineres Integrations-Ökosystem	Unternehmens-Suche mit festen Pipelines
Direkter Provider-SDK-Aufruf	Maximale Kontrolle, keine zusätzliche Abstraktionsschicht	Jede Integration muss selbst geschrieben werden	Sehr einfache, einmalige Anwendungsfälle

Wer bereits mit Multi-Agenten-Frameworks wie CrewAI arbeitet, wird feststellen, dass viele dieser Frameworks LangChain-Komponenten unter der Haube nutzen oder zumindest kompatibel dazu sind. Ein solides Verständnis von LCEL und LangGraph zahlt sich also auch außerhalb von LangChain selbst aus.

Fazit

LangChain hat sich seit dem Sprung auf die 1.x-Reihe zu einem deutlich klareren Framework entwickelt. LCEL für einfache Chains, LangGraph für Agenten und LangSmith für Tracing ergeben zusammen ein Werkzeug, mit dem sich vom einfachen Prompt bis zum RAG-Chatbot mit Tool-Zugriff alles abbilden lässt, wie du in diesem Tutorial in eigenem Code gesehen hast. Der Einstieg kostet nichts außer den API-Gebühren deines gewählten Modells, und die MIT-Lizenz erlaubt kommerzielle Nutzung ohne Einschränkung. Wer jetzt startet, baut direkt auf der aktuellen Architektur auf, statt später alte AgentExecutor-Konstrukte migrieren zu müssen.

Der nächste sinnvolle Schritt nach diesem Tutorial ist meist, den Beispiel-Chatbot mit echten Firmendaten zu füttern und die Antwortqualität systematisch zu messen, statt sie nur stichprobenartig zu prüfen. Sobald das steht, lohnt sich außerdem ein Blick auf Absicherung: Welche Tools darf der Agent wirklich autonom ausführen, und wo braucht es eine menschliche Bestätigung, bevor eine Aktion tatsächlich passiert.

Häufig gestellte Fragen zu LangChain

Ist LangChain kostenlos?

Ja, LangChain steht unter MIT-Lizenz und lässt sich kostenlos kommerziell nutzen. Kosten entstehen nur durch die API-Gebühren des gewählten LLM-Anbieters und optional durch LangSmith, dessen Developer-Tarif aber ebenfalls bei 0 Dollar pro Monat beginnt. Die eigentliche Kostentreiber sind also nicht das Framework selbst, sondern die Menge an Tokens, die dein Modell pro Anfrage verarbeitet.

Brauche ich LangGraph zusätzlich zu LangChain?

Für einfache Chains reicht LangChain mit LCEL. Sobald ein Agent mehrere Schritte, Schleifen oder Entscheidungspunkte braucht, ist LangGraph die aktuell empfohlene Lösung, da die klassischen AgentExecutor-Klassen als Legacy-Pfad gelten.

Welche Python-Version brauche ich für LangChain 1.4.0?

Laut den offiziellen Paketmetadaten benötigt LangChain 1.4.0 mindestens Python 3.10 und funktioniert bis unter Python 4.0. Getestet wurde dieses Tutorial mit Python 3.12.3.

Funktioniert LangChain auch mit lokalen Modellen ohne API-Kosten?

Ja, über das Paket langchain-ollama lässt sich jedes lokal über Ollama laufende Modell genauso einbinden wie ein Cloud-Modell. Der restliche Chain- und Agent-Code bleibt unverändert, da alle Modelle dieselbe Runnable-Schnittstelle teilen.

Was kostet LangSmith, wenn ich es produktiv einsetze?

Der Developer-Tarif ist kostenlos bis 5.000 Traces pro Monat. Der Plus-Tarif für Teams kostet 39 Dollar pro Sitz und Monat mit bis zu 10.000 Traces, darüber hinaus wird nutzungsbasiert mit 1,50 Dollar pro LangChain Compute Unit und 1,00 Dollar pro LangSmith Unit abgerechnet.

Ist LangChain für Anfänger geeignet oder zu komplex?

Der Einstieg mit einer einzelnen LCEL-Chain ist in wenigen Zeilen Code machbar, wie die Beispiele in diesem Tutorial zeigen. Komplex wird es erst bei mehrstufigen Agenten mit LangGraph, dafür lohnt sich vorher ein solides Verständnis der Grundkonzepte Chain, Tool und Retriever.

Kann ich LangChain mit Claude oder anderen Anthropic-Modellen nutzen?

Ja, über das Paket langchain-anthropic, aktuell in Version 1.7.2. Der Code bleibt bis auf den Klassennamen ChatAnthropic statt ChatOpenAI identisch zu den Beispielen in diesem Tutorial.

Wo finde ich weitere Integrationen und aktuelle Release-Notes?

Die offizielle LangChain-Dokumentation listet alle verfügbaren Integrationen, der Changelog zeigt jede Version im Detail, und der Quellcode liegt offen auf GitHub.

LangChain einrichten: 12 Schritte, 146.000 Stars [2026]