Zuverlässigere KI-Agenten mit LangSmith entwickeln

Einführung

Die Entwicklung autonomer Agenten mit großen Sprachmodellen kann häufig unvorhersehbar und schwer kontrollierbar wirken. Prompts liefern unter Umständen bei mehreren Durchläufen unterschiedliche Ergebnisse, Tools können ohne erkennbare Warnsignale ausfallen, und Modelle können halluzinieren, sich wiederholen oder in Schleifen geraten, ohne dass eindeutige Hinweise darauf sichtbar sind. LangSmith ist eine Plattform zur Instrumentierung, Fehleranalyse, Bewertung und Überwachung von LLM-Anwendungen, damit solche Probleme leichter erkannt und behoben werden können. Entwickler erhalten dadurch eine durchgängige Sicht darauf, wie sich ein Agent verhält.

In diesem Tutorial durchläufst du einen typischen Zuverlässigkeitsprozess für Agenten: Tracing einrichten, Läufe automatisch und manuell debuggen, die Leistung bewerten, Prompts verbessern und den Agenten nach der Bereitstellung überwachen. Am Ende weißt du, was LangSmith ist, wie es die Agentenentwicklung unterstützt und wie es dabei hilft, verlässlichere KI-Agenten zu erstellen.

Wichtige Erkenntnisse

Observability ist die Grundlage zuverlässiger Agenten

Das Tracing von LangSmith macht jeden LLM-Aufruf, jede Tool-Ausführung und jeden Zwischenschritt im Reasoning sichtbar. Dadurch lässt sich nachvollziehen, warum ein Agent eine bestimmte Entscheidung getroffen hat, anstatt den Ablauf mühsam aus einfachen Logs rekonstruieren zu müssen.

Traces machen Debugging analytisch

Strukturierte Traces ermöglichen es, Fehler detailliert zu untersuchen und zu erkennen, ob die Ursache in einem Prompt, einem Tool, der Retrieval-Logik oder der Orchestrierung liegt. So kann genau die Stelle korrigiert werden, an der der Prozess fehlgeschlagen ist.

Evaluation unterstützt sichere Iterationen

LangSmith bietet datensatzbasierte Evaluations-Workflows für Offline-Tests und Online-Monitoring. Diese Workflows helfen dabei, Qualität zu messen, Prompt- oder Modellversionen zu vergleichen und Regressionen zu erkennen, bevor Änderungen in die Produktion übernommen werden.

Prompt Engineering wird systematisch

Der Prompt Playground und die Prompt-Versionierung machen Prompts zu nachvollziehbaren Assets. Teams können gemeinsam an Prompt-Verbesserungen arbeiten, früheres Verhalten reproduzieren und steuern, wie Änderungen freigegeben werden.

Menschliches Feedback schließt den Kreislauf

Annotation Queues, darunter Single-Run- und Pairwise-Reviews, helfen Teams dabei, menschliche Bewertung in größerem Umfang einzusetzen. Das ist besonders wertvoll, wenn automatisierte Metriken die Qualität nicht vollständig erfassen.

Was ist LangSmith und wann ist es sinnvoll?

LangSmith ist ein End-to-End-Toolkit zum Erstellen, Debuggen, Testen, Evaluieren und Bereitstellen von LLM-gestützten Anwendungen. Mit LangSmith kannst du:

• Jede Anfrage verfolgen und jeden Schritt im Reasoning eines Agenten erfassen.
• Ausgaben bewerten, um die Qualität generierter Antworten zu überprüfen.
• Prompts mithilfe von Versionierung weiterentwickeln.
• Agentenbereitstellungen verwalten.

Im Gegensatz zu manchen Observability-Tools, die eng an ein bestimmtes Framework für LLM-Anwendungen gebunden sind, ist LangSmith frameworkunabhängig. Es kann mit LangChain, LangGraph oder eigenem Code eingesetzt werden. Dein Agent muss also nicht auf LangChain basieren, um von den Tracing- und Evaluationsfunktionen von LangSmith zu profitieren.

LangSmith ist besonders nützlich, wenn Prompts mit externen Tools oder APIs interagieren, Agenten mehrstufiges Reasoning ausführen oder Reproduzierbarkeit und Debugging wichtig sind. Wenn einfache Log-Ausgaben nicht mehr ausreichen und du verstehen möchtest, warum sich ein Agent auf eine bestimmte Weise verhalten hat, ist LangSmith eine sinnvolle Option.

Das Agent-Debugging-Problem, das LangSmith löst

Die Entwicklung autonomer Agenten ist anspruchsvoll, weil Fehler oft subtil und schwer zu interpretieren sind. Schon eine kleine Änderung am Prompt oder eine nicht-deterministische Antwort eines Tools kann den Reasoning-Pfad stark verändern. Standard-Logs und Metriken reichen meist nicht aus, um die Aktionen eines Agenten zu erklären. Du siehst vielleicht eine falsche Antwort oder einen Timeout, aber die eigentliche Ursache ist nicht sofort erkennbar.

Beispielsweise könnte das Problem darin liegen, dass der Agent das falsche Tool ausgewählt hat, wichtiger Kontext im Prompt fehlte oder ein LLM-Aufruf einen Fehler eingeführt hat, der erst später sichtbar wurde. LangSmith-Traces sollen genau solche Fragen beantwortbar machen.

Ohne detaillierte Traces wird das Debugging von Agenten schnell zu einem Ratespiel. Agenten können stillschweigend fehlschlagen, halluzinieren oder in Schleifen hängen bleiben, sodass du den Fehler manuell reproduzieren musst. LangSmith löst dieses Problem, indem jeder Schritt des Agentenpfads aufgezeichnet wird, darunter LLM-Aufrufe, Tool-Ausführungen, Zwischenprompts und weitere Details. Diese Informationen werden in einer strukturierten Zeitleiste, einem sogenannten Trace, dargestellt.

Stell dir zum Beispiel vor, ein Agent nutzt ein Such-Tool, um Informationen abzurufen. Wenn die endgültige Antwort falsch ist, kann das mehrere Ursachen haben: Das Such-Tool hat falsche oder leere Ergebnisse geliefert, das LLM hat die abgerufenen Informationen ignoriert und halluziniert, oder die Agentenlogik hat das Tool nicht aufgerufen, obwohl es notwendig gewesen wäre.

Ein LangSmith-Trace würde jeden Schritt zeigen: die Suchanfrage, das vom Such-API zurückgelieferte Ergebnis, den daraus erzeugten Prompt, die Antwort des LLM und die folgenden Schritte. Dadurch lässt sich schnell erkennen, an welcher Stelle die Kette vom erwarteten Ablauf abgewichen ist.

Quickstart: Einen Agentenlauf mit Python tracen

Dieser Abschnitt zeigt ein kurzes Beispiel dafür, wie du LangSmith nutzt, um einen Agentenlauf zu tracen. Das Beispiel verwendet Python. LangSmith stellt außerdem SDKs für JavaScript und TypeScript bereit, mit denen ähnliche Tracing-Workflows möglich sind. In diesem Beispiel instrumentierst du einen einfachen LLM-Aufruf und betrachtest den erzeugten Trace in der LangSmith-Oberfläche.

Voraussetzungen

Erstelle ein kostenloses LangSmith-Konto, falls du noch keines hast, und kopiere deinen API-Schlüssel. Zusätzlich benötigst du einen API-Schlüssel deines LLM-Anbieters, zum Beispiel OpenAI. Installiere die erforderlichen Pakete:

pip install -U langsmith openai  # for this example

1. LangSmith-Tracing aktivieren

LangSmith funktioniert direkt mit LangChain. Wenn du LangChain bereits verwendest, kannst du Tracing über eine Umgebungsvariable aktivieren. Definiere in deiner Umgebung oder in deiner .env-Datei die folgenden Werte:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="<your-langsmith-api-key>"
export OPENAI_API_KEY="<your-openai-api-key>"

Diese Variablen stellen sicher, dass LangSmith-Tracing aktiviert und authentifiziert ist. Wenn du mehrere LangSmith-Workspaces nutzt, setze zusätzlich LANGSMITH_WORKSPACE_ID passend. Du kannst diese Variablen auch in Python über os.environ setzen, bevor du ein LLM initialisierst.

Wichtig: Das Flag LANGSMITH_TRACING=true muss gesetzt sein, bevor dein Code LLM-Aufrufe ausführt, damit das SDK diese erfassen kann.

2. Einen LLM-Client verwenden oder wrappen

Wenn du die LLM-Klassen von LangChain nutzt, brauchst du keinen zusätzlichen Spezialcode, um Traces aufzuzeichnen. Es reicht aus, sicherzustellen, dass die Umgebungsvariable aktiv ist. Ein Beispiel mit dem OpenAI-Wrapper von LangChain:

import os
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = "<your-langsmith-api-key>"
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-3.5-turbo")  # This is LangChain's LLM wrapper
response = llm.predict("Hello, world!")
print(response)

Beim Ausführen erkennt LangChain, dass Tracing aktiviert ist, und protokolliert den Aufruf im Hintergrund in LangSmith. Öffne nach der Ausführung des Codes die LangSmith-Weboberfläche und sieh dir den Trace in der Trace-Liste des Standardprojekts an.

Wenn du LangChain nicht verwendest, kannst du LLM-Aufrufe manuell mit dem LangSmith-SDK instrumentieren. Um beispielsweise OpenAI-API-Aufrufe direkt zu tracen, stellt LangSmith den Helper wrap_openai bereit:

from langsmith import wrappers
import openai
openai.api_key = os.environ["OPENAI_API_KEY"]
openai_client = wrappers.wrap_openai(openai.OpenAI())  # wrap the OpenAI client for tracing
# Now any call through openai_client will be traced:
result = openai_client.ChatCompletion.create(
   model="gpt-3.5-turbo",
   messages=[ {"role": "user", "content": "Hello, world?"} ]
)
print(result["choices"][0]["message"]["content"])

In diesem Beispiel erzeugt langsmith.wrappers.wrap_openai einen getracten Client. LangSmith bietet ähnliche Wrapper auch für andere Anbieter, darunter Anthropic. Nach dem Ausführen des Codes erscheint der vollständige Trace in LangSmith, inklusive Modellanfrage und Antwort.

3. Den Trace anzeigen

Öffne die LangSmith-Web-App und gehe zu Observability / Traces. Dort sollte ein neuer Eintrag für den Lauf erscheinen. Klicke darauf, um eine strukturierte Ansicht zu öffnen. Da dieses Beispiel sehr einfach ist, enthält der Trace möglicherweise nur einen einzelnen LLM-Call-Knoten mit Prompt und Ausgabe.

Bei einer komplexeren Chain oder einem Agenten würde der Trace als Baum mit allen Teilschritten angezeigt, zum Beispiel dem Reasoning-Ablauf des Agenten und jedem Tool-Aufruf. Du kannst Laufzeiten, Eingaben, Ausgaben, Annotationen und teilbare Trace-Details prüfen. Diese Sichtbarkeit hilft dir zu bestätigen, dass der Agent wie erwartet funktioniert hat. Falls etwas fehlgeschlagen ist, zeigt der Trace, wo und warum es passiert ist.

Tipp: In der Produktion möchtest du möglicherweise nicht jeden Lauf tracen, um Kosten zu kontrollieren. LangSmith unterstützt Sampling von Traces sowie das Aktivieren oder Deaktivieren von Tracing im Code. Du kannst zum Beispiel nur einen bestimmten Prozentsatz von Anfragen oder ausgewählte Sessions tracen, indem du die Umgebungsvariable dynamisch setzt oder das Konfigurations-SDK von LangSmith verwendest. Während Entwicklung und Debugging ist global aktiviertes Tracing meist der einfachste Weg.

Traces lesen

Sobald Traces verfügbar sind, folgt die Diagnose von Problemen. Ein LangSmith-Trace funktioniert ähnlich wie ein Experimentprotokoll. Er hilft dabei, Fehler zu kategorisieren und wiederkehrende Muster zu erkennen. Die folgende Tabelle zeigt typische Fehlertypen und wie Traces bei ihrer Behebung helfen.

Betrachte einen Trace als Forschungsprotokoll. Kategorisiere jedes Problem, zum Beispiel als Prompt-, Tool-, Retrieval- oder Orchestrierungsproblem. Bewerte anschließend die Auswirkungen, etwa ob ein harter Fehler entstanden ist oder nur die Antwortqualität gelitten hat. LangSmith macht Eingaben, Prompts, Tool-Reihenfolge, Speicher- oder Zustandsänderungen, Latenz, Kosten und Fehlerpfade explizit und prüfbar.

Evaluations-Workflow: Datensätze, Evaluatoren und Experimente

Tracing erklärt, was während eines einzelnen Laufs passiert ist. Evaluation zeigt, wie gut die Ergebnisse über viele Läufe hinweg sind oder wie sich verschiedene Versionen eines Agenten vergleichen lassen. LangSmith enthält einen vollständigen Evaluations-Workflow für Offline-Tests und Online-Qualitätsmonitoring.

Offline- vs. Online-Evaluation

LangSmith unterstützt sowohl Offline- als auch Online-Evaluation. Offline-Evaluation findet statt, bevor Änderungen veröffentlicht werden. Du bereitest einen Datensatz mit Beispieleingaben vor, optional mit erwarteten Ausgaben, und lässt den Agenten alle Beispiele durchlaufen, um die Leistung zu messen. Das ist nützlich, um Regressionen zu erkennen und Prompt- oder Modellversionen kontrolliert zu vergleichen.

Online-Evaluation läuft in der Produktion. Dabei werden echte Nutzerinteraktionen kontinuierlich ausgewertet, während sie stattfinden, sodass die Qualität auf Live-Daten überwacht werden kann. Beide Ansätze sind hilfreich: Offline-Evaluation ähnelt Unit- oder Integrationstests für Agenten, während Online-Evaluation eher wie Live-Monitoring oder Canary-Testing funktioniert.

1. Einen Datensatz erstellen

Ein Datensatz ist eine Sammlung von Testfällen für deinen Agenten. Diese Beispiele können aus früheren Fehlern, synthetischen Fällen mit erwarteter Schwierigkeit oder Nutzerfragen stammen, die zuverlässig beantwortet werden sollen. In LangSmith besteht ein Datensatz aus Input-Output-Paaren oder nur aus Inputs, wenn keine Ground-Truth-Ausgabe vorhanden ist.

Du kannst Datensätze über die UI oder das SDK erstellen und verwalten. Ein Beispiel in Python:

from langsmith import Client
client = Client()
dataset = client.create_dataset("MathQA set", description="Simple math Q&A tests")
client.create_examples(dataset.id, examples=[
   {"inputs": {"question": "What is 2+2?"}, "outputs": {"answer": "4"}},
   {"inputs": {"question": "What is the capital of France?"}, "outputs": {"answer": "Paris"}}
])

Dadurch wird ein Datensatz mit zwei Q&A-Beispielen erstellt. Alternativ kannst du Datensätze aus CSV- oder JSON-Dateien hochladen oder direkt in der Benutzeroberfläche anlegen.

2. Evaluatoren definieren

Evaluatoren sind Funktionen oder Modelle, die die Ausgabe deines Agenten für jedes Beispiel bewerten. LangSmith enthält integrierte Evaluatoren und unterstützt benutzerdefinierte Varianten. Typische Evaluatortypen sind:

• Korrektheit oder Wahrheitsgehalt: Prüft, ob die Ausgabe einer bekannten korrekten Referenzantwort entspricht. Dafür sind Referenzausgaben im Datensatz erforderlich.
• Rubrikbewertung: Nutzt eine eigene Python-Funktion oder Heuristik, etwa um zu prüfen, ob eine Antwort eine Quellenangabe enthält.
• LLM-as-Judge: Verwendet ein weiteres LLM, um die Ausgabequalität zu bewerten. Ein Modell kann zum Beispiel die Agentenausgabe mit der Referenzantwort vergleichen und einen Score vergeben.
• Pairwise-Vergleich: Vergleicht zwei Ausgaben, etwa Modell A gegen Modell B, und entscheidet, welche besser ist.

Du kannst einem Experiment einen oder mehrere Evaluatoren zuweisen. LangSmith verwendet die OpenEvals-Bibliothek für Open-Source-Evaluatoren. Um beispielsweise einen LLM-as-Judge-Evaluator für Korrektheit zu nutzen, kannst du einen Prompt wie CORRECTNESS_PROMPT importieren und einen Judge erstellen:

from openevals.llm import create_llm_as_judge
from openevals.prompts import CORRECTNESS_PROMPT
judge = create_llm_as_judge(prompt=CORRECTNESS_PROMPT)

Dieser Judge kann jede Ausgabe bewerten, indem er ein LLM fragt, ob die Antwort auf Basis der Referenz korrekt ist, und anschließend einen Score zurückgibt.

3. Ein Experiment ausführen

Im nächsten Schritt lässt du deinen Agenten über den Datensatz laufen und sammelst Ergebnisse. In der LangSmith-UI kannst du ein neues Experiment erstellen, den Datensatz auswählen, die Zielfunktion wie Agent oder Chain festlegen und Evaluatoren anhängen.

Wenn du Code verwendest, kannst du etwas Ähnliches ausführen:

client = Client()
# Assuming `target_fn` is your function that takes an input dict and returns an output dict
experiment = client.run_on_dataset(
   dataset_name="MathQA set",
   func=target_fn,
   evaluators=[judge]  # the evaluator we defined
)

Dadurch wird target_fn für jedes Beispiel im Datensatz ausgeführt. Die Ausgaben werden protokolliert und von den Evaluatoren bewertet. LangSmith speichert diese Daten in einem Experimentobjekt, das du anschließend untersuchen kannst.

In der UI zeigt ein Experiment eine sich live aktualisierende Ergebnistabelle. Dort siehst du jedes Beispiel, die Modellausgabe und die Evaluator-Scores. So lassen sich Muster erkennen, etwa wenn ein Agent bei allen mathematischen Fragen mit Division scheitert.

4. Ergebnisse analysieren

Nach Abschluss des Experiments kannst du die Läufe in LangSmith vergleichen und auswerten. Du kannst nach Score sortieren und filtern, nur Beispiele mit niedriger Korrektheit anzeigen oder zwei Experimente vergleichen, beispielsweise Agent v1 gegen Agent v2 auf demselben Datensatz.

Das ist hilfreich für Benchmarks von Prompt-Versionen und Modellen. Außerdem unterstützt es Regressionstests, weil du einen Golden Dataset pflegen und sicherstellen kannst, dass zukünftige Versionen bei diesen Beispielen keine schlechteren Scores erzielen.

5. Verbesserungen iterieren

Wenn die Evaluationsergebnisse nicht gut genug sind, verfeinerst du den Agenten, indem du Prompts verbesserst, Beispiele ergänzt, die Tool-Nutzung änderst oder die Orchestrierungslogik korrigierst. Anschließend führst du ein weiteres Experiment aus.

Ein besonders nützlicher Workflow ist der Prompt Playground in LangSmith. Diese No-Code-Oberfläche ermöglicht es, verschiedene Prompt-Varianten schnell zu bewerten. Du kannst einen Datensatz laden, unterschiedliche Prompt-Templates oder Modellparameter testen und unmittelbar Evaluations-Scores ansehen.

Evaluation muss nicht immer vollständig automatisiert ablaufen. Automatisierte Metriken und LLM-Judges können wichtige Qualitätsaspekte übersehen. In solchen Fällen ist menschliche Prüfung sinnvoll. LangSmith unterstützt dies über Annotation Queues, die im nächsten Abschnitt beschrieben werden.

Human-in-the-Loop: Annotation Queues für Qualität im großen Maßstab

Automatisierte Evaluatoren sind nützlich, doch für besonders genaue Qualitätsbewertungen ist oft menschliche Evaluation erforderlich. Annotation Queues in LangSmith bieten eine skalierbare Möglichkeit, Agentenausgaben zu überprüfen. Modellausgaben können in eine Warteschlange gelegt werden, in der menschliche Reviewer wie Entwickler, Kollegen oder professionelle Labeler sie anhand einer vordefinierten Bewertungsrubrik beurteilen.

LangSmith unterstützt zwei Arten von Annotation Queues:

Single-Run Annotation Queues

Single-Run Queues zeigen dem Reviewer jeweils eine Ausgabe zusammen mit einer Rubrik oder konkreten Fragen. Eine Frage kann zum Beispiel lauten: „Ist diese Antwort faktisch korrekt?“ oder „Bewerte die Klarheit der Antwort von 1 bis 5.“ Der Reviewer sieht den relevanten Kontext, etwa Prompt, Ausgabe und gegebenenfalls eine Referenzantwort, und übermittelt anschließend Feedback für diesen Lauf.

Pairwise Annotation Queues

Pairwise Annotation Queues zeigen zwei Ausgaben nebeneinander und bitten den Reviewer auszuwählen, welche besser ist oder ob beide gleichwertig sind. Das ist nützlich für A/B-Tests, etwa wenn Agent Version A und Version B dieselbe Frage beantworten. Pairwise-Vergleiche helfen außerdem beim Vergleich eines neuen Modells oder Prompts mit einer älteren Version, was häufig bei Fine-Tuning und Reinforcement Learning from Human Feedback eingesetzt wird.

Wann welcher Queue-Typ sinnvoll ist

Single-Run Queues eignen sich, wenn absolute Bewertungen oder kategoriale Labels für Ausgaben benötigt werden. Sie sind hilfreich, um einen Datensatz mit menschlichen Bewertungen zum Trainieren eines Evaluators aufzubauen oder Qualität zu überwachen.

Pairwise Queues sind sinnvoll, wenn relative Qualität wichtiger ist. Du möchtest zum Beispiel bestätigen, dass eine neue Version besser ist als die vorherige, und verstehen, wie deutlich Menschen sie bevorzugen. Viele Teams nutzen Pairwise Reviews für Preference Modeling oder Reinforcement Learning from Human Feedback, weil es Menschen oft leichter fällt, zwischen zwei Ausgaben zu wählen, als einen absoluten Score zu vergeben.

LangSmith im Vergleich zu Alternativen

Das Ökosystem für LLM-Observability und Feedback entwickelt sich schnell. Mehrere Tools bieten Funktionen, die sich mit LangSmith überschneiden. Die folgende Übersicht fasst LangSmith und einige gängige Alternativen zusammen.

FAQ

Brauche ich LangChain, um LangSmith zu verwenden?

Nein. LangSmith ist frameworkunabhängig. Du kannst es mit LangChain, LangGraph oder ganz ohne Framework nutzen. Wenn du LangChain bereits verwendest, lässt sich LangSmith mit minimalem Aufwand integrieren, indem Umgebungsvariablen gesetzt werden, die Chains und Agenten automatisch protokollieren. Wenn du kein Framework nutzt, kannst du LLM-Aufrufe oder Agentenlogik manuell mit dem LangSmith-SDK tracen.

Kann ich Prompts evaluieren, ohne Code zu schreiben?

