LangChain 1.0 und Milvus: Wie man produktionsreife Agenten mit echtem Langzeitgedächtnis erstellt

LangChain ist ein beliebtes Open-Source-Framework für die Entwicklung von Anwendungen, die auf großen Sprachmodellen (LLMs) basieren. Es bietet ein modulares Toolkit für den Aufbau von logischen und werkzeugverwendenden Agenten, die Verbindung von Modellen mit externen Daten und die Verwaltung von Interaktionsflüssen.

Mit der Veröffentlichung von LangChain 1.0 macht das Framework einen Schritt in Richtung einer produktionsfreundlicheren Architektur. Die neue Version ersetzt das frühere kettenbasierte Design durch eine standardisierte ReAct-Schleife (Reason → Tool Call → Observe → Decide) und führt Middleware zur Verwaltung von Ausführung, Kontrolle und Sicherheit ein.

Aber logisches Denken allein ist nicht genug. Agenten müssen auch in der Lage sein, Informationen zu speichern, abzurufen und wiederzuverwenden. Hier kann Milvus, eine Open-Source-Vektordatenbank, eine wichtige Rolle spielen. Milvus bietet eine skalierbare, hochleistungsfähige Speicherebene, die es Agenten ermöglicht, Informationen über semantische Ähnlichkeit effizient zu speichern, zu suchen und abzurufen.

In diesem Beitrag werden wir untersuchen, wie LangChain 1.0 die Agentenarchitektur aktualisiert und wie die Integration von Milvus den Agenten hilft, über das Argumentieren hinauszugehen und einen persistenten, intelligenten Speicher für reale Anwendungsfälle zu ermöglichen.

Warum das kettenbasierte Design zu kurz greift

In den frühen Tagen (Version 0.x) war die Architektur von LangChain auf Ketten ausgerichtet. Jede Kette definierte eine feste Sequenz und wurde mit vorgefertigten Vorlagen geliefert, die die LLM-Orchestrierung einfach und schnell machten. Dieses Design war ideal für die schnelle Erstellung von Prototypen. Aber als sich das LLM-Ökosystem weiterentwickelte und die realen Anwendungsfälle komplexer wurden, begannen sich Risse in dieser Architektur zu zeigen.

1. Mangel an Flexibilität

Frühe Versionen von LangChain boten modulare Pipelines wie SimpleSequentialChain oder LLMChain, die jeweils einem festen, linearen Ablauf folgten - Prompt-Erstellung → Modellaufruf → Ausgabeverarbeitung. Dieses Design eignete sich gut für einfache und vorhersehbare Aufgaben und erleichterte die schnelle Erstellung von Prototypen.

Als die Anwendungen jedoch immer dynamischer wurden, fühlten sich diese starren Vorlagen zunehmend einschränkend an. Wenn die Geschäftslogik nicht mehr sauber in eine vordefinierte Sequenz passt, bleiben Ihnen zwei unbefriedigende Optionen: Sie können Ihre Logik zwingen, sich an das Framework anzupassen, oder es ganz umgehen, indem Sie die LLM-API direkt aufrufen.

2. Fehlende Kontrolle in der Produktion

Was in Demos gut funktionierte, ging in der Produktion oft schief. Die Chains enthielten nicht die Sicherheitsvorkehrungen, die für groß angelegte, dauerhafte oder sensible Anwendungen erforderlich sind. Häufige Probleme waren:

• Überlauf von Kontexten: Lange Konversationen konnten die Token-Grenzen überschreiten und Abstürze oder stillschweigende Abbrüche verursachen.

• Sensible Datenlecks: Persönlich identifizierbare Informationen (wie E-Mails oder IDs) könnten versehentlich an Modelle von Drittanbietern gesendet werden.

• Unüberwachte Vorgänge: Agenten könnten Daten löschen oder E-Mails ohne menschliche Zustimmung versenden.

3. Fehlende modellübergreifende Kompatibilität

Jeder LLM-Anbieter - OpenAI, Anthropic und viele chinesische Modelle - implementiert seine eigenen Protokolle für Schlussfolgerungen und Tool-Aufrufe. Jedes Mal, wenn man den Anbieter wechselte, musste man die Integrationsschicht neu schreiben: Eingabeaufforderungsvorlagen, Adapter und Antwortparser. Diese sich wiederholende Arbeit verlangsamte die Entwicklung und machte das Experimentieren mühsam.

LangChain 1.0: All-in ReAct Agent

Als das LangChain-Team Hunderte von produktionsreifen Agenten-Implementierungen analysierte, stach eine Erkenntnis hervor: Fast alle erfolgreichen Agenten konvergierten auf natürliche Weise zum ReAct-Muster ("Reasoning + Acting").

Unabhängig davon, ob es sich um ein Multi-Agenten-System oder einen einzelnen Agenten handelt, der tiefgreifende Überlegungen anstellt, ergibt sich derselbe Regelkreis: Abwechselnd werden kurze Überlegungsschritte mit gezielten Tool-Aufrufen durchgeführt, und die daraus resultierenden Beobachtungen fließen in nachfolgende Entscheidungen ein, bis der Agent eine endgültige Antwort geben kann.

Um auf dieser bewährten Struktur aufzubauen, stellt LangChain 1.0 die ReAct-Schleife in den Mittelpunkt seiner Architektur und macht sie zur Standardstruktur für den Aufbau zuverlässiger, interpretierbarer und produktionsreifer Agenten.

Um alles zu unterstützen, von einfachen Agenten bis hin zu komplexen Orchestrierungen, verwendet LangChain 1.0 ein mehrschichtiges Design, das Benutzerfreundlichkeit mit präziser Kontrolle kombiniert:

• Standardszenarien: Beginnen Sie mit der create_agent()-Funktion - eine saubere, standardisierte ReAct-Schleife, die Argumente und Tool-Aufrufe sofort verarbeitet.

• Erweiterte Szenarien: Fügen Sie Middleware hinzu, um eine feinkörnige Kontrolle zu erhalten. Mit Middleware können Sie die Vorgänge innerhalb des Agenten überprüfen oder ändern, z. B. durch Hinzufügen von PII-Erkennung, Prüfpunkten für die menschliche Zustimmung, automatischen Wiederholungsversuchen oder Überwachungshaken.

• Komplexe Szenarien: Für zustandsbehaftete Workflows oder die Orchestrierung mehrerer Agenten verwenden Sie LangGraph, eine graphenbasierte Ausführungsengine, die eine präzise Kontrolle über den Logikfluss, die Abhängigkeiten und die Ausführungszustände bietet.

Lassen Sie uns nun die drei Schlüsselkomponenten aufschlüsseln, die die Agentenentwicklung einfacher, sicherer und konsistenter über alle Modelle hinweg machen.

1. Der create_agent(): Eine einfachere Methode zur Erstellung von Agenten

Ein wichtiger Durchbruch in LangChain 1.0 ist die Reduzierung der Komplexität der Agentenentwicklung auf eine einzige Funktion - create_agent(). Sie müssen sich nicht mehr manuell um Zustandsverwaltung, Fehlerbehandlung oder Streaming-Ausgaben kümmern. Diese Funktionen auf Produktionsebene werden nun automatisch von der darunter liegenden LangGraph-Laufzeit verwaltet.

Mit nur drei Parametern können Sie einen voll funktionsfähigen Agenten starten:

• model - entweder ein Modellbezeichner (String) oder ein instanziiertes Modellobjekt.

• tools - eine Liste von Funktionen, die dem Agenten seine Fähigkeiten verleihen.

• system_prompt - die Anweisung, die die Rolle, den Ton und das Verhalten des Agenten definiert.

Unter der Haube läuft create_agent() in der Standard-Agentenschleife - es ruft ein Modell auf, lässt es Werkzeuge zur Ausführung wählen und schließt ab, sobald keine Werkzeuge mehr benötigt werden:

Er erbt auch die in LangGraph eingebauten Fähigkeiten zur Zustandspersistenz, zur Wiederherstellung von Unterbrechungen und zum Streaming. Aufgaben, die früher Hunderte von Zeilen an Orchestrierungscode erforderten, werden jetzt über eine einzige, deklarative API abgewickelt.

from langchain.agents import create_agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather, query_database],
    system_prompt="You are a customer service assistant who helps users check the weather and order information."
)
result = agent.invoke({
    "messages": [{"role": "user", "content": "What’s the weather like in Shanghai today?"}]
})

2. Die Middleware: Eine komponierbare Schicht für produktionsreife Steuerung

Die Middleware ist die entscheidende Brücke, die LangChain vom Prototyp zur Produktion bringt. Sie stellt an strategischen Punkten in der Ausführungsschleife des Agenten Hooks zur Verfügung, die es Ihnen ermöglichen, benutzerdefinierte Logik hinzuzufügen, ohne den Kernprozess von ReAct neu zu schreiben.

Die Hauptschleife eines Agenten folgt einem dreistufigen Entscheidungsprozess - Modell → Werkzeug → Beendigung:

LangChain 1.0 bietet ein paar vorgefertigte Middlewares für gängige Muster. Hier sind vier Beispiele.

• PII-Erkennung: Jede Anwendung, die sensible Benutzerdaten verarbeitet

from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[],  # Add tools as needed
middleware=[
# Redact emails in user input
PIIMiddleware(“email”, strategy=“redact”, apply_to_input=True),
# Mask credit cards (show last 4 digits)
PIIMiddleware(“credit_card”, strategy=“mask”, apply_to_input=True),
# Custom PII type with regex
PIIMiddleware(
“api_key”,
detector=r"sk-[a-zA-Z0-9]{32}",
strategy=“block”,  # Raise error if detected
),
],
)

• Zusammenfassen: Automatisches Zusammenfassen des Gesprächsverlaufs, wenn sich die Token-Grenze nähert.

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[weather_tool, calculator_tool],
middleware=[
SummarizationMiddleware(
model=“gpt-4o-mini”,  #Summarize using a cheaper model  
max_tokens_before_summary=4000,  # Trigger summarization at 4000 tokens
messages_to_keep=20,  # Keep last 20 messages after summary
),
],
)

• Tool-Wiederholung: Automatische Wiederholung fehlgeschlagener Tool-Aufrufe mit konfigurierbarem exponentiellem Backoff.

from langchain.agents import create_agent
from langchain.agents.middleware import ToolRetryMiddleware
agent = create_agent(
    model="gpt-4o",
    tools=[search_tool, database_tool],
    middleware=[
        ToolRetryMiddleware(
            max_retries=3,  # Retry up to 3 times
            backoff_factor=2.0,  # Exponential backoff multiplier
            initial_delay=1.0,  # Start with 1 second delay
            max_delay=60.0,  # Cap delays at 60 seconds
            jitter=True,  # Add random jitter to avoid thundering herd (±25%)
    ),
],

)

• Benutzerdefinierte Middleware

Zusätzlich zu den offiziellen, vorgefertigten Middleware-Optionen können Sie auch benutzerdefinierte Middleware auf dekorator- oder klassenbasierte Weise erstellen.

Der folgende Ausschnitt zeigt beispielsweise, wie Modellaufrufe vor der Ausführung protokolliert werden:

from langchain.agents.middleware import before_model
from langchain.agents.middleware import AgentState
from langgraph.runtime import Runtime
@before_model
def log_before_model(state: AgentState, runtime: Runtime) -> dict | None:
    print(f"About to call model with {len(state['messages'])} messages")
    return None  # Returning None means the normal flow continues
agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[log_before_model],
)

3. Strukturierte Ausgabe: Ein standardisierter Weg, Daten zu handhaben

