Observability für LLM-Anwendungen: Beste Praktiken und praktische Beispiele

Der Aufstieg der LLM-Anwendungen und der Bedarf an fortschrittlicher Beobachtbarkeit

Große Sprachmodelle (LLMs) haben sich schnell von akademischen Studienobjekten zu grundlegenden Komponenten neuer Anwendungen in verschiedenen Sektoren entwickelt. Von intelligenten Chatbots und Inhaltsgeneratoren bis hin zu codierten Assistenten und Datenanalysetools definieren LLM-gestützte Anwendungen das Benutzererlebnis und die Geschäftsprozesse neu. Allerdings bringt diese transformative Kraft eine einzigartige Reihe von betrieblichen Herausforderungen mit sich. Im Gegensatz zu herkömmlicher Software führen LLM-Anwendungen eine neue Komplexitätsebene ein, die sich aus ihrer probabilistischen Natur, ihrer Abhängigkeit von externen Modellanbietern, komplexem Prompt-Engineering und der subjektiven Qualität ihrer Ergebnisse ergibt.

Traditionelle Beobachtungswerkzeuge, die für deterministische Systeme entwickelt wurden, sind oft unzureichend, um Probleme innerhalb von LLM-Anwendungen zu diagnostizieren. Ein einfacher 5xx-Fehler kann auf einen fehlgeschlagenen API-Aufruf hinweisen, sagt jedoch nichts darüber aus, ob das Modell halluziniert hat, ob der Prompt schlecht formuliert war oder ob die Benutzereingabe falsch interpretiert wurde. Diese Lücke erfordert einen spezialisierten Ansatz zur Beobachtbarkeit, der sich nicht nur auf die Gesundheit des Systems, sondern auch auf die Qualität, Relevanz und Sicherheit der LLM-Ergebnisse sowie auf das komplexe Zusammenspiel zwischen Benutzereingabe, Prompt, Modell und externen Tools konzentriert.

Was macht LLM-Beobachtbarkeit anders?

Die grundlegenden Unterschiede in der Architektur und im Verhalten von LLM-Anwendungen erfordern eine spezifische Beobachtungsstrategie:

• Probabilistische Natur: LLMs produzieren nicht immer die gleiche Ausgabe für die gleiche Eingabe. Diese Nicht-Deterministik erschwert das Debugging.
• Black-Box-Problem: Obwohl wir LLMs über Prompts und Feinabstimmung beeinflussen können, bleibt der interne Denkprozess weitgehend undurchsichtig.
• Empfindlichkeit gegenüber Prompt-Engineering: Kleine Änderungen in den Prompts können zu sehr unterschiedlichen Ergebnissen führen, was eine sorgfältige Nachverfolgung der Prompt-Versionen und deren Auswirkungen erfordert.
• Subjektive Qualität: Die ‘Richtigkeit’ oder ‘Nützlichkeit’ einer LLM-Ausgabe ist oft subjektiv und kontextabhängig, was die automatische Bewertung erschwert.
• Externe Abhängigkeiten: Viele LLM-Anwendungen basieren auf externen APIs (für Modelle, Vektordatenbanken, RAG-Quellen usw.), was externe Ausfall- und Latenzpunkte einführt.
• Halluzinationen und Vorurteile: LLMs können faktisch falsche Informationen generieren oder Vorurteile aufweisen, die erkannt und gemindert werden müssen.
• Token-Nutzung und Kosten: LLM-API-Aufrufe werden oft nach Token abgerechnet, was die Kostenüberwachung zu einem kritischen Aspekt der Beobachtbarkeit macht.
• Verkettung und Verhalten von Agenten: Komplexe LLM-Anwendungen beinhalten oft mehrere LLM-Aufrufe, die Nutzung von Tools und Entscheidungsagenten, was komplexe Ausführungspfade schafft.

Schlüsselstützen der LLM-Beobachtbarkeit

Eine effektive LLM-Beobachtbarkeit kann in mehrere Schlüsselstützen unterteilt werden, die jeweils einen spezifischen Aspekt der Gesundheit und Leistung der Anwendung ansprechen:

1. Verfolgung von Anfragen und Antworten

Wie bei traditionellen Mikrodiensten ist die Verfolgung einzelner Anfragen innerhalb Ihrer LLM-Anwendung grundlegend. Für LLMs muss diese Verfolgung jedoch einen signifikant reicheren Kontext erfassen.

Best Practices:

• Vollständige Payloads von Anfragen/Antworten erfassen: Protokollieren Sie die vollständige Benutzereingabe, den endgültigen Prompt, der an das LLM gesendet wurde, die rohe Antwort des LLM und die verarbeitete Ausgabe Ihrer Anwendung. Dies ist entscheidend für die Nachanalyse und das Debugging.
• Modelle und Prompt-Variablen verfolgen: Wenn Sie Prompt-Modelle verwenden, protokollieren Sie die ID/Version des Modells und die spezifischen Variablen, die für jede Anfrage injiziert wurden. Dies hilft zu verstehen, wie sich Änderungen im Prompt auf die Ergebnisse auswirken.
• Modell und Parameter protokollieren: Protokollieren Sie das spezifische verwendete LLM-Modell (z. B. GPT-4, Claude 3 Opus), die Temperatur, top_p, max_tokens, Stop-Sequenzen und alle anderen relevanten Parameter.
• Zeitstempel und Latenz: Standardpraxis, aber entscheidend für LLM-Aufrufe aufgrund potenzieller Durchsatzbeschränkungen und variabler Antwortzeiten. Verfolgen Sie die End-to-End-Latenz und die Latenz einzelner LLM-API-Aufrufe.
• Benutzer- und Sitzungs-ID: Verknüpfen Sie Anfragen mit spezifischen Benutzern oder Sitzungen, um die individuellen Benutzererfahrungen zu verstehen und Muster zu identifizieren.
• Nutzung von Tools: Wenn Ihre LLM-Anwendung Tools verwendet (z. B. Such-APIs, Datenbankabfragen, Code-Interpreter), protokollieren Sie, welche Tools aufgerufen wurden, deren Eingaben und Ausgaben. Dies ist besonders wichtig für agentenbasierte Systeme.

Praktisches Beispiel (Python/LangChain):

from langchain_core.tracers import ConsoleCallbackHandler
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# Eine einfache LLM-Kette
model = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_messages([
 ("system", "Sie sind ein hilfreicher KI-Assistent."),
 ("user", "{query}")
])
chain = prompt | model

# Um die grundlegende Verfolgung in der Konsole zu sehen (für lokale Entwicklung/Debugging)
response = chain.invoke({"query": "Was ist die Hauptstadt von Frankreich?"}, config={"callbacks": [ConsoleCallbackHandler()]})

# Für die Produktion integrieren Sie eine dedizierte Verfolgungsplattform (z. B. Langsmith, OpenTelemetry)
# Beispiel mit Langsmith (konzeptionell, erfordert Konfiguration):
# import os
# os.environ["LANGCHAIN_TRACING_V2"] = "true"
# os.environ["LANGCHAIN_API_KEY"] = "your_langsmith_api_key"
# os.environ["LANGCHAIN_PROJECT"] = "my_llm_app"
# response = chain.invoke({"query": "Geben Sie mir eine interessante Tatsache über Paris."})
# print(response.content)

2. Qualität und Bewertung der Ausgaben

Die Überwachung der subjektiven Qualität der LLM-Ausgaben ist vielleicht der schwierigste, aber entscheidende Aspekt der LLM-Beobachtbarkeit.

Best Practices:

• Feedback-Schleifen von Menschen: Implementieren Sie Mechanismen, die es Benutzern ermöglichen, die LLM-Antworten zu bewerten oder Feedback zu geben (z. B. Daumen hoch/runter, Freitext-Feedbackformulare). Dies ist von unschätzbarem Wert, um Regressionen und Verbesserungsbereiche zu identifizieren.
• Automatisierte Bewertungsmetriken: Verwenden Sie für spezifische Aufgaben automatisierte Metriken. Für Zusammenfassungen ROUGE-Scores; für faktische Abrufe exakte Übereinstimmung oder F1-Scores im Vergleich zu einer Referenzwahrheit. Für die Codegenerierung Erfolgsquote von Unit-Tests.
• LLM-als-Richter: Verwenden Sie ein leistungsfähigeres LLM, um die Ausgabe eines anderen LLM anhand vordefinierter Kriterien (z. B. Kohärenz, Relevanz, faktische Genauigkeit, Sicherheit) zu bewerten. Dies kann überraschend effektiv sein, um die Bewertung zu skalieren.
• Kategorisierung von Fehlern: Wenn ein Problem erkannt wird (menschlich oder automatisiert), kategorisieren Sie es (z. B. Halluzination, nicht relevant, unvollständig, unsicher, falsches Format, Stimmungsschwankung). Dies hilft, spezifische Schwächen zu identifizieren.
• Datensammlung für Referenzwahrheiten: Sammeln und kennzeichnen Sie kontinuierlich Beispiele für gute und schlechte Ausgaben, um einen soliden Datensatz für zukünftige Feinabstimmungen und automatisierte Bewertungen zu erstellen.

