Die Feinheiten von LangChain Chains: Die Kraft moderner KI-Workflows entfesseln

Name

Akira Sakamoto

Updated on 14.11.2025

LangChain entwickelt sich rasant weiter, und Chains bleiben eines seiner zentralen Konzepte. In diesem aktualisierten Leitfaden werfen wir einen Blick darauf, was LangChain Chains im Jahr 2025 eigentlich bedeuten, wie sie mit der neuen LCEL (LangChain Expression Language) funktionieren und wie sie Entwickler:innen helfen, verlässliche, mehrstufige KI-Anwendungen zu bauen.

Dieser Artikel aktualisiert alle Beispiele auf die modernen LangChain-Standards und ersetzt veraltete Klassen wie LLMChain durch Runnables, PromptTemplate, ChatModels und sequentielle Pipelines.

Was ist LangChain? (Überblick 2025)

LangChain ist ein leistungsfähiges Python/JavaScript-Framework, das Entwickler:innen dabei unterstützt, KI-Anwendungen zu erstellen – unter anderem mit:

• Large Language Models (LLMs)
• Prompt-Templates
• Memory
• Tools & Agents
• Retrieval (RAG)
• Workflow-Graphs (LangGraph)

Das ikonischste Konzept von LangChain ist die Chain:

eine wiederverwendbare, komponierbare Pipeline, die Daten Schritt für Schritt durch Prompts, Modelle, Tools, Transformationen und Output-Parser weitergibt.

📘 Du brauchst eine grundlegende Einführung? Lies unseren LangChain-Einführungsartikel.

Was sind LangChain Chains?

Im Jahr 2023 wurden Chains häufig mit LLMChain und eigenen Python-Klassen erstellt.
Im Jahr 2025 ist der empfohlene Ansatz LCEL, das eine klare, funktionale Pipeline-Syntax verwendet:

chain = prompt | model | output_parser

Eine Chain ist einfach:

• eine Abfolge von Schritten,
• verbunden zu einer einzigen aufrufbaren Einheit,
• wobei der Output eines Schritts zum Input des nächsten Schritts wird.

LangChain bietet heute:

• Einfache Chains (ein Modell + ein Prompt)
• Sequentielle Chains (mehrere Schritte)
• Parallele Chains (verzweigte Workflows)
• Agents (dynamische, tool-wählende Chains)

Schauen wir uns moderne Beispiele an.

Basis-Chains (aktualisiert für 2025)