In der traditionellen Agentenentwicklung war es schon immer schwierig, strukturierte Ausgaben zu verwalten. Jeder Modellanbieter handhabt dies anders - OpenAI bietet zum Beispiel eine native Structured Output API, während andere nur indirekt über Toolaufrufe strukturierte Antworten unterstützen. Das bedeutete oft, dass für jeden Anbieter eigene Adapter geschrieben werden mussten, was zusätzliche Arbeit bedeutete und die Wartung mühsamer machte, als sie sein sollte.

In LangChain 1.0 wird die strukturierte Ausgabe direkt über den Parameter response_format in create_agent() gehandhabt. Sie brauchen Ihr Datenschema nur einmal zu definieren. LangChain wählt automatisch die beste Durchsetzungsstrategie auf der Grundlage des von Ihnen verwendeten Modells aus - kein zusätzliches Setup oder anbieterspezifischer Code ist erforderlich.

from langchain.agents import create_agent
from pydantic import BaseModel, Field
class WeatherReport(BaseModel):
    location: str = Field(description="City name")
    temperature: float = Field(description="Temperature (°C)")
    condition: str = Field(description="Weather condition")
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather],
    response_format=WeatherReport  # Use the Pydantic model as the response schema
)
result = agent.invoke({"role": "user", "content": "What’s the weather like in Shanghai today??"})
weather_data = result['structured_response']  # Retrieve the structured response
print(f"{weather_data.location}: {weather_data.temperature}°C, {weather_data.condition}")

LangChain unterstützt zwei Strategien für die strukturierte Ausgabe:

1. Anbieter-Strategie: Einige Modellanbieter unterstützen strukturierte Ausgaben von Haus aus über ihre APIs (z.B. OpenAI und Grok). Wenn eine solche Unterstützung verfügbar ist, verwendet LangChain direkt die eingebaute Schemadurchsetzung des Anbieters. Dieser Ansatz bietet den höchsten Grad an Zuverlässigkeit und Konsistenz, da das Modell selbst das Ausgabeformat garantiert.

2. Werkzeugaufruf-Strategie: Für Modelle, die keine native strukturierte Ausgabe unterstützen, verwendet LangChain Tool-Aufrufe, um das gleiche Ergebnis zu erzielen.

Sie müssen sich nicht darum kümmern, welche Strategie verwendet wird - das Framework erkennt die Fähigkeiten des Modells und passt sich automatisch an. Dank dieser Abstraktion können Sie zwischen verschiedenen Modellanbietern wechseln, ohne Ihre Geschäftslogik zu ändern.

Wie Milvus den Agentenspeicher verbessert

Bei produktiven Agenten ist der wirkliche Leistungsengpass oft nicht die Logik-Engine, sondern das Speichersystem. In LangChain 1.0 fungieren Vektordatenbanken als externes Gedächtnis eines Agenten, das einen langfristigen Abruf durch semantisches Retrieval ermöglicht.

Milvus ist eine der ausgereiftesten Open-Source-Vektordatenbanken auf dem Markt, die speziell für die umfangreiche Vektorsuche in KI-Anwendungen entwickelt wurde. Sie lässt sich nativ in LangChain integrieren, so dass Sie sich nicht manuell um Vektorisierung, Indexverwaltung oder Ähnlichkeitssuche kümmern müssen. Das Paket langchain_milvus wickelt Milvus als Standard-VectorStore-Schnittstelle ein, so dass Sie es mit nur wenigen Zeilen Code mit Ihren Agenten verbinden können.

Auf diese Weise löst Milvus drei zentrale Herausforderungen beim Aufbau skalierbarer und zuverlässiger Agentenspeichersysteme:

1. Schneller Abruf von massiven Wissensdatenbanken

Wenn ein Agent Tausende von Dokumenten, vergangenen Gesprächen oder Produkthandbüchern verarbeiten muss, reicht eine einfache Stichwortsuche nicht aus. Milvus verwendet eine vektorielle Ähnlichkeitssuche, um semantisch relevante Informationen innerhalb von Millisekunden zu finden - selbst wenn die Anfrage einen anderen Wortlaut hat. So kann Ihr Agent Wissen auf der Grundlage der Bedeutung abrufen, nicht nur aufgrund exakter Textübereinstimmungen.

from langchain.agents import create_agent
from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings
# Initialize the vector database as a knowledge base
vectorstore = Milvus(
    embedding=OpenAIEmbeddings(),  
    collection_name="company_knowledge",
    connection_args={"uri": "http://localhost:19530"}  #
)
# Convert the retriever into a Tool for the Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[vectorstore.as_retriever().as_tool(
        name="knowledge_search",
        description="Search the company knowledge base to answer professional questions"
    )],
    system_prompt="You can retrieve information from the knowledge base to answer questions."
)

2. Persistentes Langzeitgedächtnis

Die SummarizationMiddleware von LangChain kann den Gesprächsverlauf verdichten, wenn er zu lang wird, aber was passiert mit all den Details, die weggekürzt werden? Milvus bewahrt sie auf. Jedes Gespräch, jeder Toolaufruf und jeder Argumentationsschritt kann vektorisiert und für eine langfristige Referenz gespeichert werden. Bei Bedarf kann der Agent über die semantische Suche schnell relevante Erinnerungen abrufen, was eine echte Kontinuität über Sitzungen hinweg ermöglicht.

from langchain_milvus import Milvus
from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
from langgraph.checkpoint.memory import InMemorySaver
# Long-term memory storage(Milvus)
long_term_memory = Milvus.from_documents(
    documents=[],  # Initially empty; dynamically updated at runtime
    embedding=OpenAIEmbeddings(),
    connection_args={"uri": "./agent_memory.db"}
)
# Short-term memory management(LangGraph Checkpointer + Summarization)
agent = create_agent(
    model="openai:gpt-4o",
    tools=[long_term_memory.as_retriever().as_tool(
        name="recall_memory",
        description="Retrieve the agent’s historical memories and past experiences"
    )],
    checkpointer=InMemorySaver(),  # Short-term memory
    middleware=[
        SummarizationMiddleware(
            model="openai:gpt-4o-mini",
            max_tokens_before_summary=4000  # When the threshold is exceeded, summarize and store it in Milvus
        )
    ]
)

3. Einheitliche Verwaltung von multimodalen Inhalten

Moderne Agenten verarbeiten mehr als nur Text - sie interagieren mit Bildern, Audio und Video. Milvus unterstützt Multi-Vektor-Speicher und dynamische Schemata, so dass Sie Einbettungen aus mehreren Modalitäten in einem einzigen System verwalten können. Dies bietet eine einheitliche Speichergrundlage für multimodale Agenten, die eine konsistente Abfrage über verschiedene Datentypen hinweg ermöglicht.

# Filter retrievals by source (e.g., search only medical reports)
vectorstore.similarity_search(
    query="What is the patient's blood pressure reading?",
    k=3,
    expr="source == 'medical_reports' AND modality == 'text'"  # Milvus scalar filtering
)

LangChain vs. LangGraph: Wie Sie die passende Lösung für Ihre Agenten auswählen

Ein Upgrade auf LangChain 1.0 ist ein wichtiger Schritt auf dem Weg zur Erstellung produktionsreifer Agenten - aber das bedeutet nicht, dass es immer die einzige oder beste Wahl für jeden Anwendungsfall ist. Die Wahl des richtigen Frameworks bestimmt, wie schnell Sie diese Fähigkeiten zu einem funktionierenden, wartbaren System kombinieren können.

Tatsächlich können LangChain 1.0 und LangGraph 1.0 als Teil desselben Schichtenstapels betrachtet werden, der so konzipiert ist, dass er zusammenarbeitet, anstatt sich gegenseitig zu ersetzen: LangChain hilft Ihnen, Standard-Agenten schnell zu erstellen, während LangGraph Ihnen eine feinkörnige Kontrolle für komplexe Arbeitsabläufe bietet. Mit anderen Worten: LangChain hilft Ihnen, schnell zu arbeiten, während LangGraph Ihnen hilft, in die Tiefe zu gehen.

Im Folgenden finden Sie einen kurzen Vergleich der technischen Positionierung der beiden Systeme:

Dimension	LangChain 1.0	LangChain 1.0
Abstraktionsebene	High-Level-Abstraktion, konzipiert für Standard-Agentenszenarien	Low-Level-Orchestrierungs-Framework, konzipiert für komplexe Arbeitsabläufe
Kern-Fähigkeit	Standard ReAct-Schleife (Reason → Tool Call → Observation → Response)	Benutzerdefinierte Zustandsautomaten und komplexe Verzweigungslogik (StateGraph + Conditional Routing)
Erweiterungs-Mechanismus	Middleware für produktionsreife Fähigkeiten	Manuelle Verwaltung von Knoten, Kanten und Zustandsübergängen
Zugrundeliegende Implementierung	Manuelle Verwaltung von Knoten, Kanten und Zustandsübergängen	Native Laufzeit mit eingebauter Persistenz und Wiederherstellung
Typische Anwendungsfälle	80% der Standard-Agentenszenarien	Multi-Agenten-Kollaboration und lang laufende Workflow-Orchestrierung
Lernkurve	Erstellen eines Agenten in ~10 Codezeilen	Erfordert ein Verständnis von Zustandsgraphen und Knotenorchestrierung

Wenn Sie neu in der Erstellung von Agenten sind oder ein Projekt schnell zum Laufen bringen wollen, beginnen Sie mit LangChain. Wenn Sie bereits wissen, dass Ihr Anwendungsfall eine komplexe Orchestrierung, Multi-Agenten-Kollaboration oder langlaufende Workflows erfordert, sollten Sie direkt zu LangGraph wechseln.

Beide Frameworks können im selben Projekt koexistieren - Sie können einfach mit LangChain beginnen und LangGraph einbinden, wenn Ihr System mehr Kontrolle und Flexibilität benötigt. Der Schlüssel liegt darin, das richtige Werkzeug für jeden Teil Ihres Workflows zu wählen.

Fazit

Vor drei Jahren begann LangChain als ein leichtgewichtiger Wrapper für den Aufruf von LLMs. Heute hat es sich zu einem vollständigen, produktionsreifen Framework entwickelt.

Im Kern sorgen die Middleware-Schichten für Sicherheit, Konformität und Beobachtbarkeit. LangGraph fügt persistente Ausführung, Kontrollfluss und Zustandsverwaltung hinzu. Und auf der Speicherebene füllt Milvus eine kritische Lücke, indem es einen skalierbaren, zuverlässigen Langzeitspeicher bereitstellt, der es Agenten ermöglicht, Kontext abzurufen, Rückschlüsse auf den Verlauf zu ziehen und sich im Laufe der Zeit zu verbessern.

Zusammen bilden LangChain, LangGraph und Milvus eine praktische Toolchain für das moderne Agentenzeitalter, die eine Brücke zwischen schnellem Prototyping und unternehmensweitem Einsatz schlägt, ohne dabei an Zuverlässigkeit oder Leistung einzubüßen.

🚀 Sind Sie bereit, Ihrem Agenten ein zuverlässiges Langzeitgedächtnis zu geben? Informieren Sie sich über Milvus und sehen Sie, wie es einen intelligenten Langzeitspeicher für LangChain-Agenten in der Produktion bereitstellt.

Haben Sie Fragen oder möchten Sie in eine Funktion eintauchen? Treten Sie unserem Discord-Kanal bei oder melden Sie Probleme auf GitHub. Sie können auch eine 20-minütige Einzelsitzung buchen, um Einblicke, Anleitung und Antworten auf Ihre Fragen über die Milvus Office Hours zu erhalten.