Praktisches Beispiel (LLM-als-Richter):

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

def evaluate_response(user_query, generated_response):
 evaluator_llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
 eval_prompt = ChatPromptTemplate.from_messages([
 ("system", "Sie sind ein KI-Assistent, der entwickelt wurde, um die Qualität der Antwort einer anderen KI zu bewerten. Bewerten Sie die Antwort auf einer Skala von 1 bis 5 für Relevanz, Genauigkeit und Vollständigkeit. Geben Sie eine kurze Erklärung für Ihre Bewertung an."),
 ("user", "Benutzeranfrage: {query}\nKI-Antwort: {response}\nBewertung:")
 ])
 evaluation_chain = eval_prompt | evaluator_llm
 return evaluation_chain.invoke({"query": user_query, "response": generated_response}).content

# Beispiel für die Verwendung
query = "Erzählen Sie mir die Geschichte des Internets."
response = "Das Internet wurde 1990 von Al Gore erfunden." # Falsche Antwort
eval_result = evaluate_response(query, response)
print(eval_result)
# Die erwartete Ausgabe könnte sein: "Relevanz: 5/5, Genauigkeit: 1/5, Vollständigkeit: 2/5. Erklärung: Obwohl relevant, enthält die Antwort eine signifikante faktische Ungenauigkeit bezüglich Al Gore, der das Internet erfunden hat." 

3. Kosten- und Latenzüberwachung

LLM-API-Aufrufe können teuer sein, und die Latenz hat direkte Auswirkungen auf die Benutzererfahrung. Die Überwachung dieser Metriken ist unverzichtbar.

Beste Praktiken:

• Verfolgung der Token-Nutzung: Überwachen Sie die Anzahl der Eingabe- und Ausgabetoken für jeden LLM-Aufruf. Dies ist der Hauptkostentreiber.
• Kostenschätzung: Übersetzen Sie die Token-Zählungen in geschätzte Kosten in Dollar basierend auf den Preisen des Anbieters. Richten Sie Warnungen für ungewöhnliche Kostenanstiege ein.
• API-Latenz: Verfolgen Sie die Zeit, die für jeden LLM-API-Aufruf benötigt wird. Unterscheiden Sie zwischen der Verarbeitungszeit Ihrer Anwendung und der Antwortzeit der externen API.
• Überwachung der Rate Limits: Achten Sie auf Rate-Limit-Fehler der API (z.B. 429 Zu viele Anfragen). Implementieren Sie Wiederholungsmechanismen mit exponentiellem Backoff und warnen Sie, wenn die Rate Limits häufig erreicht werden.
• Anbieterstatus: Überwachen Sie die Statusseiten Ihrer LLM-Anbieter (OpenAI, Anthropic usw.) und integrieren Sie deren Status-APIs, wenn verfügbar.

Praktisches Beispiel (Protokollierung von Kosten/Latenz):

import time
from langchain_openai import ChatOpenAI

def call_llm_and_log_metrics(model_name, prompt_text):
 start_time = time.time()
 llm = ChatOpenAI(model=model_name)
 try:
 response = llm.invoke(prompt_text)
 end_time = time.time()

 # Langchain liefert oft Informationen zur Token-Nutzung in den Metadaten der Antwort
 input_tokens = response.response_metadata.get('token_usage', {}).get('prompt_tokens', 0)
 output_tokens = response.response_metadata.get('token_usage', {}).get('completion_tokens', 0)
 total_tokens = input_tokens + output_tokens

 latency = (end_time - start_time) * 1000 # Millisekunden

 # Einfache Ausgabe zur Veranschaulichung; in der Produktion an Prometheus/Grafana, Datadog usw. senden
 print(f"LLM-Aufrufmetriken:")
 print(f" Modell: {model_name}")
 print(f" Latenz: {latency:.2f} ms")
 print(f" Eingabetokens: {input_tokens}")
 print(f" Ausgabetokens: {output_tokens}")
 print(f" Gesamttokens: {total_tokens}")
 # Kostenschätzung (Beispielpreisliste, bei Bedarf anpassen)
 # Für gpt-3.5-turbo-0125: Eingabe $0.50/M Tokens, Ausgabe $1.50/M Tokens
 input_cost = (input_tokens / 1_000_000) * 0.50
 output_cost = (output_tokens / 1_000_000) * 1.50
 total_cost = input_cost + output_cost
 print(f" Geschätzte Kosten: ${total_cost:.5f}")

 return response.content
 except Exception as e:
 print(f"Fehler beim LLM-Aufruf: {e}")
 # Fehler im Fehlerverfolgungssystem protokollieren
 return None

# Beispiel für die Verwendung
call_llm_and_log_metrics("gpt-3.5-turbo-0125", "Erklären Sie die Quantenverschränkung in einfachen Worten.")

4. Sicherheits- und Schutzüberwachung

Die Verhinderung der Generierung von schädlichem, voreingenommenem oder unangemessenem Inhalt ist eine wesentliche Sorge für LLM-Anwendungen.

Beste Praktiken:

• Eingangs-/Ausgangsmoderation: Verwenden Sie Inhaltsmoderations-APIs (z.B. den Moderations-Endpunkt von OpenAI, maßgeschneiderte Lösungen), um die Eingaben der Benutzer und die Ausgaben von LLM auf schädlichen Inhalt (Hassrede, Selbstverletzung, sexuelle Inhalte, Gewalt) zu scannen.
• Jailbreak-Erkennung: Überwachen Sie die Versuche von Benutzern, Sicherheitsfilter zu umgehen oder das LLM dazu zu bringen, unerwünschte Inhalte zu generieren (Jailbreaking).
• PII/PHI-Erkennung: Implementieren Sie Systeme zur Erkennung und Entfernung von PII (personenbezogene Daten) und PHI (geschützte Gesundheitsinformationen), um Datenlecks sensibler Informationen zu vermeiden.
• Bias-Erkennung: Obwohl komplex, versuchen Sie, statistisch signifikante Vorurteile in den Ausgaben von LLM im Laufe der Zeit zu erkennen (z.B. Geschlechterbias, Rassenbias im generierten Text).
• Überwachung von Befehlsinjektionen: Suchen Sie nach Mustern in den Benutzereingaben, die auf Versuche zur Befehlsinjektion hindeuten.

Praktisches Beispiel (OpenAI-Moderation):

from openai import OpenAI

client = OpenAI()

def moderate_text(text):
 try:
 response = client.moderations.create(input=text)
 result = response.results[0]
 if result.flagged:
 print(f"Gemeldeter Inhalt: {result.categories}")
 return True, result.categories
 else:
 print("Der Inhalt ist sicher.")
 return False, {}
 except Exception as e:
 print(f"Fehler bei der Moderations-API: {e}")
 return False, {"error": str(e)}

# Beispiel für die Verwendung
is_flagged, categories = moderate_text("Ich hasse alle und möchte ihnen schaden.")
# is_flagged, categories = moderate_text("Der schnelle braune Fuchs springt über den faulen Hund.")

if is_flagged:
 # Maßnahmen ergreifen: Antwort blockieren, eskalieren usw.
 pass

5. Daten- und Kontextüberwachung (für RAG/Agenten)

Für Anwendungen, die retrieval-augmented generation (RAG) oder komplexe Agenten verwenden, ist die Überwachung der Datenquellen und des Kontexts entscheidend.

Beste Praktiken:

• Wiederherstellungsleistung: Verfolgen Sie die Latenz und die Erfolgsquote Ihrer Anfragen an die Vektordatenbank oder externe API, um den Kontext abzurufen.
• Qualität der abgerufenen Dokumente: Protokollieren Sie den Inhalt der abgerufenen Dokumente für jede Anfrage. Bewerten Sie deren Relevanz in Bezug auf die Benutzerfrage. Dies kann durch menschliche Überprüfung oder LLM als Richter erfolgen.
• Nutzung des Kontextfensters: Überwachen Sie, wie viel des Kontextfensters des LLM von den abgerufenen Dokumenten und der Eingabe verwendet wird. Eine übermäßige Füllung kann zu einer Trunkierung oder einer Verschlechterung der Leistung führen.
• Aktualität der Daten: Stellen Sie für RAG-Systeme sicher, dass die zugrunde liegenden Datenquellen (z.B. Vektordatenbank, Wissensdatenbank) aktuell sind und dass Ihre Indexierungs-/Embedding-Pipelines ordnungsgemäß funktionieren.
• Genauigkeit der Werkzeugauswahl: Für Agenten überwachen Sie, ob die richtigen Werkzeuge für gegebene Benutzeranfragen ausgewählt werden. Protokollieren Sie den Denkprozess des Agenten.

Praktisches Beispiel (Protokollierung des RAG-Kontexts):

# Angenommen, Sie haben ein RAG-Setup (zum Beispiel das RAG-Beispiel von Langchain)
# Dies ist konzeptionell, die spezifische Implementierung hängt von Ihrem RAG-Setup ab

def query_rag_and_log_context(retriever, llm_chain, user_query):
 # Simulieren der Abfrage
 retrieved_docs = retriever.invoke(user_query)
 
 # Protokollieren der abgerufenen Dokumente zur Beobachtbarkeit
 print(f"\n--- Abgerufene Dokumente für die Anfrage: '{user_query}' ---")
 for i, doc in enumerate(retrieved_docs):
 print(f"Doc {i+1} (Quelle: {doc.metadata.get('source', 'N/A')}):")
 print(f" Inhalt Ausschnitt: {doc.page_content[:200]}...")
 print("---------------------------------------------------")

 # Dokumente an die LLM-Kette mit der Anfrage übergeben
 response = llm_chain.invoke({"context": retrieved_docs, "question": user_query})
 
 return response

# Platzhalter für einen Retriever und eine LLM-Kette
class MockRetriever:
 def invoke(self, query):
 if "internet" in query:
 return [
 {'page_content': 'Das ARPANET, finanziert von der DARPA, war der Vorläufer des Internets. Seine Entwicklung begann Ende der 1960er Jahre.', 'metadata': {'source': 'Wikipedia'}},
 {'page_content': 'Vinton Cerf und Robert Kahn entwickelten die TCP/IP-Protokolle, die zum Standard für die Kommunikation im Internet wurden.', 'metadata': {'source': 'RFC 793'}}
 ]
 return []

class MockLLMChain:
 def invoke(self, inputs):
 context_summary = " ".join([d['page_content'] for d in inputs['context']])
 return f"Basierend auf dem bereitgestellten Kontext, hier ist eine Antwort auf \"{inputs['question']}\": {context_summary[:150]}..."

# Beispiel für die Verwendung
my_retriever = MockRetriever()
my_llm_chain = MockLLMChain()

query_rag_and_log_context(my_retriever, my_llm_chain, "Wer hat die ersten Protokolle des Internets entwickelt?")

Die richtigen Werkzeuge für die LLM-Beobachtbarkeit auswählen

Eine umfassende LLM-Beobachtbarkeitsstrategie umfasst oft eine Kombination von Werkzeugen:

• Spezialisierte LLM-Beobachtbarkeitsplattformen: Werkzeuge wie Langsmith, Helicone, Athina.ai, Arize AI und Phoenix sind speziell für LLM-Anwendungen konzipiert und bieten Funktionen wie Versionskontrolle von Eingabeaufforderungen, Visualisierung von Spuren, Integration von Benutzerfeedback und automatisierte Bewertung.
• Traditionelle APM/Logging-Plattformen: Datadog, New Relic, Splunk, Elastic Stack (ELK) sind nach wie vor entscheidend für die Überwachung der Infrastruktur, Anwendungsprotokolle und die Aggregation von Metriken. Integrieren Sie LLM-spezifische Metriken (Token-Nutzung, Latenz) in diese.
• Vektordatenbanken: Entscheidend für RAG, aber auch um die Embeddings von Eingabeaufforderungen und Antworten für eine Analyse problematischer Ausgaben basierend auf Ähnlichkeitssuche zu speichern.
• Experimentiervalidierungstools: MLflow, Weights & Biases können angepasst werden, um die Experimente der Eingabeaufforderungsingenieure und deren zugehörige Metriken zu verfolgen.
• Benutzerdefinierte Dashboards & Skripte: Für spezifische Bedürfnisse können benutzerdefinierte Python-Skripte in Kombination mit Dashboard-Tools wie Grafana gezielte Einblicke bieten.

Fazit

Beobachtbarkeit für LLM-Anwendungen ist keine Option, sondern eine grundlegende Anforderung, um solide, zuverlässige und verantwortungsvolle Systeme zu bauen. Die einzigartigen Eigenschaften von LLM erfordern einen Übergang von traditioneller Überwachung zu einem nuancierteren Ansatz, der das Nachverfolgen von Eingaben/Ausgaben, die subjektive Qualitätsbewertung, Kostenmanagement, Sicherheitsüberprüfungen und Kontextbewusstsein umfasst. Durch die Umsetzung der oben beschriebenen Best Practices und die Verwendung der richtigen Werkzeuge können Entwickler und MLOps-Teams die tiefen Einblicke gewinnen, die notwendig sind, um ihre LLM-gestützten Anwendungen zu verstehen, zu debuggen und kontinuierlich zu verbessern, um sicherzustellen, dass sie konstanten Wert liefern und das Vertrauen der Benutzer aufrechterhalten.

🕒 Published: March 29, 2026