Was LangChain kann — und wann du es brauchst
LangChain ist ein Open-Source-Framework das repetitive Patterns beim Bau von LLM-Applikationen abstrahiert. Statt Prompt-Templates von Hand zu schreiben, API-Responses zu parsen und Kontexte zu verketten, bekommst du vorgefertigte Bausteine: Chains für sequentielle Logik, Document Loaders für RAG, Agents für autonomes Tool-Calling.
Die ehrliche Einschätzung: LangChain macht Sinn wenn dein Projekt mehrere der folgenden Bausteine kombiniert — RAG über eigene Dokumente, mehrschrittige Pipelines, Tool-Calling-Agents oder Wechsel zwischen verschiedenen LLM-Providern. Für einen einfachen Chatbot oder einzelne API-Calls ist direktes Anthropic-SDK schlanker und transparenter.
| Szenario |
LangChain sinnvoll? |
Empfehlung |
| Einfacher Chatbot, 1 Prompt |
Nein |
Direkt Anthropic SDK |
| RAG über interne Dokumente |
Ja |
LangChain + FAISS/Chroma |
| Mehrstufige Analyse-Pipeline |
Ja |
LangChain Chains |
| Agent mit Tool-Calling |
Ja |
LangChain Agents + ReAct |
| Schnelles Prototyping |
Bedingt |
SDK für Einstieg, dann LangChain |
| Produktions-API, Performance-kritisch |
Nein |
Direktes SDK mit eigenem Caching |
Claude mit LangChain in Python: Setup und ChatAnthropic
LangChain hat eine dedizierte Anthropic-Integration im Paket langchain-anthropic. Die Installation ist minimal:
# Installation
pip install langchain langchain-anthropic langchain-community
pip install faiss-cpu chromadb # für VectorStores
pip install pypdf unstructured # für Document Loaders
Der zentrale Einstiegspunkt ist ChatAnthropic. Es implementiert das LangChain-BaseChatModel-Interface und kann daher überall eingesetzt werden wo LangChain ein LLM erwartet:
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage
import os
# API Key aus Umgebungsvariable — niemals hardcoden!
llm = ChatAnthropic(
model="claude-opus-4-5",
api_key=os.environ["ANTHROPIC_API_KEY"],
max_tokens=2048,
temperature=0.2,
)
# Einfacher Aufruf
response = llm.invoke([
SystemMessage(content="Du bist ein präziser Python-Experte."),
HumanMessage(content="Erkläre Decorators in 3 Sätzen.")
])
print(response.content)
# Streaming für lange Outputs
for chunk in llm.stream([HumanMessage(content="Schreibe eine FastAPI-Route.")]):
print(chunk.content, end="", flush=True)
Tipp: Setze ANTHROPIC_API_KEY in deiner .env-Datei und lade sie mit python-dotenv. LangChain liest den Key automatisch aus der Umgebung wenn du den api_key-Parameter weglässt.
Prompt-Templates erlauben parametrisierbare, wiederverwendbare Prompts — das Fundament für Chains:
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
# Strukturiertes Template mit Variablen
prompt = ChatPromptTemplate.from_messages([
("system", "Du bist ein {rolle} mit Expertise in {thema}."),
("human", "{frage}"),
])
# Formatieren und aufrufen
chain = prompt | llm
result = chain.invoke({
"rolle": "Senior Python-Entwickler",
"thema": "async/await und Concurrency",
"frage": "Wann nutze ich asyncio.gather vs asyncio.TaskGroup?"
})
print(result.content)
Chains: SequentialChain und LLMChain für strukturierte Pipelines
Das Herzstück von LangChain ist das LCEL — LangChain Expression Language. Pipes (|) verbinden Komponenten zu ausführbaren Chains. Jede Komponente empfängt den Output der vorherigen als Input.
Praxisbeispiel: Mehrstufige Analyse-Pipeline
Ein typischer Use-Case: Dokument zusammenfassen → Kernpunkte extrahieren → strukturierte Ausgabe generieren.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-opus-4-5", temperature=0)
# Schritt 1: Zusammenfassung
summarize_prompt = ChatPromptTemplate.from_template(
"Fasse folgenden Text in 3 Sätzen zusammen:\n\n{text}"
)
# Schritt 2: Kernpunkte extrahieren
keypoints_prompt = ChatPromptTemplate.from_template(
"Extrahiere 5 Kernaussagen aus dieser Zusammenfassung als JSON-Liste:\n\n{summary}"
)
# Chain mit LCEL (|) zusammenbauen
summarize_chain = summarize_prompt | llm | StrOutputParser()
keypoints_chain = keypoints_prompt | llm | JsonOutputParser()
# Sequential: Output von Schritt 1 geht in Schritt 2
full_pipeline = (
{"text": lambda x: x["text"]}
| summarize_chain.with_config({"run_name": "Zusammenfassung"})
| (lambda summary: {"summary": summary})
| keypoints_chain
)
# Ausführen
langer_text = "... dein langer Artikel oder Report ..."
kernpunkte = full_pipeline.invoke({"text": langer_text})
print(kernpunkte) # → ["Punkt 1", "Punkt 2", ...]
Für parallele Ausführung mehrerer Chains auf demselben Input nutzt du RunnableParallel:
from langchain_core.runnables import RunnableParallel
# Gleichzeitig: Zusammenfassung UND Sentiment UND Kategorie
parallel_chain = RunnableParallel(
zusammenfassung=summarize_chain,
sentiment=(
ChatPromptTemplate.from_template("Bewerte das Sentiment (positiv/neutral/negativ): {text}")
| llm | StrOutputParser()
),
kategorie=(
ChatPromptTemplate.from_template("Kategorisiere den Text in einem Wort: {text}")
| llm | StrOutputParser()
),
)
# Alle 3 laufen parallel — spart Zeit!
results = parallel_chain.invoke({"text": langer_text})
# → {"zusammenfassung": "...", "sentiment": "positiv", "kategorie": "Technologie"}
Performance-Tipp: RunnableParallel führt alle Branches gleichzeitig aus. Bei API-Calls mit Ratenlimits beachte, dass mehrere Requests simultan gesendet werden — plane entsprechend mit max_concurrency.
RAG mit LangChain: Document Loaders, Text Splitters, VectorStores und Retrievers
RAG (Retrieval-Augmented Generation) ist der häufigste Produktions-Use-Case für LangChain. Die Idee: eigene Dokumente vektorisieren, ähnliche Passagen bei jeder Anfrage abrufen, als Kontext an Claude übergeben.
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
# 1. Dokumente laden (PDF, DOCX, TXT, Web — 80+ Loader verfügbar)
loader = DirectoryLoader("./docs/", glob="**/*.pdf", loader_cls=PyPDFLoader)
docs = loader.load()
print(f"Geladen: {len(docs)} Seiten")
# 2. Text in Chunks aufteilen (Chunk-Size ist wichtig!)
splitter = RecursiveCharacterTextSplitter(
chunk_size=800, # Tokens pro Chunk — nicht zu groß!
chunk_overlap=100, # Überlapp für Kontext-Kontinuität
separators=["\n\n", "\n", ".", " "]
)
chunks = splitter.split_documents(docs)
print(f"Erstellt: {len(chunks)} Chunks")
# 3. Embeddings + VectorStore erstellen (lokal, kein API-Key nötig)
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vectorstore = FAISS.from_documents(chunks, embeddings)
vectorstore.save_local("./vectorstore_index")
# 4. Retriever konfigurieren
retriever = vectorstore.as_retriever(
search_type="similarity",
search_kwargs={"k": 4} # Top-4 relevanteste Chunks
)
Mit dem Retriever baust du die eigentliche RAG-Chain:
# 5. RAG-Chain zusammenbauen
rag_prompt = ChatPromptTemplate.from_template("""
Beantworte die Frage basierend ausschließlich auf folgendem Kontext.
Wenn die Antwort nicht im Kontext steht, sage "Dazu habe ich keine Information."
Kontext:
{context}
Frage: {question}
Antwort:""")
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| rag_prompt
| llm
| StrOutputParser()
)
# Anfrage stellen — Claude antwortet nur mit Wissen aus deinen Docs
antwort = rag_chain.invoke("Was sind die Kündigungsfristen im Vertrag?")
print(antwort)
Chunk-Size-Falle: Zu große Chunks (>1500 Tokens) schicken irrelevante Passagen an Claude und erhöhen die Kosten. Zu kleine Chunks (<200 Tokens) verlieren Kontext. Optimum: 600–900 Tokens mit 10–15% Überlapp. Teste mit deinen spezifischen Dokumenten.
Agents mit LangChain: ReAct-Pattern und Tools definieren
Agents sind der mächtigste — und komplexeste — Teil von LangChain. Ein Agent entscheidet eigenständig welche Tools er aufruft, wertet Ergebnisse aus und iteriert bis zur Antwort. Das ReAct-Pattern (Reasoning + Acting) gibt Claude dabei strukturierte Denkschritte: Thought → Action → Observation → Thought...
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.tools import tool
from langchain import hub
import requests, datetime
# Tools mit @tool-Decorator definieren
@tool
def suche_unternehmen(name: str) -> str:
"""Sucht Informationen zu einem Unternehmen via externe API."""
# Beispiel: eigene DB-Abfrage oder Web-API
response = requests.get(f"https://api.example.com/company?q={name}", timeout=10)
return response.json().get("description", "Kein Ergebnis")
@tool
def heutiges_datum() -> str:
"""Gibt das heutige Datum zurück."""
return datetime.date.today().isoformat()
@tool
def berechne(ausdruck: str) -> str:
"""Berechnet mathematische Ausdrücke sicher. Eingabe z.B. '(12 * 8) / 3'."""
try:
return str(eval(ausdruck, {"__builtins__": {}}, {}))
except Exception as e:
return f"Fehler: {e}"
tools = [suche_unternehmen, heutiges_datum, berechne]
# ReAct-Prompt aus LangChain Hub laden (oder eigenen definieren)
react_prompt = hub.pull("hwchase17/react")
# Agent erstellen
agent = create_react_agent(llm, tools, react_prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True, # Zeigt Reasoning-Schritte
max_iterations=5, # Verhindert Endlosschleifen
handle_parsing_errors=True
)
# Agent ausführen
result = agent_executor.invoke({
"input": "Was kostet ein Projekt mit 45 Stunden à €85? Welches Datum ist heute?"
})
print(result["output"])
Tool-Docstrings sind der Schlüssel
Claude entscheidet anhand des Docstrings ob und wie es ein Tool verwendet. Präzise, beschreibende Docstrings (was tut das Tool, welche Eingabe erwartet es, was gibt es zurück) verbessern die Tool-Auswahl dramatisch. Vage Beschreibungen führen zu falschen oder fehlenden Tool-Calls.
Für Agents die Konversationshistorie behalten, nutze create_react_agent mit Memory:
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
memory_key="chat_history",
k=10, # Letzte 10 Nachrichten behalten
return_messages=True
)
agent_executor_mit_memory = AgentExecutor(
agent=agent, tools=tools, memory=memory,
verbose=False, max_iterations=5
)
# Konversation über mehrere Turns
agent_executor_mit_memory.invoke({"input": "Suche Infos zu OpenAI."})
agent_executor_mit_memory.invoke({"input": "Wie viele Mitarbeiter hat das Unternehmen?"})
# Agent weiß noch, dass es um OpenAI geht!
Wann LangChain NICHT nutzen: Overhead und Alternativen
LangChain ist mächtig — aber nicht für jeden Use-Case die beste Wahl. Die Abstraktion hat einen Preis: mehr Dependencies, tiefere Callstacks, schwierigeres Debugging wenn etwas schiefläuft.
Finger weg von LangChain wenn:
- Du nur einzelne API-Calls machst — das Anthropic SDK ist schlanker und direkter
- Du maximale Kontrolle über Prompts und Parsing brauchst — keine Abstraktionsschicht dazwischen
- Du Performance-kritische Produktionssysteme baust — LangChain-Chains haben messbaren Overhead durch Serialisierung und Callback-Mechanismen
- Dein Team LangChain nicht kennt — die Lernkurve ist steil, Debugging oft frustrierend
- Du nur einen LLM-Provider nutzt und kein Provider-Wechsel geplant ist
# DIREKTES SDK — einfacher, transparenter, schneller für einfache Fälle
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-opus-4-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Erkläre Closures in Python."}]
)
print(message.content[0].text)
# Kein Import-Overhead, kein Prompt-Template-Wrapper, kein Output-Parser
# → Für einfache Tasks ist das alles was du brauchst
LangChain-Versionen: LangChain hat seit 2023 mehrere Breaking Changes durchgemacht (LangChain v0.1 → v0.2 → v0.3). Nutze immer langchain-core und langchain-anthropic direkt statt dem veralteten monolithischen langchain-Paket für neue Projekte. Check regelmäßig die Changelogs.
Die pragmatische Faustregel: Starte mit dem direkten Anthropic-SDK. Wenn du merkst dass du Patterns wiederholst (Prompt-Templates, Output-Parsing, Kontext-Verkettung) und dein System aus 3+ Schritten besteht — dann ist der Umstieg auf LangChain sinnvoll.
Fazit: LangChain + Claude als Produktions-Kombination
Claude über LangChain zu nutzen gibt dir das beste beider Welten: Claudes überragende Reasoning-Qualität gepaart mit LangChains ausgreiftem Ökosystem für RAG, Chains und Agents. Die Kombination ist particularly stark für:
- Unternehmens-RAG: Interne Wissensdatenbanken, Policy-Dokumente, Support-Systeme
- Analyse-Pipelines: Mehrstufige Verarbeitung von Berichten, E-Mails, Tickets
- Autonome Agents: Tool-Calling für Datenbank-Queries, API-Calls, Kalender-Management
Der konkrete nächste Schritt: Clone eines der LangChain-Templates (langchain app new my-rag-app --package rag-chroma), tausche den Standard-LLM gegen ChatAnthropic aus, und du hast in 20 Minuten eine funktionsfähige RAG-App mit Claude im Backend.
KI-Pipelines produktiv einsetzen?
Wir helfen Unternehmen bei der Implementierung von LangChain + Claude — von der Architektur bis zur Produktion.
14 Tage kostenlos starten →