Ja. LangSmith bietet einen Prompt Playground und eine Evaluationsoberfläche, mit denen viele Workflows ohne Programmierung möglich sind. Du kannst zum Beispiel einen Datensatz erstellen und ein Experiment direkt in der Weboberfläche ausführen, indem du Beispiele hinzufügst, einen Evaluator auswählst und den Lauf startest.

Was ist der Unterschied zwischen Single-Run- und Pairwise-Annotationen in LangSmith?

Bei Single-Run-Annotationen sieht ein menschlicher Reviewer jeweils eine einzelne Ausgabe und gibt anhand einer Rubrik Feedback, etwa zur Korrektheit oder zu einer anderen Qualität. Bei Pairwise-Annotationen sieht der Reviewer zwei Ausgaben nebeneinander, üblicherweise von zwei verschiedenen Modellversionen für dieselbe Eingabe, und wählt aus, welche besser ist oder ob beide gleichwertig sind. Single-Run-Annotation bewertet eine Ausgabe isoliert, während Pairwise-Annotation Ausgaben miteinander vergleicht.

Was muss gesetzt sein, damit LLM-Aufrufe von LangSmith getract werden?

Die wichtigste Voraussetzung ist, Tracing über Umgebungsvariablen oder Konfiguration zu aktivieren. Der einfachste Weg ist, LANGSMITH_TRACING=true zu setzen, bevor die Anwendung gestartet wird. Zusätzlich sollte LANGSMITH_API_KEY gesetzt werden, damit die Daten deinem Konto zugeordnet werden, ebenso wie die jeweiligen Modell-API-Schlüssel, etwa OPENAI_API_KEY.

Mit LANGSMITH_TRACING=true beginnen unterstützte Integrationen wie LangChain automatisch mit dem Logging. Falls Umgebungsvariablen nicht möglich sind, unterstützt LangSmith auch programmatische Tracing-Konfiguration. Ein Beispiel in Python:

from langsmith import Client
client = Client()
client.configure_tracing(True)

Dies ist ein konzeptionelles Beispiel, und die konkrete API kann abweichen. Die Kernaussage ist, dass Tracing im Code aktiviert werden kann. Nach dem Ausführen der Chain oder des Agenten sollten Traces in der LangSmith-UI erscheinen. Falls nicht, prüfe, ob die Umgebungsvariablen im selben Laufzeitkontext wie die Anwendung definiert sind und ob der richtige Workspace verwendet wird.

Ist LangSmith nur für Tracing gedacht oder unterstützt es auch Deployments?

LangSmith wurde mit Fokus auf Observability und Evaluation entwickelt, enthält aber auch ein Deployment-Modul. Agenten können über LangSmith als verwaltete Endpunkte bereitgestellt werden, sogenannte Agent Servers, inklusive Skalierung, Verfügbarkeit und Monitoring.

Fazit

LangSmith hilft dabei, Agentenentwicklung von Trial-and-Error in einen strukturierten Engineering-Workflow zu überführen. Mit Tracing, Evaluation, Prompt-Versionierung und menschlicher Prüfung können Teams Fehler diagnostizieren, Verbesserungen messen und verhindern, dass Regressionen bei Nutzern ankommen.

Der zentrale Arbeitsablauf ist der Agent Reliability Loop: jeden Lauf tracen, echte Fehler in Datensätze überführen, wiederholbare Experimente mit Evaluatoren und bei Bedarf menschlicher Bewertung durchführen und nur die besten Prompt- oder Modelländerungen über versionierte Releases freigeben.

Tracking und Monitoring helfen außerdem dabei, Drift, Tool-Fehler, Latenzänderungen und unerwartete Kostensteigerungen frühzeitig zu erkennen. Für Entwickler, die toolnutzende oder mehrstufige Agenten erstellen, bietet LangSmith einen strukturierten Weg, Reproduzierbarkeit und disziplinierte Iteration vom Prototyp bis zur Produktion zu verbessern.