Claude Code & LangChain: LLM-Anwendungen mit Python produktiv bauen

LangChain ist das meistgenutzte Python-Framework für LLM-Anwendungen — nicht weil es das einfachste ist, sondern weil es alle zentralen Bausteine moderner KI-Apps unter einem Dach vereint: Chains, Agents, Tools, Memory und Prompt-Management. Wer mit Claude Code arbeitet, hat dabei einen entscheidenden Vorteil: Claude Code versteht LangChain-Code auf einer strukturellen Ebene, kann Chains debuggen, Prompts optimieren und komplexe Agent-Setups auf Anhieb korrekt verdrahten.

Dieser Artikel zeigt die zentralen LangChain-Konzepte — von der Installation bis zu produktionsreifen Agents — und erklärt, wo Claude Code als Entwicklungspartner konkret Zeit spart.

1. Was ist LangChain?

LangChain ist ein Open-Source-Framework das die Bausteine für LLM-getriebene Anwendungen bereitstellt. Es abstrahiert die direkte API-Kommunikation mit Sprachmodellen und bietet stattdessen wiederverwendbare Komponenten:

• Chains: Sequenzen von Schritten — Prompt → LLM → Output Parser → nächster Schritt
• Agents: LLMs die selbst entscheiden, welche Tools sie in welcher Reihenfolge aufrufen
• Tools: Funktionen die ein Agent aufrufen kann — Websuche, Taschenrechner, Datenbankabfragen
• Memory: Gesprächsverlauf und Kontext der zwischen Aufrufen erhalten bleibt
• Prompt Templates: Wiederverwendbare, parametrisierbare Prompts mit Variablen

Die Installation ist schnell erledigt:

pip install langchain langchain-anthropic langchain-openai
pip install langchain-community  # Tools, Retriever, Integrationen

2. LLMs einbinden: ChatAnthropic und ChatOpenAI

Der erste Schritt ist immer die Anbindung eines Sprachmodells. LangChain abstrahiert die Unterschiede zwischen Providers — ChatAnthropic und ChatOpenAI haben dieselbe Schnittstelle:

from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI

# Claude 3.5 Sonnet über Anthropic
llm_claude = ChatAnthropic(
    model="claude-sonnet-4-5",
    temperature=0,
    api_key="...",  # oder ANTHROPIC_API_KEY aus .env
)

# GPT-4o als Alternative
llm_openai = ChatOpenAI(
    model="gpt-4o",
    temperature=0,
)

# Direkter Aufruf
response = llm_claude.invoke("Erkläre mir LCEL in einem Satz.")
print(response.content)

Der Vorteil der gemeinsamen Schnittstelle: du kannst Providers austauschen ohne den Rest deines Codes anzufassen. Claude Code hilft dabei, den richtigen Provider für deinen Use Case zu wählen — einfach beschreiben, was du brauchst, und es empfiehlt Modell und Parameter.

3. Prompt Templates und Output Parser

Hardcodierte Strings in Prompts sind ein Anti-Pattern. ChatPromptTemplate macht Prompts wiederverwendbar, testbar und versionierbar:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel

# Einfaches String-Template
template = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent für {domain}."),
    ("human", "{frage}"),
])

# Strukturierter Output mit Pydantic
class Analyse(BaseModel):
    zusammenfassung: str
    schluesselwoerter: list[str]
    sentiment: str

json_parser = JsonOutputParser(pydantic_object=Analyse)

structured_template = ChatPromptTemplate.from_messages([
    ("system", "Analysiere den Text und antworte als JSON.\n{format_instructions}"),
    ("human", "{text}"),
]).partial(format_instructions=json_parser.get_format_instructions())

4. Chains mit LCEL (LangChain Expression Language)

LCEL ist das Herzstück moderner LangChain-Anwendungen. Der Pipe-Operator | verbindet Komponenten zu einer Chain — lesbar, komponierbar und lazy-evaluated:

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatAnthropic(model="claude-sonnet-4-5", temperature=0)

# Einfache Chain: Prompt | LLM | Parser
chain = (
    ChatPromptTemplate.from_template("Übersetze ins Englische: {text}")
    | llm
    | StrOutputParser()
)

result = chain.invoke({"text": "Guten Morgen, die Welt ist schön."})
print(result)  # Good morning, the world is beautiful.

# Chains verketten
zusammenfassen = (
    ChatPromptTemplate.from_template("Fasse in einem Satz zusammen: {text}")
    | llm
    | StrOutputParser()
)

uebersetzen = (
    ChatPromptTemplate.from_template("Übersetze ins Englische: {text}")
    | llm
    | StrOutputParser()
)

# Zwei Chains hintereinander
pipeline = zusammenfassen | (lambda x: {"text": x}) | uebersetzen

LCEL unterstützt Streaming, Batching und asynchrone Ausführung ohne Codeänderungen — einfach chain.stream() statt chain.invoke() aufrufen. Claude Code schreibt LCEL-Chains korrekt auf Anhieb, weil es das Kompositionsmuster versteht.

5. Agents und Tools

Agents gehen über einfache Chains hinaus: das LLM entscheidet selbst, welche Tools es aufruft und in welcher Reihenfolge. Das ist nützlich wenn die Lösung nicht linear ist oder externe Daten benötigt werden.

from langchain_anthropic import ChatAnthropic
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_community.tools.wolfram_alpha import WolframAlphaQueryRun
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

llm = ChatAnthropic(model="claude-sonnet-4-5", temperature=0)

# Tools definieren
search = DuckDuckGoSearchRun()

# Eigenes Tool mit Decorator
from langchain.tools import tool

@tool
def rechner(ausdruck: str) -> str:
    """Berechnet einen mathematischen Ausdruck. Eingabe: z.B. '2 ** 10 + 5'"""
    try:
        return str(eval(ausdruck, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"Fehler: {e}"

tools = [search, rechner]

# Agent erstellen
prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent mit Zugriff auf Suche und Rechner."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "Was ist die Einwohnerzahl von Berlin, und wie viel ist das hoch 2?"
})

6. Memory: Gesprächskontext erhalten

Ohne Memory behandelt LangChain jede Anfrage als isoliert. Für echte Konversations-Apps brauchst du Memory — zwei Varianten decken die meisten Fälle ab:

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-4-5", temperature=0)

# Option 1: Gesamten Verlauf behalten (kurze Gespräche)
buffer_memory = ConversationBufferMemory(
    return_messages=True,
    memory_key="chat_history"
)

# Option 2: Zusammenfassung statt Volltext (lange Gespräche)
summary_memory = ConversationSummaryMemory(
    llm=llm,
    return_messages=True,
    memory_key="chat_history"
)

# Memory in eine Chain integrieren
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory

store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])

chain = prompt | llm

chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

# Konversation mit persistentem Kontext
chain_with_history.invoke(
    {"input": "Mein Name ist Anna."},
    config={"configurable": {"session_id": "user-1"}}
)

chain_with_history.invoke(
    {"input": "Wie ist nochmal mein Name?"},
    config={"configurable": {"session_id": "user-1"}}
)
# Antwort: "Dein Name ist Anna."

ConversationBufferMemory speichert den kompletten Verlauf — ideal für kurze Sessions, aber bei langen Gesprächen wächst der Kontext und damit die Kosten pro Anfrage. ConversationSummaryMemory komprimiert ältere Teile des Gesprächs durch das LLM selbst und hält den Kontext kompakt.

7. Claude Code Tipps: Chains debuggen und Prompts optimieren

LangChain-Fehler sind oft nicht selbsterklärend — ein ValidationError aus Pydantic, ein OutputParserException oder ein Agent der im Loop steckt. Claude Code hilft hier auf drei Arten:

Chains mit LangSmith tracing debuggen

# LangSmith für vollständiges Tracing aktivieren
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "..."

# Claude Code kann den Trace-Output analysieren:
# claude "Dieser Agent ruft das search-Tool dreimal auf und gibt dann
# trotzdem 'Ich konnte keine Antwort finden' zurück.
# Hier ist der verbose-Output: [...]"

Prompt-Qualität systematisch verbessern

# Schlechter Prompt (zu vage):
prompt_schlecht = "Analysiere den Text."

# Besser: Claude Code um Verbesserung bitten:
# claude "Optimiere diesen System-Prompt für eine Sentiment-Analyse-Chain.
# Das LLM gibt aktuell inkonsistente Formate zurück: [Beispiele]"

# Ergebnis: strukturierter, mit Output-Format-Vorgabe
prompt_gut = """Analysiere den folgenden Text auf Sentiment.

Antworte IMMER im JSON-Format:
{{"sentiment": "positiv|negativ|neutral", "staerke": 0.0-1.0, "begruendung": "..."}}

Kein erklärender Text außerhalb des JSON."""

Output-Parser-Fehler beheben

# Typischer Fehler: LLM antwortet nicht streng JSON
# Claude Code findet die Ursache wenn du fragst:
# claude "JsonOutputParser wirft OutputParserException: 'Expected ',' delimiter'.
# Der Prompt ist: [Prompt]. Die LLM-Antwort ist: [Antwort]."

# Lösung: OutputFixingParser als Fallback
from langchain.output_parsers import OutputFixingParser

fixing_parser = OutputFixingParser.from_llm(
    parser=json_parser,
    llm=llm
)
# Versucht automatisch, malformed Output zu reparieren

"Ich habe einen Agent der eine Websuche machen soll, aber er ruft das Tool nicht auf — er antwortet direkt aus seinem Trainingswissen. Was ist falsch?" — Diese Frage beantwortet Claude Code in Sekunden: meistens fehlt {"agent_scratchpad": []} im Prompt-Template, oder das Tool ist nicht korrekt als Callable registriert.

Der größte Zeitgewinn beim Einsatz von Claude Code für LangChain-Entwicklung liegt nicht im Code-Schreiben — der liegt im Diagnoseprozess. LangChain-Fehler haben oft mehrere Schichten: der sichtbare Fehler ist selten die eigentliche Ursache. Claude Code kann einen kompletten Stack Trace, den Prompt, das Chain-Setup und den LLM-Output gleichzeitig lesen und die Root Cause direkt benennen.

Zwei verwandte Artikel die auf diesem Thema aufbauen:

• Claude Code für Python-Projekte — Claude Code in Python-Workflows integrieren
• Claude Code Debugging — Bugs systematisch finden und beheben