Observierbarkeit für LLM-Apps: 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 Kuriositäten zu grundlegenden Komponenten neuer Anwendungen in verschiedenen Branchen entwickelt. Von intelligenten Chatbots und Inhaltsgeneratoren bis hin zu Programmierassistenten und Datenanalysetools, LLM-gestützte Anwendungen ändern die Benutzererfahrung und Geschäftsprozesse neu. Diese transformative Kraft bringt jedoch eine einzigartige Reihe operationaler Herausforderungen mit sich. Im Gegensatz zu traditioneller Software bringen LLM-Anwendungen eine neue Komplexität mit sich, die aus ihrer probabilistischen Natur, der Abhängigkeit von externen Modellanbietern, komplexem Prompt Engineering und der subjektiven Qualität ihrer Ausgaben resultiert.

Traditionelle Beobachtbarkeitstools, die für deterministische Systeme konzipiert wurden, stoßen oft an ihre Grenzen, wenn es darum geht, Probleme innerhalb von LLM-Anwendungen zu diagnostizieren. Ein einfacher 5xx-Fehler könnte auf einen fehlerhaften API-Aufruf hinweisen, gibt jedoch nicht an, ob das Modell halluziniert hat, ob der Prompt schlecht formuliert war oder ob die Eingabe des Benutzers falsch interpretiert wurde. Diese Lücke erfordert einen spezialisierten Ansatz zur Beobachtbarkeit, der sich nicht nur auf die Systemgesundheit konzentriert, sondern auch auf die Qualität, Relevanz und Sicherheit der Ausgaben des LLM sowie auf das komplizierte Zusammenspiel zwischen Benutzereingabe, Prompt, Modell und externen Tools.

Was macht LLM-Beobachtbarkeit anders?

Die grundlegenden Unterschiede in der Architektur und dem Verhalten von LLM-Anwendungen treiben den Bedarf an einer eigenen Beobachtbarkeitsstrategie voran:

• Probabilistische Natur: LLMs erzeugen nicht immer die gleiche Ausgabe für die gleiche Eingabe. Diese Nicht-Deterministik macht das Debugging schwierig.
• Black-Box-Problem: Obwohl wir LLMs über Prompts und Feinabstimmungen beeinflussen können, bleibt der interne Denkprozess weitgehend undurchsichtig.
• Empfindlichkeit des Prompt-Engineerings: Kleine Änderungen an Prompts können zu erheblich unterschiedlichen Ausgaben führen, was eine sorgfältige Nachverfolgung der Prompt-Versionen und deren Auswirkungen erfordert.
• Subjektive Qualität: Die ‘Richtigkeit’ oder ‘Nützlichkeit’ einer Ausgabe des LLM ist oft subjektiv und kontextabhängig, was eine automatisierte Bewertung erschwert.
• Externe Abhängigkeiten: Viele LLM-Anwendungen sind auf externe APIs (für Modelle, Vektordatenbanken, RAG-Quellen usw.) angewiesen, was externe Fehlerquellen und Latenzzeiten einführt.
• Halluzinationen & Vorurteile: LLMs können faktisch falsche Informationen generieren oder Vorurteile aufweisen, die erkannt und gemildert werden müssen.
• Token-Nutzung & Kosten: LLM-API-Aufrufe werden oft pro Token abgerechnet, was die Kostenüberwachung zu einem kritischen Aspekt der Beobachtbarkeit macht.
• Verkettung & Agentenverhalten: Komplexe LLM-Anwendungen beinhalten oft mehrere LLM-Aufrufe, Tool-Nutzung und Entscheidungsagenten, was aufwendige Ausführungspfade schafft.

Wesentliche Säulen der LLM-Beobachtbarkeit

Eine effektive LLM-Beobachtbarkeit lässt sich in mehrere Schlüssel-Säulen unterteilen, die jeweils einen bestimmten Aspekt der Gesundheit und Leistung der Anwendung ansprechen:

1. Anforderungs- & Antwortverfolgung

So wie bei traditionellen Mikrodiensten ist die Verfolgung einzelner Anforderungen in Ihrer LLM-Anwendung grundlegend. Für LLMs muss diese Verfolgung jedoch erheblich mehr Kontext erfassen.

Best Practices:

