LangChain: Das Agenten-Framework, das den Vendor-Lock-in beendete

LangChain: Das Agenten-Framework, das den Vendor-Lock-in beendete

Jahrelang bedeutete der Aufbau eines KI-Agenten, sich für einen Anbieter zu entscheiden und mit den Konsequenzen zu leben. OpenAIs SDK, Anthropics SDK, Googles SDK — jedes mit eigenen Klassen, eigenem Nachrichtenformat, eigenen Retry-Semantiken. Wechselte man den Anbieter, schrieb man die Anwendung neu. LangChain 1.0, stabil veröffentlicht am 22. Oktober 2025, wurde entwickelt, um dieses Problem zu lösen: ein Import-Pfad, eine API und eine einzige Funktion namens create_agent , die ein Modell, Werkzeuge, Memory und Middleware zu einem ausführbaren Agenten verbindet. Dieser Artikel ist der vollständige Überblick darüber, was das in der Praxis bedeutet — das Ökosystem, die Einrichtung und alle zentralen Funktionen, von einem Wetter-Tool bis zu strukturierten Ausgaben, Memory, multimodalen Eingaben, RAG und dem Middleware-System, das 1.0 wirklich einzigartig macht. Er behandelt auch, was seit dem Launch hinzugekommen ist — die Release-Linie hat sich schnell weiterentwickelt, und die aktuelle Version, langchain v1.4.0 (1. September 2026), bringt erstklassige Model Context Protocol (MCP)-Unterstützung in das Core-Paket.

Wechseln Sie morgen von OpenAI zu Anthropic, und Ihr Agenten-Code ändert sich kaum. Das ist der ganze Sinn von LangChain 1.0.

Das Ökosystem: Deep Agents, LangChain und LangGraph

Bevor es an den Code geht, lohnt es sich, die Bestandteile des modernen LangChain-Ökosystems präzise zu benennen, denn die Begriffe werden oft synonym verwendet — und sind es nicht. Seit 2026 besteht der Open-Source-Stack aus drei Schichten — Deep Agents, LangChain und LangGraph — plus der Observability-Plattform LangSmith. Sie sind vollständig kombinierbar, sodass Sie zwischen den Schichten wechseln, statt sich für eine zu entscheiden.

• Deep Agents — das sofort einsatzbereite Agenten-Gerüst, gestartet im Juli 2025. Seine Aufgabe ist Context Engineering: dem Modell zur richtigen Zeit den richtigen Kontext zu liefern. Es bringt ein Dateisystem zum Lesen und Schreiben von Kontext mit, Subagenten für spezialisierte Aufgaben ohne Aufblähung des Haupt-Kontextfensters, Skills, die der Agent bei Bedarf lädt, und Memory über mehrere Durchläufe hinweg. Gestartet wird mit create_deep_agent. Fun Fact: Deep Agents ist im Grunde der Kern-LangChain-Agent plus ein Haufen Middleware.
• LangChain — das Agenten-Framework: die Abstraktions- und Integrationsschicht. Es liefert ein minimales, unvoreingenommenes Agenten-Gerüst — ein LLM, das in einer Schleife läuft und Werkzeuge aufruft. Die zentrale Abstraktion ist create_agent, und sein Middleware-System ist der Weg, diese Schleife zu modifizieren. Diese Schicht ist Gegenstand dieses Artikels.
• LangGraph — die Agenten-Laufzeitumgebung: ein graphenbasiertes Framework für individuelle Agenten-Workflows, gestützt auf eine robuste Engine mit Human-in-the-Loop, Fehlertoleranz und Observability in jedem Schritt. Es bildet die Grundlage für die Agenten-Abstraktionen in LangChain und Deep Agents. Eine bestimmte LangGraph-Klasse, der InMemorySaver Checkpointer, verleiht Agenten Memory.
• LangSmith — eine Sammlung von Werkzeugen zur Beobachtung, Evaluierung, Überwachung und zum Deployment von Modellen. Es ist die Observability-Schicht, nicht die Build-Schicht, und liegt außerhalb des Fokus dieses Artikels.

Die Faustregel des LangChain-Teams: Beginnen Sie mit Deep Agents, wenn Sie einen Agenten wollen, der ohne weitere Einrichtung einsatzfähig ist; greifen Sie zu LangChain, wenn Sie die grundlegenden Bausteine und präzise Kontrolle darüber benötigen, welche Werkzeuge und welcher Kontext zum Modell gelangen; nutzen Sie LangGraph, wenn Ihr Agent nicht in eine Standard-Schleife passt oder Sie deterministische und agentische Schritte kombinieren müssen. Der entscheidende Wandel in 1.0 besteht darin, dass LangChain kein allgemeines Toolkit mehr für Modelle, Vektorspeicher und Werkzeuge ist, sondern eine bibliothek zum Aufbau von Agenten. Die Agenten-Seite, die früher in LangGraph angesiedelt war, hat nun eine erstklassige Heimat in create_agent. Die alten Provider-spezifischen Pakete existieren weiterhin, aber für die meisten Anwendungsfälle reicht das Hauptpaket langchain aus.

Einrichtung: uv, Provider-Extras und API-Schlüssel

Die moderne Methode, LangChain zu installieren, ist mit uv, dem Rust-basierten Python-Paketmanager — pip funktioniert aber ebenso, falls Sie es bevorzugen. Das Einzige, was Sie unbedingt richtig machen müssen, sind die Provider-Extras. LangChain selbst ist Provider-agnostisch, aber um tatsächlich ein Modell aufzurufen, benötigen Sie das Integrationspaket für den jeweiligen Anbieter, das Sie mit eckigen Klammern einbinden:

uv add "langchain[openai]"

Diese eine Zeile installiert langchain plus langchain-openai und den OpenAI-Client. Dasselbe machen Sie für jeden Anbieter, den Sie nutzen möchten — langchain[anthropic], langchain[mistralai], langchain[google-genai]. Dann erstellen Sie eine .env Datei mit Ihren API-Schlüsseln (OPENAI_API_KEY, ANTHROPIC_API_KEYusw.) und laden sie mit python-dotenv. Ein Modell-String wie "gpt-4.1-mini" wird automatisch als OpenAI erkannt — allerdings nur, wenn langchain-openai installiert ist UND ein OPENAI_API_KEY in der Umgebung vorhanden ist. Fehlt eines von beiden, schlägt der Aufruf erst zur Laufzeit fehl, nicht beim Import.

Ihr erster Agent: ein Wetter-Werkzeug

Am schnellsten verstehen Sie 1.0, wenn Sie einen echten Agenten bauen, keinen Mock. Das klassische Beispiel ist ein Wetter-Assistent, der eine kostenlose API ohne Konto abfragt. Der @tool Decorator verwandelt eine einfache Funktion in ein Werkzeug, das der Agent aufrufen kann, und create_agent ist die zentrale Funktion, die alles verbindet:

import requests
from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain.tools import tool

load_dotenv()

@tool
def get_weather(city: str) -> str:
    """Return weather information for a given city."""
    response = requests.get(f"https://wttr.in/{city}?format=j1")
    return response.json()

agent = create_agent(
    model="gpt-4.1-mini",
    tools=[get_weather],
    system_prompt="You are a helpful weather assistant who always cracks jokes and is humorous while remaining helpful.",
)

response = agent.invoke({
    "messages": [{"role": "user", "content": "What is the weather like in Vienna?"}]
})
print(response["messages"][-1].content)

Ein paar Dinge fallen auf. Der @tool Decorator kann eine Beschreibung enthalten, damit der Agent weiß, was die Funktion tut, und ein return_direct Flag, wenn das Werkzeug-Rohresultat direkt an den Nutzer zurückgegeben werden soll, statt an das Modell weitergeleitet zu werden. Der Agent wird mit einem Dictionary aufgerufen, das eine messages Liste enthält — dieselbe role/content-Struktur wie bei den nativen APIs. Das Antwort-Objekt enthält den gesamten Nachrichtenverlauf, und response["messages"][-1].content extrahiert die finale Antwort. Führen Sie es aus, erhalten Sie einen witzigen Wiener Wetterbericht: teils bewölkt, rund 15 °C, mit Wind und Luftfeuchtigkeit.

Einzelne Modelle, Gespräche und Streaming

Nicht immer brauchen Sie einen Agenten. Manchmal möchten Sie einfach abstrakt mit einem Modell sprechen, und dafür bietet 1.0 init_chat_model — eine Funktion, die das Chat-Modell jedes Anbieters anhand eines Modell-Strings initialisiert:

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4.1-mini", temperature=0.1)
response = model.invoke("Hello, what is Python?")
print(response.content)

Tauschen Sie den Modell-String gegen "mistral-medium" aus, bleibt der Rest der Anwendung unverändert — das ist die Abstraktion in Aktion. Für mehrstufige Gespräche können Sie entweder die Listen-und-Dictionary-Notation verwenden oder die Nachrichten-Klassen HumanMessage, AIMessageund SystemMessage aus langchain.messages und erstellen eine Gesprächsübersicht. Bei langen Antworten können Sie diese Token für Token streamen, statt auf das gesamte Ergebnis zu warten:

for chunk in model.stream("Explain quantum computing."):
    print(chunk.content, end="", flush=True)

Streaming verwandelt eine lange Wartezeit in ein Echtzeit-Mitlesen — entscheidend für jede interaktive Anwendung.

Der fortgeschrittene Agent: Kontext, strukturierte Ausgabe und Gedächtnis

Die eigentliche Stärke von 1.0 zeigt sich, wenn Sie drei Fähigkeiten in einem Agenten kombinieren: typisierten Kontext, strukturierte Ausgabe und Gedächtnis. Das Ergebnis ist ein Agent, der weiß, wo Sie sich befinden, ohne dass Sie es ihm sagen müssen, in einer festen Form antwortet und sich an das Gespräch erinnert. Drei Komponenten machen das möglich:

• context_schema + ToolRuntime — Sie definieren eine Dataclass (etwa eine Context , die ein user_identhält), übergeben sie an create_agent, und die Werkzeuge lesen sie über ToolRuntime[Context] aus — sodass ein locate_user -Werkzeug eine Stadt aus der Benutzer-ID auflösen kann, ohne dass die ID ein Werkzeugparameter ist.
• response_format — eine zweite Dataclass (eine ResponseFormat mit summary, temperature_celsius, temperature_fahrenheit, humidity) zwingt den Agenten in eine strukturierte Form. Das Ergebnis kommt in response["structured_response"] zurück — kein Parsen, kein Raten.
• InMemorySaver + thread_id — ein LangGraph-Checkpointer, der die Nachrichtenhistorie speichert, indiziert nach einem thread_id in der Konfiguration. Bei gleichem Thread erinnert sich der Agent; bei einem anderen Thread nicht.

from dataclasses import dataclass
from langchain.chat_models import init_chat_model
from langchain.tools import tool, ToolRuntime
from langgraph.checkpoint.memory import InMemorySaver

@dataclass
class Context:
    user_id: str

@dataclass
class ResponseFormat:
    summary: str
    temperature_celsius: float
    temperature_fahrenheit: float
    humidity: float

@tool
def locate_user(runtime: ToolRuntime[Context]) -> str:
    """Look up a user's city based on the context."""
    match runtime.context.user_id:
        case "ABC123": return "Vienna"
        case "XYZ456": return "London"
        case _: return "unknown"

model = init_chat_model("gpt-4.1-mini", temperature=0.3)
checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    tools=[get_weather, locate_user],
    system_prompt="You are a helpful weather assistant.",
    context_schema=Context,
    response_format=ResponseFormat,
    checkpointer=checkpointer,
)

config = {"configurable": {"thread_id": "1"}}
response = agent.invoke(
    {"messages": [{"role": "user", "content": "What is the weather like?"}]},
    config=config,
    context=Context(user_id="ABC123"),
)
print(response["structured_response"].summary)
print(response["structured_response"].temperature_celsius)

Der Agent löst die Stadt aus dem user_id im Kontext auf, wird in die ResponseFormat -Form gezwungen und erinnert sich — dank des Checkpointers — an den Thread. Stellen Sie eine Folgefrage mit demselben thread_id , weiß er, worum es ging; ändern Sie ihn auf "2" , hat er keine Ahnung. Das ist ein kurzfristiges, thread-bezogenes Gedächtnis und bildet die Grundlage jedes Gesprächsagenten.

Multimodale Eingabe: Bilder per URL oder base64

Agenten sind nicht auf Text beschränkt. In 1.0 können Sie einem Modell Bilder auf zwei Arten übergeben: per URL oder als base64-kodierte Bytes aus einer lokalen Datei. Der Nachrichteninhalt wird zu einer Liste typisierter Blöcke — ein Textblock plus ein Bildblock:

message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Describe the contents of this image."},
        {"type": "image", "url": "https://example.com/logo.png"},
    ],
}

# Or from a local file, base64-encoded:
# {"type": "image", "base64": b64_string, "mime_type": "image/png"}

response = model.invoke([message])
print(response.content)

Dieselbe Struktur funktioniert mit der HumanMessage Klasse — Sie lassen einfach den role Schlüssel weg und behalten die Inhaltsliste. Base64-Kodierung bläht die Payload um etwa ein Drittel auf, daher sind URLs vorzuziehen, wenn das Bild öffentlich erreichbar ist; für lokale oder private Dateien verwenden Sie base64.

RAG: Embeddings, Vektorspeicher und ein Retrieval-Werkzeug

Retrieval-Augmented Generation (RAG) ermöglicht es, einem Agenten Zugang zu Wissen zu geben, auf das er nicht trainiert wurde. Der klassische Weg funktioniert auch in 1.0: Ihre Dokumente embedden, in einem Vektorspeicher ablegen und den Speicher in ein Retrieval-Werkzeug umwandeln, das der Agent als Tool aufrufen kann. Das Beispiel, das das Konzept verständlich macht, verwendet einen kleinen Satz von Aussagen über Obst und Computer — darunter die Tatsache, dass „Apple“ sowohl eine Frucht als auch ein Unternehmen ist:

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.tools import create_retriever_tool
from langchain.agents import create_agent

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
texts = [
    "I love apples", "I enjoy oranges", "I think pears taste very good",
    "I hate bananas", "I dislike raspberries", "I despise mangoes",
    "I love Linux", "I hate Windows",
]
vector_store = FAISS.from_texts(texts, embedding=embeddings)
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

retriever_tool = create_retriever_tool(
    retriever,
    name="knowledge_base_search",
    description="Search the small product/fruit knowledge base for information.",
)

agent = create_agent(
    model="gpt-4.1-mini",
    tools=[retriever_tool],
    system_prompt="You are a helpful assistant. If there are any questions about fruits, use the retriever tool first, retrieve the context, and answer concisely. You may need to use the tool multiple times.",
)

response = agent.invoke({
    "messages": [{"role": "user", "content": "What three fruits does the person like and what three fruits does the person dislike?"}]
})
print(response["messages"][-1].content)

Das Embedding-Modell ist der Schlüssel dazu. Führen Sie eine Ähnlichkeitssuche durch, ordnen die Embeddings „I love apples“ korrekt näher bei „I enjoy oranges“ ein als bei „Apple makes very good computers“ — weil sich die Konzepte unterscheiden, obwohl die Zeichenkette übereinstimmt. Der Agent führt dann zwei separate Ähnlichkeitssuchen beim Tool durch — eine für Vorlieben, eine für Abneigungen — und kombiniert sie in der Antwort: „Die Person mag Orangen, Äpfel und Birnen. Die Person mag keine Mangos, Himbeeren und Bananen.“ Dieses Mehrfachaufruf-Verhalten ist genau das, was ein einzelner Prompt nicht leisten kann; es ist das, was RAG für einen Agenten natürlich wirken lässt, statt nachträglich hinzugefügt.

Middleware: das prägende Feature von 1.0

Middleware ist das, was create_agent wirklich von jedem anderen Agenten-Builder unterscheidet. Sie sitzt zwischen Anfrage und Antwort und ermöglicht es Ihnen, das Verhalten in jedem Schritt der Agenten-Schleife anzupassen — ohne die Kernlogik des Agenten zu berühren. Der Lebenszyklus umfasst sechs benannte Hooks: before_agenton_request before_modelon_parse wrap_tool_callon_pre_invoke wrap_model_callon_post_invoke after_modelon_error after_agentund on_response. Sie können ein anderes System-Prompt wählen, ein anderes Modell, zusammenfassen, ratenbegrenzen oder personenbezogene Daten schwärzen — alles als kombinierbare Schichten.

Dynamische System-Prompts

Der @dynamic_prompt Decorator überschreibt das System-Prompt aus dem Kontext. Das klassische Beispiel passt den Erklärungsstil an die Rolle der Nutzerin an — Expertin, Anfängerin oder Kind:

from dataclasses import dataclass
from langchain.agents import create_agent
from langchain.agents.middleware import ModelRequest, dynamic_prompt

@dataclass
class Context:
    user_role: str

@dynamic_prompt
def user_role_prompt(request: ModelRequest) -> str:
    base = "You are a helpful and very concise assistant."
    match request.runtime.context.user_role:
        case "expert": return base + " Provide detailed technical responses."
        case "beginner": return base + " Keep your explanations simple and basic."
        case "child": return base + " Explain everything as if you were literally talking to a 5-year-old."
        case _: return base

agent = create_agent(
    model="gpt-4.1-mini",
    middleware=[user_role_prompt],
    context_schema=Context,
)

response = agent.invoke(
    {"messages": [{"role": "user", "content": "Explain PCA."}]},
    context=Context(user_role="child"),
)
print(response["messages"][-1].content)

Fragen Sie nach PCA als Kind, erhalten Sie: „Stell dir vor, du hast eine große Schachtel Buntstifte mit vielen Farben. Manchmal möchtest du nur ein paar Stifte auswählen, mit denen du trotzdem viele Bilder schön ausmalen kannst. PCA ist wie ein Zauberhelfer.“ Derselbe Prompt, drei verschiedene Zielgruppen, keine Änderungen an der Kernlogik des Agenten.