Eine Basis-Chain löst ein einzelnes Modell mit einem Prompt aus.

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
prompt = PromptTemplate.from_template(
    "Describe a perfect day in {city}."
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
chain = prompt | model
 
chain.invoke({"city": "Paris"})

Was passiert hier?

1. PromptTemplate formatiert "Describe a perfect day in Paris."
2. Das LLM generiert die Beschreibung
3. Das Ergebnis wird als ChatMessage oder String zurückgegeben – je nach Konfiguration

Dies ist die einfachste mögliche Chain im modernen LangChain.

Fortgeschrittene Chains: Mehrstufige Pipelines

Mehrstufige Chains kombinieren mehrere Operationen.

Beispiel: Zusammenfassen → Übersetzen mit LCEL:

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
summarize_prompt = PromptTemplate.from_template(
    "Summarize this text:\n\n{text}"
)
 
translate_prompt = PromptTemplate.from_template(
    "Translate this into Spanish:\n\n{summary}"
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
summarize_chain = summarize_prompt | model
translate_chain = translate_prompt | model
 
full_chain = summarize_chain | (lambda x: {"summary": x.content}) | translate_chain
 
full_chain.invoke({"text": "Climate change is causing rapid ocean warming..."})

Warum das wichtig ist

Das spiegelt die modernen Best Practices in LangChain wider:

• Runnables statt der alten Chain-Klassen
• Funktionale Komposition mit |
• Zwischen-Daten-Mapping mit Python-Funktionen

Chains ohne LLMs (Transformations- und Cleaning-Pipelines)

Nicht jede Chain braucht ein LLM. Du kannst Preprocessing- oder Postprocessing-Pipelines aufbauen.

Beispiel: Whitespace trimmen → in Kleinbuchstaben umwandeln → an LLM weitergeben:

def cleanup(text):
    return text.strip().lower()
 
chain = cleanup | model
chain("   WHAT is the    WEATHER   LIKE?   ")

Jede Python-Funktion kann in eine Chain eingefügt werden, solange sie serialisierbare Daten entgegennimmt und zurückgibt.

Sequentielle Chains (Ersatz für SimpleSequentialChain)

SimpleSequentialChain und SequentialChain sind veraltet.
Das LCEL-Äquivalent ist einfach:

chain = step1 | step2 | step3

Beispiel: Prompt bereinigen → umformulieren → beantworten

from langchain_openai import ChatOpenAI
 
clean = lambda x: x.strip()
rewrite_prompt = PromptTemplate.from_template(
    "Rewrite this more clearly: {text}"
)
answer_prompt = PromptTemplate.from_template(
    "Answer this question: {question}"
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
rewrite_chain = rewrite_prompt | model
answer_chain = answer_prompt | model
 
chain = clean | (lambda x: {"text": x}) | rewrite_chain | (lambda x: {"question": x.content}) | answer_chain
 
chain.invoke("   What is LangChain used for?  ")

Dies ist der moderne Ersatz für SimpleSequentialChain.

Die Rolle von Agents in LangChain (Edition 2025)

Agents ermöglichen es LLMs, Tools dynamisch auszuwählen:

• Suchmaschinen
• Codeausführung
• Taschenrechner
• APIs
• Retriever
• Eigene Funktionen

Beispiel (moderne Syntax):

from langchain.agents import AgentExecutor, load_tools, create_react_agent
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-4o-mini")
tools = load_tools(["llm-math"], llm=llm)
 
agent = create_react_agent(llm, tools)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
executor.invoke({"input": "If I'm half my dad's age and he'll be 60 next year, how old am I?"})

Agents sind besonders dann sinnvoll, wenn die Aufgabe Folgendes erfordert:

• Reasoning
• Auswahl der passenden Tools
• Mehrere Entscheidungsschritte

Für feste Workflows ist eine einfache Chain oft die bessere Wahl.

Praxisbeispiel: Ein Movie-Recommendation-Workflow (aktualisiert)

Wir modernisieren dein Beispiel mit zwei LLMs mithilfe von LCEL.

Schritt 1 – Nutzer nach Genres fragen

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
ask_prompt = PromptTemplate.from_template(
    "Ask the user about their favorite movie genres."
)
 
ask_chain = ask_prompt | ChatOpenAI(model="gpt-4o-mini")

Schritt 2 – Filme empfehlen

recommend_prompt = PromptTemplate.from_template(
    "Based on these genres: {genres}, recommend 5 movies."
)
 
recommend_chain = recommend_prompt | ChatOpenAI(model="gpt-4o-mini")

Kombination

chain = ask_chain | (lambda x: {"genres": x.content}) | recommend_chain
chain.invoke({})

Memory hinzufügen (modern)

from langchain.memory import ConversationBufferMemory
 
memory = ConversationBufferMemory(return_messages=True)
 
# pipelines can load memory before passing to next step

Fazit

Das moderne LangChain (2024–2025) macht es so einfach wie nie zuvor, skalierbare KI-Workflows mit LCEL-Pipelines, Runnables und Agents zu bauen. Egal ob du:

• Text vorverarbeitest,
• mehrstufige Workflows erstellst,
• Tools integrierst oder
• dynamische Agents aufsetzt –

LangChain stellt dir die Bausteine zur Verfügung, um alles sauber und zuverlässig zu verbinden.

Experimentiere frei – aus einfachen Chains können schnell leistungsfähige KI-Anwendungen werden.

FAQ (aktualisiert)

1. Was ist LangChain?
   LangChain ist ein Framework zum Erstellen von KI-Anwendungen auf Basis von Prompts, Modellen, Tools, Memory und Workflow-Graphs.

2. Was ersetzt SimpleSequentialChain?
   LCEL-Pipelines, die für sequentielle Verarbeitung den |-Operator nutzen.

3. Wie füge ich Memory hinzu?
   Verwende ConversationBufferMemory, SummaryMemory oder eigene Memory-Lösungen, die du in deine Chain einspeist.

4. Sind Agents noch nützlich?
   Ja – immer dann, wenn dynamische Tool-Auswahl nötig ist. Für feste Schritte sind Chains übersichtlicher.

5. Wo kann ich mehr lernen?
   Sieh dir die LangChain-Dokumentation an oder erkunde LangGraph für agentenbasierte Workflows und Orchestrierung.