• Vollständige Anforderungs-/Antwort-Payloads erfassen: Protokollieren Sie die gesamte 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 nachträgliche Analyse und das Debugging.
• Prompt-Vorlagen & Variablen nachverfolgen: Wenn Sie Prompt-Vorlagen verwenden, protokollieren Sie die Vorlage-ID/version und die spezifischen Variablen, die für jede Anforderung eingefügt wurden. Dies hilft, zu verstehen, wie Änderungen am Prompt die Ergebnisse beeinflussen.
• Modell & Parameter aufzeichnen: Protokollieren Sie das spezifische verwendete LLM-Modell (z.B. GPT-4, Claude 3 Opus), Temperatur, top_p, max_tokens, Stopsequenzen und alle anderen relevanten Parameter.
• Zeitstempel & Latenz: Standardpraxis, aber entscheidend für LLM-Aufrufe aufgrund möglicher Ratenbeschränkungen und variierender Antwortzeiten. Verfolgen Sie die End-to-End-Latenz und die individuelle Latenz der LLM-API-Aufrufe.
• Benutzer- & Sitzungs-IDs: Verknüpfen Sie Anforderungen mit bestimmten Benutzern oder Sitzungen, um individuelles Benutzererlebnis zu verstehen und Muster zu erkennen.
• Tool-Nutzung: Wenn Ihre LLM-Anwendung Tools verwendet (z.B. Such-API, Datenbankabfrage, 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", "Du bist ein hilfreicher KI-Assistent."),
 ("user", "{query}")
])
chain = prompt | model

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

# Für die Produktion mit einer dedizierten Verfolgungsplattform integrieren (z.B. Langsmith, OpenTelemetry)
# Beispiel mit Langsmith (konzeptionell, erfordert Einrichtung):
# 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": "Erzähl mir eine interessante Tatsache über Paris."})
# print(response.content)

2. Ausgabequalität & Bewertung

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

Best Practices:

• Feedbackschleifen von Nutzern: Implementieren Sie Mechanismen, damit Benutzer die Antworten des LLM bewerten oder Feedback geben können (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-Werte; für faktische Informationen, exakte Übereinstimmungen oder F1-Werte im Vergleich zur Grundwahrheit. Für die Codegenerierung, die Durchfallquoten von Unit-Tests.
• LLM als Richter: Verwenden Sie ein leistungsstärkeres LLM zur Bewertung der Ausgabe eines anderen LLM basierend auf vordefinierten Kriterien (z.B. Kohärenz, Relevanz, faktische Genauigkeit, Sicherheit). Dies kann überraschend effektiv sein, um die Bewertung zu skalieren.
• Kategorisierung von Fehlern: Wenn ein Problem erkannt wird (menschen- oder automatisiert), kategorisieren Sie es (z.B. Halluzination, irrelevant, unvollständig, unsicher, schlechtes Format, Stimmungsmismatch). Dies hilft, spezifische Schwächen zu identifizieren.
• Sammlung von Basisdaten: Sammeln und kennzeichnen Sie kontinuierlich Beispiele für gute und schlechte Ausgaben, um einen soliden Datensatz für zukünftige Feinabstimmungen des Modells und automatisierte Bewertungen aufzubauen.

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", "Du bist ein KI-Assistent, der dafür konzipiert ist, die Qualität der Antwort einer anderen KI zu bewerten. Bewerte die Antwort auf einer Skala von 1 bis 5 hinsichtlich Relevanz, Genauigkeit und Vollständigkeit. Gib eine kurze Erklärung für deine Bewertung."),
 ("user", "Benutzeranfrage: {query}\nKI-Antwort: {response}\nBewertung:")
 ])
 evaluation_chain = eval_prompt | evaluator_llm
 return evaluation_chain.invoke({"query": user_query, "response": generated_response}).content

# Beispielgebrauch
query = "Erzähl mir über die Geschichte des Internets."
response = "Das Internet wurde von Al Gore im Jahr 1990 erfunden." # Falsche Antwort
eval_result = evaluate_response(query, response)
print(eval_result)
# Erwartete Ausgabe könnte sein: "Relevanz: 5/5, Genauigkeit: 1/5, Vollständigkeit: 2/5. Erklärung: Obwohl relevant, enthält die Antwort eine erhebliche faktische Ungenauigkeit über Al Gore, der das Internet erfunden hat." 

3. Kosten- & Latenzüberwachung

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

Best Practices:

• Token-Nutzungsverfolgung: Überwachen Sie die Anzahl der Eingabe- und Ausgabe-Token für jeden LLM-Aufruf. Dies ist der Haupttreiber der Kosten.
• Kostenschätzung: Übersetzen Sie die Token-Anzahlen in geschätzte Dollar-Kosten basierend auf den Preisen des Anbieters. Setzen Sie Warnungen für ungewöhnliche Kostenanstiege.
• API-Latenz: Verfolgen Sie die Zeitdauer für jeden LLM-API-Aufruf. Unterscheiden Sie zwischen der Verarbeitungszeit Ihrer Anwendung und der Antwortzeit der externen API.
• Überwachung der Ratenbegrenzung: Behalten Sie API-Fehler aufgrund der Ratenbegrenzung im Auge (z.B. 429 Zu viele Anfragen). Implementieren Sie Wiederholungsmechanismen mit exponentiellem Backoff und benachrichtigen Sie, wenn die Ratenlimits häufig erreicht werden.
• Anbieter-Gesundheit: Überwachen Sie die Statusseiten Ihrer LLM-Anbieter (OpenAI, Anthropic usw.) und integrieren Sie deren Status-APIs, wenn verfügbar.

Praktisches Beispiel (Kosten-/Latenzprotokollierung):

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 gibt oft den Tokenverbrauch in den Antwortmetadaten an
 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 zum Veranschaulichen; in der Produktion an Prometheus/Grafana, Datadog usw. senden
 print(f"LLM Call Metrics:")
 print(f" Modell: {model_name}")
 print(f" Latenz: {latency:.2f} ms")
 print(f" Eingabe-Token: {input_tokens}")
 print(f" Ausgabe-Token: {output_tokens}")
 print(f" Gesamt-Token: {total_tokens}")
 # Kostenschätzung (Beispielpreise, nach 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"LLM Call Error: {e}")
 # Fehler in das Fehlerverfolgungssystem protokollieren
 return None

# Beispielverwendung
call_llm_and_log_metrics("gpt-3.5-turbo-0125", "Erkläre Quantenteleportation in einfachen Worten.")

4. Sicherheits- & Sicherheitsüberwachung

Die Verhinderung der Generierung von schädlichem, voreingenommenem oder unangemessenem Inhalt ist ein kritisches Anliegen für LLM-Anwendungen.

Beste Praktiken:

• Eingabe-/Ausgabemoderation: Verwenden Sie APIs zur Inhaltsmoderation (z. B. OpenAI’s Moderationsendpunkt, maßgeschneiderte Lösungen), um sowohl Benutzeranfragen als auch LLM-Antworten auf schädliche Inhalte (Hassrede, Selbstverletzung, sexuelle Inhalte, Gewalt) zu scannen.
• Jailbreak-Erkennung: Überwachen Sie Versuche von Benutzern, Sicherheitsfilter zu umgehen oder das LLM zu veranlassen, unerwünschte Inhalte zu erzeugen (Jailbreaking).
• PII/PHI-Erkennung: Implementieren Sie PII (personenbezogene Daten) und PHI (geschützte Gesundheitsinformationen) Erkennung und Anonymisierung, um die Offenlegung sensibler Daten zu verhindern.
• Voreingenommenheitserkennung: Versuchen Sie, statistisch signifikante Voreingenommenheiten in den LLM-Antworten im Laufe der Zeit zu erkennen (z. B. Geschlecht, rassistische Voreingenommenheit im generierten Text).
• Überwachung von Prompt-Injektionen: Achten Sie auf Muster in den Benutzereingaben, die auf Versuche zur Prompt-Injektion 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"Inhalt markiert: {result.categories}")
 return True, result.categories
 else:
 print("Inhalt ist sicher.")
 return False, {}
 except Exception as e:
 print(f"Moderations-API-Fehler: {e}")
 return False, {"error": str(e)}

# Beispielverwendung
is_flagged, categories = moderate_text("Ich hasse alle und will ihnen wehtun.")
# 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- & 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 von entscheidender Bedeutung.

Beste Praktiken:

• Abfrage-Leistung: Verfolgen Sie die Latenz und Erfolgsquote Ihrer Abfragen an die Vektordatenbank oder externe API-Aufrufe zur Kontextretrieval.
• Qualität der abgerufenen Dokumente: Protokollieren Sie den Inhalt der für jede Abfrage abgerufenen Dokumente. Bewerten Sie deren Relevanz zur Frage des Nutzers. Dies kann durch menschliche Überprüfung oder LLM als Richter erfolgen.
• Ausnutzung des Kontextfensters: Überwachen Sie, wie viel vom Kontextfenster des LLM durch abgerufene Dokumente und den Prompt genutzt wird. Eine Überfüllung kann zu Truncation oder verringerter Leistung führen.
• Datenaktualität: Stellen Sie für RAG-Systeme sicher, dass die zugrunde liegenden Datenquellen (z. B. Vektordatenbank, Wissensdatenbank) aktuell sind und dass Ihre Indexierungs-/Einbettungspipelines korrekt funktionieren.
• Genauigkeit der Werkzeugauswahl: Überwachen Sie für Agenten, ob die richtigen Werkzeuge für gegebene Benutzeranfragen ausgewählt werden. Protokollieren Sie den Entscheidungsprozess des Agenten.

Praktisches Beispiel (RAG Kontextprotokollierung):

# Angenommen, Sie haben einen RAG-Chain-Setup (z. B. Langchains RAG-Beispiel)
# Dies ist konzeptionell, die spezifische Implementierung hängt von Ihrem RAG-Setup ab

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

 # Dokumente zusammen mit der Abfrage an die LLM-Chain weitergeben
 response = llm_chain.invoke({"context": retrieved_docs, "question": user_query})
 
 return response

# Platzhalter für einen Retriever und eine LLM-Chain
class MockRetriever:
 def invoke(self, query):
 if "internet" in query:
 return [
 {'page_content': 'Das ARPANET, finanziert von 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]}..."

# Beispielverwendung
my_retriever = MockRetriever()
my_llm_chain = MockLLMChain()

query_rag_and_log_context(my_retriever, my_llm_chain, "Wer entwickelte die frühen Internetprotokolle?")

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

Eine gründliche Strategie zur LLM-Beobachtbarkeit umfasst oft eine Kombination von Werkzeugen:

• Speziell entwickelte LLM-Beobachtungsplattformen: Werkzeuge wie Langsmith, Helicone, Athina.ai, Arize AI und Phoenix sind speziell für LLM-Anwendungen konzipiert und bieten Funktionen wie Prompt-Versionierung, Visualisierung von Nachverfolgungen, Integration menschlichen Feedbacks und automatisierte Bewertung.
• Traditionelle APM-/Protokollierungsplattformen: Datadog, New Relic, Splunk, Elastic Stack (ELK) sind nach wie vor wichtig für die Infrastrukturüberwachung, Anwendungsprotokolle und das Aggregieren von Metriken. Integrieren Sie LLM-spezifische Metriken (Tokenverbrauch, Latenz) in diese.
• Vektordatenbanken: Entscheidend für RAG, aber auch für die Speicherung von Einbettungen von Prompts und Antworten für analysen basierte auf Ähnlichkeit bei problematischen Ergebnissen.
• Werkzeuge zur Verfolgung von Experimenten: MLflow, Weights & Biases können angepasst werden, um Experimente zur Prompt-Engineering und deren zugehörigen Metriken zu verfolgen.
• Benutzerdefinierte Dashboards & Skripte: Für spezifische Anforderungen können benutzerdefinierte Python-Skripte in Verbindung mit Dashboard-Tools wie Grafana gezielte Einblicke bieten.

Fazit

Die Beobachtbarkeit für LLM-Anwendungen ist kein ‘nettes Zubrot’, sondern eine grundlegende Voraussetzung für den Aufbau solider, zuverlässiger und verantwortungsvoller Systeme. Die einzigartigen Eigenschaften von LLMs erfordern einen Wandel von der traditionellen Überwachung zu einem differenzierteren Ansatz, der Eingangs-/Ausgangsnachverfolgung, subjektive Qualitätsbewertung, Kostenmanagement, Sicherheitsüberprüfungen und Kontextbewusstsein umfasst. Durch die Implementierung der oben skizzierten besten Praktiken und den Einsatz geeigneter Werkzeuge können Entwickler und MLOps-Teams tiefgreifende Einblicke gewinnen, die notwendig sind, um ihre von LLM unterstützten Anwendungen zu verstehen, zu debuggen und kontinuierlich zu verbessern, sodass sie konsistenten Wert liefern und das Vertrauen der Nutzer aufrechterhalten.

🕒 Published: March 28, 2026