Dynamische Modellauswahl

Der wrap_model_call Hook ermöglicht es Ihnen, pro Anfrage ein anderes Modell auszuwählen. Ein gängiges Muster: Verwenden Sie ein günstiges Basismodell für kurze Gespräche und wechseln Sie zu einem leistungsstärkeren Modell, sobald das Gespräch eine bestimmte Nachrichtenanzahl überschreitet. Sie lesen die Nachrichtenanzahl aus dem Anfrage-Status, überschreiben das Modell und übergeben die Anfrage an den Handler:

from langchain.agents.middleware import ModelRequest, ModelResponse, wrap_model_call
from langchain.chat_models import init_chat_model

basic_model = init_chat_model("gpt-4o-mini")
advanced_model = init_chat_model("gpt-4.1-mini")

@wrap_model_call
def dynamic_model_selection(request: ModelRequest, handler) -> ModelResponse:
    message_count = len(request.state.messages)
    model = advanced_model if message_count > 3 else basic_model
    return handler(request.override(model=model))

agent = create_agent(
    model=basic_model,
    middleware=[dynamic_model_selection],
)

Sie können überprüfen, welches Modell tatsächlich gelaufen ist, indem Sie response.metadata["model_name"]auslesen. Das ist Kostenkontrolle und Qualitätskontrolle in einem — der Agent gibt wenig aus, wenn die Frage einfach ist, und investiert mehr, wenn das Gespräch komplexer wird.

Eigene Middleware mit Hooks

Für volle Kontrolle leiten Sie von AgentMiddleware und überschreiben die Hook-Methoden direkt. Ein Timing-Middleware, das die gesamte Agenten-Ausführung misst, ist das klassische Beispiel — überschreiben Sie before_agent um einen Startzeitpunkt zu erfassen und after_agent um die verstrichene Zeit auszugeben. So bauen Sie Logging, Guardrails und individuelles Verhalten, das genau zum richtigen Zeitpunkt im Zyklus ausgelöst wird.

Vorgefertigte Middleware

LangChain liefert mehrere einsatzbereite Middlewares für gängige Produktionsmuster:

• SummarizationMiddleware — nach einer Token-Schwelle fasst sie das Gespräch zusammen und behält die letzten N Nachrichten, damit lange Threads im Kontextfenster bleiben.
• HumanInTheLoopMiddleware — unterbricht bei bestimmten Tool-Aufrufen (E-Mail senden, Zahlung tätigen) und wartet auf die Freigabe, Bearbeitung oder Ablehnung durch eine Person.
• ModelCallLimitMiddleware — begrenzt, wie oft das Modell pro Durchlauf oder Thread aufgerufen werden kann.
• ModelFallbackMiddleware — falls ein Modell fehlschlägt, wird auf ein anderes zurückgegriffen.
• PIIMiddleware — schwärzt personenbezogene Daten, bevor sie das Modell erreichen, um Compliance zu gewährleisten.

Es gibt noch mehr — Tool-Aufruf-Limits, Modell-Wiederholungsversuche, einen LLM-Tool-Emulator und eine Planungs-/To-do-Middleware. Entscheidend ist das Muster: Middleware ermöglicht es, die Fähigkeiten eines Agenten zu erweitern, ohne ihn neu zu schreiben, und Sie können mehrere Schichten gleichzeitig kombinieren.

Was seit 1.0 veröffentlicht wurde: die Release-Linie bisher

Der 1.0-Start erfolgte am 22. Oktober 2025, und das Framework ist seitdem nicht stehengeblieben. Die Release-Linie hat in weniger als einem Jahr vier Minor-Versionen durchlaufen, von denen jede produktionsreife Funktionen hinzufügte. Die wichtigste ist langchain v1.4.0 (1. September 2026), die die Unterstützung für das Model Context Protocol direkt in das Core-Paket integriert — doch auch die kleineren Releases sind relevant, da sie stillschweigend veränderten, wie Agenten programmiert werden.

v1.4.0: MCP-Unterstützung im Core-Paket

Die größte Änderung seit 1.0 ist, dass MCP — das offene Protokoll zur Verbindung von Modellen mit Werkzeugen und Kontext — nun direkt in LangChain ausgeliefert wird. Der langchain.mcp Namespace, basierend auf FastMCP, ersetzt das eigenständige langchain-mcp-adapters Paket. Installieren Sie es mit dem mcp Extra:

uv add "langchain[mcp]"

