Hallo zusammen, Sarah hier von agnthq.com. Die letzten paar Wochen waren verrückt, oder? Jedes Mal, wenn ich blinzle, gibt es einen neuen KI-Agenten, der verspricht, mein Leben, meinen Workflow oder zumindest meine Kaffeemenge zu verändern. Und ehrlich gesagt, viele von ihnen… tun das einfach nicht. Sie sind entweder zu komplex, zu nischenspezifisch oder sie halten einfach nicht, was sie versprechen.
Aber hin und wieder taucht etwas wirklich Interessantes auf. Etwas, das mich tatsächlich aufmerken lässt und ich denke: „Okay, das könnte tatsächlich nützlich sein.“ Heute möchte ich über eines dieser Dinge sprechen. Kein brandneues, glänzendes Ding, sondern eine Plattform, die sich stetig weiterentwickelt hat und meiner Meinung nach gerade einen sweet spot für den praktischen, täglichen Gebrauch getroffen hat: das neue Agents-Framework von LangChain mit seinen verbesserten strukturierten Ausgaben und Tool-Calling-Funktionen.
Jetzt, bevor ihr stöhnt und denkt: „Oh toll, ein weiterer LangChain-Artikel,“ hört mir zu. Ich beschäftige mich seit ziemlich genau dem ersten Tag mit LangChain. Ich erinnere mich an die Anfangstage, als ich LLMs und Tools miteinander verknüpfte und mich wie ein digitaler Frankenstein fühlte. Es war mächtig, das steht fest, aber oft auch umständlich, schwer zu debuggen und es fühlte sich ein bisschen so an, als würde ich 2024 Python 2-Code schreiben. Die Ausgaben konnten… kreativ sein, um es milde auszudrücken, und einen Agenten dazu zu bringen, zuverlässig das zu tun, was man wollte, insbesondere bei mehreren Schritten, fühlte sich eher wie ein Gebet als wie Programmierung an.
Die letzten Updates, besonders wie Agenten mit Tools interagieren und strukturierte Ausgaben erzeugen, haben das Spiel für mich wirklich geändert. Es ist von „experimentellem Spielplatz“ zu „tatsächlich nützlich für meine freiberufliche Arbeit“ gewechselt. Und das ist bedeutend.
Meine Frustration mit unzuverlässigen Agenten (und wie das hilft)
Lasst mich ein Bild malen. Vor ein paar Monaten versuchte ich, einen einfachen Agenten für eine Freundin zu bauen, die einen kleinen E-Commerce-Shop betreibt. Ihr Problem: Kunden stellen oft sehr ähnliche Fragen zu Produkten, Versand und Rückgaben, und sie verbrachte viel zu viel Zeit damit, Antworten zu kopieren und einzufügen. Meine Idee war ein Agent, der:
- Produktdetails (Preis, Verfügbarkeit) aus einer Dummy-Datenbank abrufen kann.
- Versandzonen und -zeiten überprüfen kann.
- Eine höfliche, präzise Antwort formulieren kann.
Klingt einfach, oder? Ist es nicht wirklich. Meine frühen LangChain-Versuche waren ein Durcheinander. Der Agent würde manchmal Produkt-IDs halluzinieren, oder vergessen, das Versand-Tool aufzurufen, oder einfach ein konversationelles Geschwafel anstelle einer präzisen Antwort ausgeben. Ihn dazu zu bringen, konsequent ein spezielles Format, wie ein JSON-Objekt, das die Antwort und die verwendeten Tools enthält, auszugeben, war ein Albtraum. Ich verbrachte Stunden damit, ihn mit ausgeklügelten Aufforderungen zu überreden, nur damit er bei einem Randfall versagte.
Hier glänzt das neue Agenten-Framework. LangChain hat wirklich verbessert, wie Agenten entscheiden, welche Tools zu verwenden sind und, entscheidend, wie sie ihre Ergebnisse zurückmelden. Es geht weniger darum, zu hoffen, dass das LLM „es herausfindet“ und mehr darum, ihm einen klaren, strukturierten Weg zu geben.
Die Kernidee: Besseres Tool-Calling und strukturierte Ausgaben
Die größte Verbesserung, meiner Meinung nach, kommt aus einer Kombination von Dingen:
- Verbesserte Tool-Definition: Tools werden jetzt mit Pydantic-Schemas definiert, was dem LLM viel klarer macht, welche Eingaben es erwartet.
- Funktion-Calling-APIs (z.B. OpenAI’s): LangChain nutzt diese im Hintergrund, um die Auswahl der Tools viel zuverlässiger zu machen. Das LLM „rät“ nicht einfach, welches Tool es verwenden soll; es wird explizit über die verfügbaren Funktionen und deren Parameter informiert.
- Parser für strukturierte Ausgaben: Das ist der heilige Gral für mich. Kein Herumprobieren mehr, um aus einem Freitext-Blob eine Antwort herauszufiltern. Wir können jetzt genau definieren, welche Struktur wir von der endgültigen Antwort des Agenten erwarten.
Schauen wir uns ein einfaches Beispiel an, um das zu veranschaulichen. Stellen wir uns vor, wir haben ein Tool, um den aktuellen Lagerbestand für ein Produkt abzurufen.
Beispiel: Ein einfaches Lagerbestandsprüfungs-Tool
Zuerst definieren wir unser Tool mithilfe eines Pydantic-Modells für die Eingabe:
from langchain_core.tools import tool
from pydantic import BaseModel, Field
class ProductStockInput(BaseModel):
product_id: str = Field(description="Die eindeutige Kennung für das Produkt.")
@tool("get_product_stock", args_schema=ProductStockInput)
def get_product_stock(product_id: str) -> dict:
"""
Ruft den aktuellen Lagerbestand für eine gegebene Produkt-ID ab.
Gibt ein Dictionary mit product_id und stock_level zurück.
"""
# Dies würde typischerweise eine Datenbank abfragen
stock_data = {
"P101": 50,
"P102": 0, # Ausverkauft
"P103": 15
}
stock_level = stock_data.get(product_id, -1) # -1 für nicht gefunden
if stock_level == -1:
return {"product_id": product_id, "stock_level": "Produkt nicht gefunden"}
return {"product_id": product_id, "stock_level": stock_level}
tools = [get_product_stock]
Beachtet das `args_schema` hier. Das ist entscheidend. Es sagt dem LLM genau, welche Argumente `get_product_stock` erwartet und welche Typen sie haben. Keine Mehrdeutigkeit mehr.
Den Agenten mit strukturierten Ausgaben aufbauen
Jetzt bauen wir einen Agenten, der dieses Tool verwendet und, was wichtig ist, seine endgültige Antwort auf strukturierte Weise bereitstellt. Für meine E-Commerce-Freundin wollte ich, dass der Agent die Anfrage des Kunden, die Antwort des Agenten und alle verwendeten Tools in einem schönen JSON-Format ausgibt.
from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.messages import BaseMessage
from typing import List, Union, Dict, Any
# Definiere das strukturierte Ausgabeformat für die endgültige Antwort des Agenten
class AgentResponse(BaseModel):
original_query: str = Field(description="Die ursprüngliche Anfrage des Kunden.")
agent_answer: str = Field(description="Die formulierte Antwort des Agenten auf die Anfrage.")
tools_used: List[str] = Field(description="Eine Liste von Namen der Tools, die der Agent verwendet hat.")
metadata: Dict[str, Any] = Field(description="Zusätzliche Metadaten oder Ergebnisse der Tools.")
# Lade den Basis-Prompt für den OpenAI-Tools-Agent
prompt = hub.pull("hwchase17/openai-tools-agent")
llm = ChatOpenAI(model="gpt-4-0125-preview", temperature=0) # Verwendung eines aktuellen GPT-4 zur Zuverlässigkeit
# Erstelle den Agenten
agent = create_openai_tools_agent(llm, tools, prompt)
# Erstelle den Agenten-Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Jetzt definieren wir, wie der Agent mit structured_output reagieren soll
# Hier passiert die Magie für zuverlässige strukturierte Ausgaben!
structured_agent_executor = agent_executor.with_structured_output(AgentResponse)
# Lass es uns testen!
query1 = "Was ist der Lagerbestand für Produkt P101?"
response1 = structured_agent_executor.invoke({"input": query1})
print("\n--- Antwort 1 ---")
print(response1.json(indent=2))
query2 = "Ist das Produkt P102 verfügbar?"
response2 = structured_agent_executor.invoke({"input": query2})
print("\n--- Antwort 2 ---")
print(response2.json(indent=2))
query3 = "Was ist die Hauptstadt von Frankreich?" # Der Agent sollte unser Tool dafür nicht verwenden
response3 = structured_agent_executor.invoke({"input": query3})
print("\n--- Antwort 3 ---")
print(response3.json(indent=2))
Wenn du das ausführst, wirst du in der ausführlichen Ausgabe sehen, wie das LLM zuerst den Bedarf für `get_product_stock` erkennt, es mit der richtigen `product_id` aufruft und dann das Ergebnis verwendet, um seine `agent_answer` zu formulieren. Noch wichtiger ist, dass die *endgültige Ausgabe* ein `AgentResponse`-Objekt ist, nicht nur ein String. Das ist unglaublich mächtig für die nachfolgende Verarbeitung, Protokollierung oder sogar einfach nur, um konsistente Informationen einem Benutzer anzuzeigen.
Was ich an `with_structured_output` liebe
Diese `with_structured_output`-Methode ist ein wesentlicher Fortschritt. Sie bedeutet, dass ich die Antworten des Agenten zuverlässig in andere Teile meiner Anwendung integrieren kann. Ich muss keine anfällige Parsing-Logik schreiben. Wenn der Agent irgendwie abweicht, wird Pydantic das oft entdecken und mir einen klaren Fehler anzeigen, anstatt stillschweigend zu versagen oder Müll zurückzugeben.
Für meine E-Commerce-Freundin bedeutet das, dass ihr Kundenservice-Portal jetzt die Antwort des Agenten mit Zuversicht anzeigen kann, da sie sicher weiß, dass sie im richtigen Format vorliegt. Wir können sogar die Felder `tools_used` und `metadata` protokollieren, um zu verstehen, wie oft der Agent spezifische Tools verwendet oder ob es häufige Fragen gibt, die er nicht beantworten kann.
Über einfache Tools hinaus: Mehrstufiges Denken mit Zuverlässigkeit
Der echte Test für einen Agenten ist oft das mehrstufige Denken. Lassen Sie uns ein weiteres Tool hinzufügen: eines, das geschätzte Versandzeiten basierend auf einer Produkt-ID und einer Zielzone abruft.
from langchain_core.tools import tool
from pydantic import BaseModel, Field
# ... (ProductStockInput und get_product_stock bleiben gleich) ...
class ShippingInfoInput(BaseModel):
product_id: str = Field(description="Die eindeutige Kennung für das Produkt.")
destination_zone: str = Field(description="Die Versandzone (z.B. 'Zone A', 'Zone B').")
@tool("get_shipping_info", args_schema=ShippingInfoInput)
def get_shipping_info(product_id: str, destination_zone: str) -> dict:
"""
Gibt die geschätzten Versandzeiten für ein Produkt in eine bestimmte Zone an.
Gibt ein Dictionary mit product_id, zone und estimated_days zurück.
"""
# Dummy-Daten für den Versand
shipping_times = {
("P101", "Zone A"): "3-5 Werktage",
("P101", "Zone B"): "5-7 Werktage",
("P103", "Zone A"): "2-4 Werktage",
("P103", "Zone B"): "4-6 Werktage",
}
key = (product_id, destination_zone)
estimated_days = shipping_times.get(key, "Variiert, bitte den Support kontaktieren")
return {"product_id": product_id, "destination_zone": destination_zone, "estimated_days": estimated_days}
tools_multi = [get_product_stock, get_shipping_info]
# Erstelle Agent und Executor mit den neuen Tools neu
agent_multi = create_openai_tools_agent(llm, tools_multi, prompt)
agent_executor_multi = AgentExecutor(agent=agent_multi, tools=tools_multi, verbose=True)
structured_agent_executor_multi = agent_executor_multi.with_structured_output(AgentResponse)
# Teste eine mehrstufige Anfrage
multi_step_query = "Wie ist der Lagerbestand für P101 und wie lange würde der Versand nach Zone A dauern?"
response_multi = structured_agent_executor_multi.invoke({"input": multi_step_query})
print("\n--- Mehrstufige Antwort ---")
print(response_multi.json(indent=2))
Du wirst in der ausführlichen Ausgabe feststellen, dass der Agent jetzt intelligent zuerst `get_product_stock` aufruft, dann `get_shipping_info` und die Informationen in eine kohärente Antwort kombiniert, während er die Struktur von `AgentResponse` respektiert. Dies ist ein gewaltiger Fortschritt im Vergleich zu früher, als man diese Toolaufrufe explizit verknüpfen musste oder hoffen musste, dass das LLM die richtige Reihenfolge inferiert.
Meine Erkenntnisse & warum das jetzt wichtig ist
Warum ist mir das jetzt so wichtig? Weil es sich anfühlt, als hätten sich die LangChain-Agenten, insbesondere mit der Kombination aus `create_openai_tools_agent` und `with_structured_output`, endlich zu einem Punkt weiterentwickelt, an dem sie für Entwickler, die praktische Anwendungen erstellen, wirklich nützlich sind. Kein endloses Prompt-Engineering mehr, um einen JSON-Ausgabe zu erzwingen, keine fragilen Regex-Parser mehr und deutlich weniger „halluzinierte Toolaufrufe“.
Handlungsorientierte Erkenntnisse für dich:
- Überdenke LangChain-Agenten: Wenn du vor einem Jahr LangChain-Agenten ausprobiert hast und frustriert warst, ist jetzt der Zeitpunkt, sie dir erneut anzusehen. Die Verbesserungen bei den Toolaufrufen und der strukturierten Ausgabe sind erheblich.
- Definiere Tools mit Pydantic: Definiere immer deine Tool-Eingaben mithilfe von Pydantic-Modellen mit klaren Beschreibungen. Das gibt dem LLM die beste Chance zu verstehen, wann und wie es deine Tools nutzen kann.
- Nutze `with_structured_output`: Dies ist dein bester Freund für eine zuverlässige Agenten-Integration. Definiere ein Pydantic-Modell für die endgültige Ausgabe deines Agents und nutze `agent_executor.with_structured_output(YourOutputModel)`. Das wird dir unzählige Stunden beim Debuggen und Parsen ersparen.
- Starte einfach, dann erweitere: Versuche nicht, sofort einen Super-Agenten zu erstellen. Beginne mit ein oder zwei einfachen Tools und einer klaren Ausgabestruktur. Sobald das zuverlässig funktioniert, füge nach und nach mehr Komplexität hinzu.
- Verwende detaillierte Tool-Beschreibungen: Das Feld `description` in deinem `@tool`-Dekorator ist das, was das LLM liest, um zu entscheiden, ob es ein Tool verwenden soll. Mache es klar, prägnant und erkläre, was das Tool *macht* und was es *zurückgibt*.
- Nutze OpenAI’s Function Calling: Während dieser Artikel sich auf LangChain konzentriert, kommt die zugrunde liegende Zuverlässigkeit oft von LLMs wie OpenAI’s GPT-Modellen, die solide Funktionalitäten bieten. Stelle sicher, dass du Modelle verwendest, die das unterstützen, um die besten Ergebnisse zu erzielen.
Ich glaube wirklich, dass diese Fortschritte den Bau intelligenter Agenten viel zugänglicher und, noch wichtiger, viel zuverlässiger machen. Für jeden, der KI-gestützte Funktionen entwickelt, sei es ein Kundenservice-Bot, ein Datenanalyse-Assistent oder einfach nur zur Automatisierung mühsamer Aufgaben, ist die Fähigkeit, vorhersehbar mit einem Agenten zu interagieren und strukturierte Daten zurückzubekommen, ein bedeutender Wandel. Es hat Agenten von einem coolen Demo zu einem wirklich nützlichen Bestandteil des Entwickler-Toolkits verwandelt.
Das war’s von mir für heute. Probier es aus und lass mich wissen, was du baust! Teile deine Gedanken und Erfahrungen in den Kommentaren unten. Viel Spaß beim Erstellen von Agenten!
🕒 Published: