In dem sich schnell entwickelnden Bereich der LLM-Anwendungen ist eine robuste Beobachtbarkeit entscheidend, um eine optimale Leistung und Zuverlässigkeit zu gewährleisten. Aufgrund ihrer Komplexität und Skalierung ist es jedoch nicht einfach, Laufzeitereignisse in LLM-Anwendungen zu verfolgen und zu speichern. Um diese Herausforderungen zu bewältigen, haben wir MyScale Telemetry (opens new window) veröffentlicht, das sich nahtlos in LangChain Callbacks (opens new window) integriert.
Dieser Callback erfasst nahtlos Trace-Daten aus auf LangChain basierenden LLM-Anwendungen und speichert sie in der MyScaleDB (opens new window), um Probleme zu diagnostizieren, die Leistung zu optimieren und das Verhalten des Modells zu verstehen. MyScale Telemetry bietet ähnliche Funktionen wie LangSmith (opens new window), einschließlich Verfolgung und Auswertung von LLM-Anwendungen, und dient als Open-Source-Alternative zu LangSmith. Zusätzlich kann MyScale Telemetry direkt mit ClickHouse verwendet werden, da MyScaleDB ClickHouse-kompatibel ist.
In den folgenden Abschnitten werden die Funktionen und die Verwendung des MyScale Telemetry im Detail erläutert.
# Wie MyScale Telemetry funktioniert
Die Integration von MyScale Telemetry in LangChain ist unkompliziert. Der Callback-Handler erstellt automatisch eine verschachtelte Spur für jedes Laufzeitereignis Ihrer LangChain-Anwendungen. Diese Laufzeitereignisse umfassen:
on_chain_starton_chain_endon_llm_starton_llm_endon_chat_model_starton_retriever_starton_retriever_endon_tool_starton_tool_endon_tool_erroron_chain_erroron_retriever_erroron_llm_error
Die erfassten Laufzeitereignisdaten werden dann ähnlich wie OpenTelemetry Trace-Daten (opens new window) in Trace-Daten organisiert und in der MyScale-Datenbank in einer dedizierten Trace-Daten-Tabelle gespeichert. Die Tabellenstruktur sieht wie folgt aus:
CREATE TABLE your_database_name.your_table_name
(
`TraceId` String CODEC(ZSTD(1)),
`SpanId` String CODEC(ZSTD(1)),
`ParentSpanId` String CODEC(ZSTD(1)),
`StartTime` DateTime64(9) CODEC(Delta(8), ZSTD(1)),
`EndTime` DateTime64(9) CODEC(Delta(8), ZSTD(1)),
`Duration` Int64 CODEC(ZSTD(1)),
`SpanName` LowCardinality(String) CODEC(ZSTD(1)),
`SpanKind` LowCardinality(String) CODEC(ZSTD(1)),
`ServiceName` LowCardinality(String) CODEC(ZSTD(1)),
`SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)),
`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)),
`StatusCode` LowCardinality(String) CODEC(ZSTD(1)),
`StatusMessage` String CODEC(ZSTD(1)),
INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1,
INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_span_attr_key mapKeys(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_span_attr_value mapValues(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_duration Duration TYPE minmax GRANULARITY 1
)
ENGINE = MergeTree()
PARTITION BY toDate(StartTime)
ORDER BY (SpanName, toUnixTimestamp(StartTime), TraceId);
Benutzer können diese Trace-Daten analysieren, um ihre LLM-Anwendungen effektiv zu debuggen und zu verbessern. Der MyScale Telemetry gewährleistet eine minimale Auswirkung auf die Leistung und bietet gleichzeitig umfangreiche Einblicke in die Beobachtbarkeit, was Entwicklern ermöglicht, tiefere Einblicke in das Verhalten und die Leistung ihrer Anwendungen zu gewinnen.
# Beispielhafte Verwendung
Wir werden Ihnen anhand eines vollständigen Beispiels zeigen, wie Sie MyScale Telemetry effektiv nutzen können. Dieses Beispiel umfasst die Einrichtung von MyScaleDB (opens new window) und Grafana Dashboard (opens new window) zur Speicherung und Überwachung von Trace-Daten und die Verwendung von Ragas (opens new window) zur Auswertung.
Befolgen Sie diese Schritte, um es effektiv einzurichten und zu verwenden:
# Einrichten von MyScaleDB und Grafana
Richten Sie zunächst eine MyScaleDB- und Grafana-Instanz mit Docker Compose ein. Die Datei docker-compose.yml finden Sie hier (opens new window). Führen Sie den folgenden Befehl aus, um die Container zu starten:
docker-compose up -d
# Erforderliche Pakete installieren
Installieren Sie anschließend das MyScale Telemetry-Paket zusammen mit LangChain und der LangChain OpenAI-Integration und Ragas mit pip:
pip install myscale-telemetry langchain_openai ragas
# Einfache Kette erstellen
Erstellen Sie dann eine einfache LangChain-Kette und integrieren Sie sie mit MyScaleCallbackHandler zur Erfassung von Trace-Daten.
import os
from myscale_telemetry.handler import MyScaleCallbackHandler
from operator import itemgetter
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import MyScale
from langchain_community.vectorstores.myscale import MyScaleSettings
from langchain_core.runnables import RunnableConfig
# Umgebungsvariablen für OpenAI und MyScale Cloud/MyScaleDB einrichten:
os.environ["OPENAI_API_KEY"] = "IHR_OPENAI_SCHLÜSSEL"
os.environ["MYSCALE_HOST"] = "YOUR_MYSCALE_HOST"
os.environ["MYSCALE_PORT"] = "YOUR_MYSCALE_HOST"
os.environ["MYSCALE_USERNAME"] = "YOUR_MYSCALE_USERNAME"
os.environ["MYSCALE_PASSWORD"] = "YOUR_MYSCALE_PASSWORD"
# Vektor-Speicher und -Retriever mit MyScale und OpenAI-Embeddings erstellen:
texts = [
"Harrison hat bei Kensho gearbeitet.",
"Alice ist Softwareingenieurin.",
"Bob geht gerne am Wochenende wandern.",
"Claire studiert Data Science.",
"David arbeitet bei einem Tech-Startup.",
"Eva spielt gerne Klavier.",
"Frank ist Grafikdesigner.",
"Grace ist KI-Forscherin.",
"Henry ist freiberuflicher Schriftsteller.",
"Isabel lernt maschinelles Lernen."
]
myscale_settings = MyScaleSettings()
myscale_settings.index_type = 'SCANN'
vectorstore = MyScale.from_texts(texts, embedding=OpenAIEmbeddings(), config=myscale_settings)
retriever = vectorstore.as_retriever()
# LLM und Prompt-Vorlage einrichten:
model = ChatOpenAI()
template = """Beantworten Sie die Frage basierend nur auf dem folgenden Kontext:
{context}
Frage: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
# Kette erstellen
chain = (
{
"context": itemgetter("question") | retriever,
"question": itemgetter("question"),
}
| prompt
| model
| StrOutputParser()
)
# MyScaleCallbackHandler integrieren, um Trace-Daten während der Kettenausführung zu erfassen:
chain.invoke({"question": "Wo hat Harrison gearbeitet?"}, config=RunnableConfig(
callbacks=[
MyScaleCallbackHandler()
]
))
Nach erfolgreicher Ausführung finden Sie die entsprechenden Trace-Daten in der Tabelle otel.otel_traces in MyScaleDB.
Weitere Informationen zur Anpassung von MyScaleCallbackHandler finden Sie in der Dokumentation: MyScale Telemetry benutzerdefinierte Parameter (opens new window).
# Beobachtbarkeit
Um die mit dem MyScale Telemetry erfassten Trace-Daten aus der Laufzeit Ihrer LLM-Anwendung einfach und übersichtlich anzuzeigen, bieten wir auch ein Grafana Trace Dashboard (opens new window) an. Das Dashboard ermöglicht es Benutzern, den Status der LLM-Anwendung zu überwachen, ähnlich wie bei LangSmith, was das Debuggen und die Verbesserung der Leistung erleichtert.
Das Docker Compose-Beispiel startet eine Grafana-Instanz unter http://localhost:3000 (opens new window). Verwenden Sie den Benutzernamen admin und das Passwort admin, um sich anzumelden.
# Einrichten des Trace Dashboards
Nachdem Sie Trace-Daten mit dem MyScale Telemetry Handler erfasst haben, befolgen Sie diese Schritte, um das MyScale Trace Dashboard einzurichten:
Installieren Sie das Grafana-clickhouse-datasource Plugin (opens new window):
Fügen Sie eine neue ClickHouse-Datenquelle in Grafana hinzu:
In den Einstellungen der Grafana-Datenquelle fügen Sie eine neue ClickHouse-Datenquelle hinzu. Die Serveradresse, der Serverport, der Benutzername und das Passwort sollten mit dem Host, dem Port, dem Benutzernamen und dem Passwort der verwendeten MyScaleDB übereinstimmen. Für das bereitgestellte Docker Compose-Beispiel sind diese Werte:
- Address:
myscaledb - Port:
9000 - Username:
default - Password:
default
- Address:
Importieren Sie das MyScale Trace Dashboard:
Sobald die ClickHouse-Datenquelle hinzugefügt wurde, können Sie das MyScale Trace Dashboard (opens new window) importieren.
Konfigurieren Sie das Dashboard:
Nach dem Import wählen Sie den MyScale-Cluster (Name der ClickHouse-Datenquelle), den Datenbanknamen, den Tabellennamen und die TraceID der zu analysierenden Spur aus. Das Dashboard zeigt dann die Traces-Tabelle und das Trace-Details-Panel der ausgewählten Spur an.
# Erkenntnisse aus dem MyScale Trace Dashboard
Das MyScale Trace Dashboard bietet umfassende Einblicke in das Laufzeitverhalten Ihrer LLM-Anwendungen, ähnlich wie bei LangSmith. Es zeigt wichtige Informationen an, die bei der Fehlersuche, Optimierung und dem Verständnis der Leistung Ihrer Anwendungen helfen.
# Ausführungszeiten der Funktionen
Das Dashboard zeigt die Ausführungszeit für jede Funktion in Ihrer LangChain-Anwendung an, um Leistungsengpässe zu identifizieren.
# Eingabe und Ausgabe
Das Dashboard bietet eine detaillierte Ansicht der Gesamteingabe und -ausgabe Ihrer Kette, um den Datenfluss durch Ihre Anwendung nachverfolgen zu können.
# DB-Retriever-Rückgaben
Es zeigt die spezifischen Daten, die vom Datenbank-Retriever zurückgegeben werden, um zu überprüfen, ob die richtigen Daten abgerufen und in Ihren Prompts verwendet werden.
# Prompt-Informationen
Sie können die genauen Prompts sehen, die generiert und an das LLM gesendet werden, was wichtig ist, um die Korrektheit und Relevanz der gestellten Fragen sicherzustellen.
# ChatOpenAI-Ausgaben
Die Ausgaben, die von ChatOpenAI generiert werden, werden ebenfalls angezeigt und geben Aufschluss darüber, wie das LLM auf die Prompts reagiert.
Darüber hinaus werden Details zur Token-Nutzung angezeigt, um die Kosten für API-Aufrufe an das LLM zu überwachen und zu optimieren.
# Auswertung mit Ragas
Die in MyScaleDB gespeicherten Span-Daten können verwendet werden, um ihre RAG-Pipeline mit Ragas (opens new window), einem beliebten Open-Source-RAG-Evaluierungsframework, zu analysieren und auszuwerten.
Der folgende Python-Code veranschaulicht, wie Sie mit RAGAS eine Spur bewerten, indem Sie die abgerufenen Kontexte und die generierte Antwort auswerten:
import os
from datasets import Dataset
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_utilization
from clickhouse_connect import get_client
def score_with_ragas(query, chunks, answer):
test_dataset = Dataset.from_dict({"question": [query], "contexts": [chunks], "answer": [answer]})
result = evaluate(test_dataset, metrics=[faithfulness, answer_relevancy, context_utilization])
return result
def evaluate_trace(question, topk, client, database_name, table_name):
trace_id, answer = client.query(
f"SELECT TraceId, SpanAttributes['output'] as Answer FROM {database_name}.{table_name} WHERE SpanAttributes['question'] = '{question}' AND ParentSpanId = ''"
).result_rows[0]
span_dict = client.query(
f"SELECT SpanAttributes FROM {database_name}.{table_name} WHERE TraceId = '{trace_id}' AND SpanKind = 'retriever'"
).result_rows[0][0]
contexts = [span_dict.get(f"documents.{i}.content") for i in range(topk)]
print(score_with_ragas(question, contexts, answer))
test_question = "Wo hat Harrison gearbeitet?"
client = get_client(
host=os.getenv("MYSCALE_HOST"),
port=int(os.getenv("MYSCALE_PORT")),
username=os.getenv("MYSCALE_USERNAME"),
password=os.getenv("MYSCALE_PASSWORD"),
)
evaluate_trace(test_question, 4, client, "otel", "otel_traces")
Nach Ausführung des Beispiels können Sie die Leistung Ihrer RAG-Pipeline anhand der von Ragas bereitgestellten Bewertungen bewerten.
# Fazit
MyScale Telemetry bietet eine robuste Open-Source-Lösung zur Verbesserung der Beobachtbarkeit und Auswertung von LLM-Anwendungen. Durch die nahtlose Integration mit LangChain Callbacks erfasst es detaillierte Trace-Daten und speichert sie in MyScaleDB, um Probleme zu diagnostizieren, die Leistung zu optimieren und das Verhalten der Anwendung zu verstehen.
Das MyScale Trace Dashboard in Grafana bietet klare Visualisierungen dieser Trace-Daten, um Ihre LLM-Anwendungen effektiv zu überwachen und zu debuggen. Zu den wichtigsten Erkenntnissen gehören Ausführungszeiten der Funktionen, Eingabe- und Ausgabeverfolgung, DB-Retriever-Rückgaben, Prompt-Informationen, ChatOpenAI-Ausgaben und Token-Nutzung.
Darüber hinaus ermöglicht die Integration von RAGAS mit MyScale Telemetry eine umfassende Bewertung von RAG-Pipelines. Mit den in MyScaleDB gespeicherten Trace-Daten kann RAGAS Metriken wie Treue, Antwortrelevanz und Kontextnutzung bewerten, um hochwertige Ergebnisse und kontinuierliche Verbesserungen zu gewährleisten.
Wir laden Sie ein, MyScale Telemetry und das Grafana Dashboard auszuprobieren, um diese leistungsstarken Tools optimal zu nutzen. Bei Fragen oder weiterer Unterstützung steht Ihnen unser Support-Team gerne zur Verfügung.