Das Herzstück ist MCPAdapter, das den Transport aus dem ableitet, was Sie übergeben — eine Remote-URL über streambares HTTP, ein lokales Skript über stdio, einen In-Process-FastMCP-Server oder ein MCPConfig Dict für mehrere Server hinter einem Adapter. Sie öffnen den Adapter, entdecken dessen Tools und übergeben sie direkt an create_agent

from langchain.agents import create_agent
from langchain.mcp import MCPAdapter

async def main():
    async with MCPAdapter("https://example.com/mcp") as adapter:
        tools = await adapter.list_tools()
        agent = create_agent("claude-sonnet-5", tools)
        return await agent.ainvoke({
            "messages": [{"role": "user", "content": "..."}]
        })

Dieser einzelne Adapter ersetzt eine ganze Klasse manuell geschriebener Tool-Integrationen. Er übernimmt auch die komplexen Teile von MCP, die Sie sonst selbst implementieren müssten: Authentifizierung (Bearer-Tokens, vollständiges OAuth 2.1 mit dynamischer Client-Registrierung oder jedes httpx.Auth), unterbrechungsgesteuerte Abfrage (wenn ein Server während eines Anrufs nach Eingaben fragt, erscheint die Frage als LangGraph- interrupt() , sodass ein Mensch antworten kann und der Lauf fortgesetzt wird), sowie detailliertere Tool-Metadaten — darunter eine destructive_hint Annotation, die Sie hinter einer menschlichen Freigabe verbergen können. Der Namespace ist noch Beta (der Import löst eine LangChainBetaWarningaus), doch die Richtung ist klar: MCP ist der Standardweg, um Agenten mit der Außenwelt zu verbinden.

v1.3.0 und v1.2.0: Streaming und Tool-Extras

v1.3.0 (12. Mai 2026) ergänzte version="v3" um stream_events und astream_events für Agenten — ein streaming-Protokoll mit Content-Block-Fokus und typisierten, kanalbasierten Projektionen, sodass Sie Text, Reasoning, Tool-Aufrufe und Usage getrennt streamen können, statt einen undifferenzierten Stream parsen zu müssen. v1.2.0 (15. Dezember 2025) fügte ein neues extras Attribut für Tools hinzu, das provider-spezifische Parameter unterstützt — etwa Anthropics programmatische Tool-Aufrufe und Tool-Suche sowie clientseitig ausgeführte Built-in-Tools von OpenAI und anderen — plus strikte Schema-Einhaltung in Agenten- response_format via ProviderStrategy

v1.1.0: Modellprofile und neue Middleware

v1.1.0 (25. November 2025) war das erste Feature-Release nach 1.0 und brachte zwei erwähnenswerte Neuerungen. Erstens Modellprofile: Jedes Chat-Modell stellt nun ein .profile Attribut bereit, das seine Fähigkeiten beschreibt (abgeleitet vom Open-Source-Projekt models.dev ), sodass das Framework Dinge wie native Structured-Output-Unterstützung und kontextsensitive Zusammenfassungs-Trigger ableiten kann. Zweitens zwei neue vorgefertigte Middlewares: ModelRetryMiddleware für das automatische Wiederholen fehlgeschlagener Modellaufrufe mit konfigurierbarem exponentiellem Backoff, sowie eine OpenAI-Content-Moderations-Middleware, die Nutzer:innen-Eingaben, Modellausgaben und Tool-Ergebnisse auf unsichere Inhalte prüft. Zudem wurde die Möglichkeit eingeführt, eine SystemMessage Instanz direkt an create_agents system_prompt Parameter zu übergeben, was Cache-Kontrolle und strukturierte Content-Blöcke ermöglicht.

LangGraph v1.2.0: das Runtime-System im Hintergrund

Da create_agent auf LangGraph läuft, sind auch die Releases des Graph-Runtime-Systems relevant. LangGraph v1.2.0 (12. Mai 2026) führte DeltaChannel (Beta) ein, einen Kanaltyp, der nur das inkrementelle Delta pro Schritt speichert, statt den gesamten akkumulierten Wert neu zu serialisieren — ein echter Gewinn für langlaufende Threads, deren Nachrichtenlisten groß werden, da es die Checkpoint-Größen klein hält. Zudem wurden pro-Node-Timeouts (ein hartes run_timeout, ein Leerlauf- idle_timeout , das bei Fortschritt zurückgesetzt wird, oder beides via TimeoutPolicy), Node-Level-Error-Handler für Saga/Kompensationsmuster sowie ein geordneter Shutdown via RunControl.request_drain() hinzugefügt — stoppen Sie einen laufenden Lauf kooperativ und speichern Sie einen wiederaufnehmbaren Checkpoint. Für die meisten create_agent Nutzer:innen sind diese Features unsichtbar, doch sie machen den Unterschied zwischen einer Demo und einem System, das Sie in Produktion betreiben können.

Das Fazit

LangChain 1.0 ist ein echter Neuanfang. Es hat ein weitverzweigtes Ökosystem in einen einzigen Import-Pfad zusammengefasst, create_agent zum Standardverfahren für den Aufbau eines Agenten gemacht und Middleware als Abstraktion eingeführt, mit der Sie Prompts, Modelle und Guardrails zur Laufzeit steuern können. Das praktische Rezept für den Einstieg ist kurz: Installation mit uv add "langchain[openai]", Laden der Schlüssel aus einer .env, Erstellen eines ersten Agenten mit create_agent und einer @tool -Funktion, dann schrittweises Hinzufügen von Kontext, strukturierter Ausgabe, Memory, RAG und Middleware, sobald der Bedarf entsteht. Der Fehlerfall, den 1.0 beseitigt, ist die Provider-Abhängigkeit — und das ist das Wertvollste, was es leistet.

Middleware sitzt zwischen Anfrage und Antwort. Sie können einen anderen System-Prompt wählen, ein anderes Modell, zusammenfassen, ratenbegrenzen oder personenbezogene Daten schwärzen — alles, ohne die Kernlogik des Agenten anzutasten.

Weiterlesen — die Quellen

Dieser Artikel bietet die Vogelperspektive. Wenn Sie die Mechanik wirklich verstehen wollen — wie create_agent die Schleife aufbaut, wie Middleware-Hooks feuern, wie Memory und RAG tatsächlich funktionieren —, gehen die folgenden Ressourcen ins Detail. Jeder Link ist eine primäre oder autoritative Quelle, verifiziert 2026-09-08.

LangChain 1.0 und create_agent

• LangChain — „LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones“ Die offizielle Ankündigung (22. Oktober 2025) zur create_agent -Abstraktion, den Middleware-Hooks und der Vereinfachung des Pakets. https://www.langchain.com/blog/langchain-langgraph-1dot0
• LangChain-Dokumentation — „What's new in LangChain v1“ Die offiziellen Release Notes: create_agent als Standard-Builder, der Middleware-Lebenszyklus und der vereinfachte Namensraum. https://docs.langchain.com/oss/python/releases/langchain-v1
• LangChain-Dokumentation — „LangChain v1 migration guide“ Wie Sie von der Vor-1.0- create_react_agent und den Provider-spezifischen Paketen zu create_agent und Middleware wechseln. https://docs.langchain.com/oss/python/migrate/langchain-v1
• LangChain-Referenz — create_agent Die API-Referenz für den Standard-Agent-Builder. https://reference.langchain.com/python/langchain/agents/factory/create_agent

Deep Agents

• LangChain — „Deep Agents vs LangChain vs LangGraph“ Der offizielle Beitrag (06. August 2026) zum Drei-Schichten-Stack — Harness, Framework, Runtime — und wann welche Ebene zum Einsatz kommt. https://www.langchain.com/blog/deep-agents-vs-langchain-vs-langgraph
• LangChain — Deep Agents-Übersicht Die offizielle Produktseite für das Open-Source-Agenten-Framework: Dateisystem, Subagenten, Skills und Memory. https://www.langchain.com/deep-agents
• LangChain-Dokumentation — „Deep Agents overview“ Der create_deep_agent Quickstart und Kernfunktionen. https://docs.langchain.com/oss/python/deepagents/overview
• GitHub — langchain-ai/deepagents Das „batteries-included“-Agenten-Framework-Repository. https://github.com/langchain-ai/deepagents

Modelle, Nachrichten und Streaming

• LangChain-Referenz — init_chat_model Die einheitliche Modell-Initialisierungsfunktion, inklusive der Provider-Präfix-Inferenzregeln und der vollständigen Provider-Tabelle. https://reference.langchain.com/python/langchain/chat_models/base/init_chat_model
• LangChain-Dokumentation — „Models“ Wie man ein eigenständiges Modell initialisiert und verwendet. https://docs.langchain.com/oss/python/langchain/models
• LangChain-Dokumentation — „Messages“ Das Nachrichtenmodell, inklusive multimodaler Inhaltsblöcke (Text, Bild, Datei, Audio, Video) per URL, base64 oder Datei-ID. https://docs.langchain.com/oss/python/langchain/messages

Memory und Checkpointing

• LangGraph-Dokumentation — „Memory“ Kurzzeit- (thread-spezifisch) vs. Langzeit-Memory (thread-übergreifend) und wie der Checkpointer + thread_id funktioniert. https://docs.langchain.com/oss/python/langgraph/add-memory
• LangGraph-Dokumentation — „Checkpointers“ Die Kernkonzepte: Threads, der thread_id Primärschlüssel und wie der Zustand persistiert wird. https://docs.langchain.com/oss/python/langgraph/checkpointers
• LangGraph-Referenz — InMemorySaver Der In-Memory-Checkpointer für Debugging und Testing. https://reference.langchain.com/python/langgraph.checkpoint/memory/InMemorySaver

RAG, Embeddings und Vektorspeicher

• LangChain-Referenz — create_retriever_tool Die Funktion, die einen Retriever als Tool kapselt, das der Agent aufrufen kann. https://reference.langchain.com/python/langchain-core/tools/create_retriever_tool
• LangChain-Referenz — FAISS-Vektorspeicher Die langchain_community FAISS-Integration, inklusive from_texts und as_retriever. https://reference.langchain.com/python/langchain-community/vector-stores
• LangChain-Dokumentation — FAISS-Integration Der offizielle FAISS-Vektor-Store-Leitfaden. https://python.langchain.com/docs/integrations/vectorstores/faiss

Middleware

• LangChain-Dokumentation — „Middleware-Übersicht“ Die kombinierbare Middleware-Abstraktion und ihre Verwendung innerhalb eines LangGraph-Workflows. https://docs.langchain.com/oss/python/langchain/middleware/overview
• LangChain-Dokumentation — „Vorgefertigte Middleware“ Die integrierten Middlewares: Model Retry, Model Fallback, Zusammenfassung, Model-Call-Limit und der LLM-Tool-Emulator. https://docs.langchain.com/oss/python/langchain/middleware/built-in
• LangChain-Dokumentation — „Human-in-the-loop“ Wie HumanInTheLoopMiddleware Genehmigungs-, Bearbeitungs- und Ablehnungsentscheidungen zu Tool-Aufrufen hinzugefügt werden. https://docs.langchain.com/oss/python/langchain/human-in-the-loop

Die neuesten Releases

• LangChain-Dokumentation — „Changelog“ Das offizielle Changelog zu langchain v1.4.0 (MCP), v1.3.0 (v3-Streaming), v1.2.0 (Tool-Extras), v1.1.0 (Model-Profile, Model Retry, Content Moderation) und langgraph v1.2.0 (DeltaChannel, Timeout pro Node, Graceful Shutdown). https://docs.langchain.com/oss/python/releases/changelog
• LangChain-Dokumentation — „Model Context Protocol (MCP)“ Der langchain.mcp -Namespace, MCPAdapter, Transports, Authentifizierung und Tool-Loading. https://docs.langchain.com/oss/python/langchain/mcp
• LangChain-Dokumentation — „Modelle: Model-Profile“ Das .profile -Attribut und wie Model-Fähigkeiten abgeleitet werden. https://docs.langchain.com/oss/python/langchain/models
• LangChain-Dokumentation — „Event-Streaming (v3)“ Das inhaltsblockbasierte Streaming-Protokoll, eingeführt in v1.3.0. https://docs.langchain.com/oss/python/langchain/event-streaming

Quellen

• NeuralNine, „LangChain Full Crash Course — AI Agents in Python“ — https://www.youtube.com/watch?v=J7j5tCB_y4w (veröffentlicht 10. November 2025; Transkript abgerufen 2026-09-08)
• LangChain & LangGraph v1.0-Ankündigung — https://www.langchain.com/blog/langchain-langgraph-1dot0
• LangChain v1 Release Notes — https://docs.langchain.com/oss/python/releases/langchain-v1
• LangChain v1 Migrationsleitfaden — https://docs.langchain.com/oss/python/migrate/langchain-v1
• LangChain-Referenz (create_agent, init_chat_model, middleware) — https://reference.langchain.com/python/langchain
• LangGraph-Dokumentation zu Memory & Checkpointing — https://docs.langchain.com/oss/python/langgraph/add-memory
• LangChain-Changelog (v1.4.0, v1.3.0, v1.2.0, v1.1.0, langgraph v1.2.0) — https://docs.langchain.com/oss/python/releases/changelog
• LangChain-MCP-Dokumentation — https://docs.langchain.com/oss/python/langchain/mcp
• GitHub — langchain-ai/langchain (die Agent-Engineering-Plattform) — https://github.com/langchain-ai/langchain
• LangChain — „Deep Agents vs LangChain vs LangGraph“ — https://www.langchain.com/blog/deep-agents-vs-langchain-vs-langgraph