Ihr KI-Agent leistet beim Testen hervorragende Arbeit. Dann verschicken Sie es und etwas geht irgendwie kaputt. Ein Instrument namens Loops läuft ewig, als würde es nie lernen. Ein Abrufschritt bringt Müll zurück und die Kosten steigen. Sie haben überhaupt keine Ahnung, warum.

Das ist das Downside der Agentenbeobachtbarkeit. Und wenn Sie mit LLMs bauen, müssen Sie das Downside vor der Produktion lösen, nicht danach. In diesem Beitrag werden drei der am häufigsten verwendeten Observability-Instruments näher erläutert: LangSmith, Langfuse Und Arize. Wir richten jeden einzelnen ein, verfolgen denselben Agenten und vergleichen, was Sie tatsächlich erhalten.

Was ist Agent Observability?

Die herkömmliche Anwendungsüberwachung verfolgt Anfragen, Fehler und Latenz, aber das reicht für Agenten nicht aus.

Ein Agent kann mehrere Instruments nacheinander aufrufen, wobei jeder LLM-Schritt seine eigene Eingabeaufforderung, Token-Nutzung, Latenz und potenzielle Fehlerstelle hat. Ein einzelner fehlgeschlagener Abruf oder Instrument-Aufruf kann zu einer falschen Endantwort führen.

Beobachtbarkeit des Agenten erfasst das vollständige Ausführungsdiagramm: jeden Schritt, jede Entscheidung, jede LLM-Eingabe und -Ausgabe, jeden Instrument-Aufruf, Argumente, Ergebnisse, Token-Nutzung, Latenz und Bewertungsergebnis. Ohne diese Sichtbarkeit wird das Verhalten des Debug-Agenten zur Vermutung.

Einrichten des Testagenten

Wir werden einen sehr einfachen LangChain-Agenten verwenden, um sie zu vergleichen. Der Agent empfängt eine Frage des Benutzers, ruft den relevanten Kontext ab und antwortet mithilfe eines oder mehrerer Instruments, um eine Antwort bereitzustellen.

Zunächst müssen Sie den Testagenten erstellen und dafür alle erforderlichen Bibliotheken installieren.

Schauen wir uns den Basisagenten mit zwei Methoden an (search_docs Und get_order_status). Dies dient als Grundlage für den Vergleich mit den drei Observability-Instruments.

"""
Base agent used throughout all three observability demos.

Swap the OPENAI_API_KEY env var or name build_agent() from any demo file.
"""

import os

from dotenv import load_dotenv
from langchain.brokers import AgentExecutor, create_openai_tools_agent
from langchain.instruments import device
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

load_dotenv()


@device
def search_docs(question: str) -> str:
    """Search inside docs for related data."""
    # Simulated retrieval — swap together with your precise vector retailer
    docs = {
        "refund": (
            "Refunds are processed inside 5-7 enterprise days. "
            "Gadgets should be returned inside 30 days."
        ),
        "transport": (
            "Commonplace transport takes 3-5 enterprise days. "
            "Specific is 1-2 days."
        ),
        "account": (
            "You possibly can reset your password by way of the login web page. "
            "Contact assist for account points."
        ),
    }

    for key phrase, content material in docs.gadgets():
        if key phrase in question.decrease():
            return content material

    return f"Discovered basic docs associated to: {question}"


@device
def get_order_status(order_id: str) -> str:
    """Lookup the standing of an order by ID."""
    # Simulated order lookup
    statuses = {
        "ORD-001": "Shipped — anticipated supply 2026-05-30",
        "ORD-002": "Processing — not but shipped",
        "ORD-003": "Delivered on 2026-05-25",
    }

    return statuses.get(
        order_id,
        f"Order {order_id} not discovered within the system.",
    )


def build_agent() -> AgentExecutor:
    llm = ChatOpenAI(
        mannequin="gpt-4o",
        temperature=0,
        api_key=os.environ("OPENAI_API_KEY"),
    )

    instruments = (search_docs, get_order_status)

    immediate = ChatPromptTemplate.from_messages(
        (
            (
                "system",
                "You're a useful buyer assist assistant. "
                "Use instruments when wanted.",
            ),
            ("person", "{enter}"),
            MessagesPlaceholder(variable_name="agent_scratchpad"),
        )
    )

    agent = create_openai_tools_agent(llm, instruments, immediate)

    return AgentExecutor(
        agent=agent,
        instruments=instruments,
        verbose=False,
    )


TEST_QUESTIONS = (
    "What are the refund insurance policies?",
    "What's the standing of order ORD-002?",
    "How lengthy does transport take?",
)


if __name__ == "__main__":
    executor = build_agent()

    for query in TEST_QUESTIONS:
        print(f"nQ: {query}")

        outcome = executor.invoke({"enter": query})

        print(f"A: {outcome('output')}")

Dadurch wird ein Kandidatenagent erstellt, der auch mit jedem der Instruments verwendet werden kann. Das erste Instrument, das wir untersuchen werden, wird das von LangSmith bereitgestellte sein.

LangSmith: Native Langchain-Tracing

Das LangChain-Group hat sich weiterentwickelt LangSmith. Wenn Sie LangChain verwenden, erfolgt die Integration schnell und einfach.

"""
LangSmith observability demo.

Setup:

pip set up langsmith

Set LANGCHAIN_API_KEY in your .env file.

The way it works:

LangSmith hooks into LangChain's callback system by way of env vars, so no code
modifications are wanted past the 2 os.environ traces beneath.
"""

import os

from dotenv import load_dotenv

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()

# Allow LangSmith tracing. These two vars are all you want.
os.environ("LANGCHAIN_TRACING_V2") = "true"
os.environ("LANGCHAIN_PROJECT") = "agent-observability-demo"

# LANGCHAIN_API_KEY should be set in your .env or setting.


def run_with_metadata(
    executor,
    query: str,
    user_id: str = "demo-user",
):
    """Run the agent and fix per-run metadata by way of config."""
    return executor.invoke(
        {"enter": query},
        config={
            "metadata": {
                "user_id": user_id,
                "supply": "langsmith_demo",
            },
            # Optionally available: tag runs for filtering within the dashboard.
            "tags": ("observability-blog", "demo"),
        },
    )


def predominant():
    print("=== LangSmith Demo ===")
    print("Traces will seem at: https://smith.langchain.com")
    print(f"Venture: {os.environ('LANGCHAIN_PROJECT')}n")

    executor = build_agent()

    for query in TEST_QUESTIONS:
        print(f"Q: {query}")

        outcome = run_with_metadata(executor, query)

        print(f"A: {outcome('output')}n")

    print("Carried out. Open LangSmith to examine the complete hint tree for every run.")


if __name__ == "__main__":
    predominant()

LangSmith stellt automatisch eine Verbindung zum Rückrufsystem von LangChain her, ohne dass Dekorateure oder Wrapper erforderlich sind, um jede Ausführung in Ihrem Projekt-Dashboard anzuzeigen.

Was Sie auf dem Dashboard sehen werden:

Die Hint-Ansicht von LangSmith zeigt den vollständigen Agentenausführungsbaum, vom ersten Aufruf über die Instrument-Nutzung, LLM-Antworten bis hin zur endgültigen Ausgabe. Jeder Knoten umfasst Eingaben, Ausgaben und Latenz.

Sie können Läufe mit Tags versehen, Metadaten hinzufügen, nach Ergebnissen filtern, Läufe als Datensätze speichern und Auswertungen durchführen. Dies ist nützlich, wenn Sie Eingabeaufforderungen oder die Abruflogik verbessern.

Der prompte Spielplatz ist ein weiteres starkes Merkmal. Sie können eine beliebige Ablaufverfolgung öffnen, die Eingabeaufforderung inline bearbeiten und sie erneut ausführen, um eine schlechte LLM-Leistung zu beheben.

Die Einschränkungen von LangSmith zeigen sich im großen Maßstab. Für das kostenlose Kontingent gelten Obergrenzen und die Integration erfordert mehr Aufwand, wenn Sie LangChain nicht verwenden, obwohl OpenTelemetry unterstützt wird.

Langfuse: Open Supply und Framework-Agnostiker

Langfuse ist hier die Open-Supply-Various. Sie können es entweder auf Ihrem Server hosten oder deren Cloud-Dienst nutzen. Es lässt sich auch in alle Frameworks wie LangChain, LlamaIndex, rohe OpenAI-APIs usw. integrieren.

# Learn this Doc-string for putting in the dependencies and their setup 
"""
Langfuse observability demo.

Setup:

pip set up langfuse

Set LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY in your .env file.

LANGFUSE_HOST defaults to https://cloud.langfuse.com; override for self-hosted.

Key variations from LangSmith:

- Callback handler is handed per-invoke for extra express management.
- Native session grouping for multi-turn conversations.
- You possibly can rating any hint after the very fact by way of the Langfuse consumer.
"""

import os

from dotenv import load_dotenv
from langfuse import Langfuse
from langfuse.callback import CallbackHandler

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()


def build_handler(
    session_id: str,
    user_id: str = "demo-user",
) -> CallbackHandler:
    return CallbackHandler(
        public_key=os.environ("LANGFUSE_PUBLIC_KEY"),
        secret_key=os.environ("LANGFUSE_SECRET_KEY"),
        host=os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com"),
        session_id=session_id,
        user_id=user_id,
        metadata={"supply": "langfuse_demo"},
        tags=("observability-blog", "demo"),
    )


def score_trace(
    trace_id: str,
    rating: float,
    remark: str = "",
):
    """Add a correctness rating to a hint after reviewing the output."""
    lf = Langfuse(
        public_key=os.environ("LANGFUSE_PUBLIC_KEY"),
        secret_key=os.environ("LANGFUSE_SECRET_KEY"),
        host=os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com"),
    )

    lf.rating(
        trace_id=trace_id,
        title="correctness",
        worth=rating,
        remark=remark,
    )

    lf.flush()

    print(f"Scored hint {trace_id}: {rating}")


def run_single_session(
    executor,
    session_id: str,
):
    """Run all check questions in a single session so that they're linked within the UI."""
    handler = build_handler(session_id=session_id)
    trace_ids = ()

    for query in TEST_QUESTIONS:
        print(f"Q: {query}")

        outcome = executor.invoke(
            {"enter": query},
            config={"callbacks": (handler)},
        )

        print(f"A: {outcome('output')}n")

        # handler.get_trace_id() returns the hint ID for the final run.
        trace_ids.append(handler.get_trace_id())

    # Flush ensures traces are despatched earlier than the method exits.
    # That is essential in batch jobs.
    handler.flush()

    return trace_ids


def predominant():
    print("=== Langfuse Demo ===")
    print(f"Dashboard: {os.getenv('LANGFUSE_HOST', 'https://cloud.langfuse.com')}n")

    executor = build_agent()
    session_id = "demo-session-001"

    trace_ids = run_single_session(executor, session_id)

    # Instance: programmatically rating the primary hint.
    if trace_ids and trace_ids(0):
        print("nScoring first hint for example:")
        score_trace(trace_ids(0), rating=0.9, remark="Reply was correct")

    print(f"nDone. Discover all runs beneath session '{session_id}' in your Langfuse dashboard.")


if __name__ == "__main__":
    predominant()

Sie können bei jedem Lauf Callback-Handler übergeben, was etwas expliziter ist als bei LangSmith, aber mehr Flexibilität bietet, da Sie beim Aufruf Benutzer-IDs, Sitzungs-IDs und benutzerdefinierte Metadaten zuweisen können.

Bewertungsworkflow

Langfuse verfügt auch über einen wirklich guten Bewertungsworkflow; Sie können Punkte hinzufügen, nachdem die Verfolgung abgeschlossen ist.

from langfuse import Langfuse

lf = Langfuse()

# Rating a particular hint by ID.
lf.rating(
    trace_id="trace-abc123",
    title="correctness",
    worth=0.9,
    remark="Reply was correct however barely verbose",
)

Dies funktioniert in Verbindung mit menschlichen Überprüfungen der von Ihrem Group erzielten Antworten, sodass Sie im Laufe der Zeit aggregierte Bewertungsmetriken erhalten.

Benutzer können ihre Sitzungen organisieren, indem sie sie verbinden, sodass Agenten Gespräche über mehrere Runden hinweg problemlos verfolgen können. Alle Spuren einer einzelnen Benutzersitzung werden in der Anwendung verknüpft, sodass Sie ein gesamtes Gespräch an einem Ort verfolgen können.

Arize: ML-Beobachtbarkeit auf Produktionsniveau

Arize wurde ursprünglich als Plattform zur Überwachung herkömmlicher Modelle des maschinellen Lernens entwickelt und ist nun in der Lage, sowohl Sprachmodelle als auch Agenten zu beobachten. Die Tatsache, dass es ursprünglich entwickelt wurde, um Groups bei der maßstabsgetreuen Bereitstellung von Modellen in der Produktion zu unterstützen, ist bis heute erhalten geblieben.

Nutzung von OpenInference

Zusätzlich zur Verwendung des OpenInference-Requirements als Messschema lässt sich Arize zur Instrumentierung in OpenTelemetry integrieren. Die Konfiguration von Arize ist komplizierter als bei den meisten Anbietern.

# Learn this Doc-string for putting in the dependencies and their setup 
"""
Arize observability demo.

Setup:

pip set up arize-otel openinference-instrumentation-langchain

Set ARIZE_SPACE_ID and ARIZE_API_KEY in your .env file.

Key variations from the others:

- Makes use of OpenTelemetry beneath the hood, so it integrates with present OTel stacks.
- Instrumentation is international like LangSmith, not per-invoke like Langfuse.
- Greatest-in-class manufacturing monitoring: drift detection, cohort evaluation, alerting.
- Phoenix, arize-phoenix, is the free native sibling for growth use.
"""

import os

from arize.otel import register
from dotenv import load_dotenv
from openinference.instrumentation.langchain import LangChainInstrumentor

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()


def setup_arize_tracing():
    """Register Arize because the OTel tracer supplier and instrument LangChain globally."""
    tracer_provider = register(
        space_id=os.environ("ARIZE_SPACE_ID"),
        api_key=os.environ("ARIZE_API_KEY"),
        project_name="agent-observability-demo",
    )

    LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

    return tracer_provider


def run_with_attributes(
    executor,
    query: str,
    user_segment: str = "commonplace",
):
    """Run the agent and fix span attributes for cohort evaluation in Arize."""
    from opentelemetry import hint

    tracer = hint.get_tracer(__name__)

    with tracer.start_as_current_span("agent_run") as span:
        span.set_attribute("person.phase", user_segment)
        span.set_attribute("question.textual content", query)
        span.set_attribute("demo.supply", "arize_demo")

        outcome = executor.invoke({"enter": query})

        span.set_attribute("response.textual content", outcome("output"))

        return outcome


def predominant():
    print("=== Arize Demo ===")
    print("Traces will seem at: https://app.arize.com")
    print("Venture: agent-observability-demon")

    setup_arize_tracing()

    executor = build_agent()

    # Simulate two person segments to reveal cohort evaluation in Arize.
    segments = ("premium", "commonplace", "commonplace")

    for query, phase in zip(TEST_QUESTIONS, segments):
        print(f"Q: {query} (phase={phase})")

        outcome = run_with_attributes(
            executor,
            query,
            user_segment=phase,
        )

        print(f"A: {outcome('output')}n")

    print("Carried out. In Arize, use the cohort filter to check premium vs commonplace responses.")
    print("Arrange screens on the Arize dashboard to alert on response high quality drift.")


if __name__ == "__main__":
    predominant()

Die Instrumentierung ist international wie die von LangSmith, wird jedoch zu einem Bestandteil des gesamten Messrahmens von OpenTelemetry. Daher kann Arize den vorhandenen Observability Stack Ihrer Organisation nutzen, unabhängig vom tatsächlich verwendeten Framework (z. B. Jaeger, Grafana usw.).

Welches sollten Sie für die Beobachtbarkeit von Agenten auswählen?

Um ganz offen zu sein: Es gibt kein einziges richtiges Instrument für alle Anwendungsfälle. Es hängt alles davon ab, wo Sie sich im Entwicklungszyklus befinden und was Ihr Group braucht.

• Verwenden LangSmith wenn Sie mit LangChain erstellen und die schnellste Einrichtung für schnelles Debuggen und Iteration wünschen.
• Verwenden Langfuse wenn Sie Selbsthosting, stärkeres Dateneigentum, Multi-Framework-Unterstützung oder Monitoring auf Sitzungsebene für Konversationsagenten benötigen.
• Verwenden Arize wenn Ihr Agent in die Produktion übergeht und Sie Überwachung, Abweichungserkennung, Kohorten und Warnungen benötigen.

Abschluss

Die Beobachtbarkeit von Agenten gehört zu den Dingen, die Sie nur dann bereuen, wenn in der Produktion ein Fehler auftritt. Das Nachverfolgen einer Agentenausführung ohne jegliche Instrumentierung ist wie das Debuggen eines verteilten Programs mit Druckanweisungen.

Alle drei hier behandelten Werkzeuge sind produktionsbereit. Sie haben jeweils einen freien Zugang. Und die Integration mit einem LangChain-Agenten dauert jeweils weniger als 30 Minuten. Es gibt keinen guten Grund mehr, einen unbeobachtbaren Agenten zu entsenden.

Wählen Sie das Werkzeug, das zu Ihrer aktuellen Section passt. Fügen Sie frühzeitig Punkte hinzu, auch informell. Und wenn Ihr Agent um 2 Uhr morgens anfängt, etwas Seltsames zu tun, werden Sie es nicht bereuen.

Information Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Information Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
Du kannst mich auch erreichen unter (electronic mail protected)

Der Bau eines LLM-Prototyps ist schnell. Ein paar Zeilen Python, eine Eingabeaufforderung und es funktioniert. Aber Produktion ist ein ganz anderes Spiel. Sie sehen vage Antworten, Halluzinationen, Latenzspitzen und seltsame Fehler, bei denen das Modell eindeutig etwas „weiß“, es aber trotzdem falsch versteht. Da alles auf Wahrscheinlichkeiten basiert, wird das Debuggen schwierig. Warum wurden aus der Suche nach Stiefeln Schuhe? Das System hat eine Wahl getroffen, aber Sie können die Gründe nicht leicht nachvollziehen.

Um dieses Drawback anzugehen, werden wir bauen FuseCommerceein fortschrittliches E-Commerce-Unterstützungssystem, das auf Transparenz und Kontrolle ausgelegt ist. Mit Langfuse erstellen wir einen Agenten-Workflow mit semantischer Suche und Absichtsklassifizierung und halten dabei jede Entscheidung clear. In diesem Artikel verwandeln wir einen fragilen Prototyp in ein beobachtbares, produktionsreifes LLM-System.

Was ist Langfuse?

Langfuse fungiert als Open-Supply-Plattform für LLM-Engineering, die es Groups ermöglicht, beim Debuggen, Analysieren und Entwickeln ihrer LLM-Anwendungen zusammenzuarbeiten. Die Plattform fungiert als DevTools für KI-Agenten.

Das System bietet drei Hauptfunktionen, darunter:

• Tracing, das alle Ausführungspfade durch das System anzeigt, einschließlich LLM Aufrufe und Datenbankabfragen sowie Toolnutzung.
• Metriken, die eine Echtzeitüberwachung von Latenz, Kosten und Token-Nutzung ermöglichen.
• Eine Bewertung, bei der Benutzerfeedback über ein „Daumen hoch“- und „Daumen runter“-System gesammelt wird, das eine direkte Verbindung zu der spezifischen Technology herstellt, die das Suggestions abgegeben hat.
• Das System ermöglicht Assessments durch Dataset Administration, wodurch Benutzer ihre Testeingaben und -ausgaben kuratieren können.

In diesem Projekt fungiert Langfuse als unser Hauptprotokollierungssystem, das uns dabei hilft, ein automatisiertes System zu erstellen, das seine eigene Leistung verbessert.

Was wir schaffen: FuseCommerce…

Wir werden einen intelligenten Kundenbetreuer für ein Technologie-Einzelhandelsunternehmen namens „FuseCommerce.“

Im Gegensatz zu einem Customary-LLM-Wrapper sind folgende Elemente enthalten:

• Kognitives Routing – Die Fähigkeit, zu analysieren (durchzudenken), was man sagen soll, bevor man antwortet – einschließlich der Bestimmung des/der Grund(es) für die Interaktion (z. B. etwas kaufen wollen vs. eine Bestellung prüfen vs. über etwas reden wollen).
• Semantisches Gedächtnis – Die Fähigkeit, Ideen als Konzepte zu erkennen und darzustellen (z. B. wie „Gaming-Ausrüstung“ und eine „mechanische Maus“ konzeptionell miteinander verbunden sind) durch Vektoreinbettung.
• Visuelles Denken (einschließlich einer beeindruckenden Benutzeroberfläche) – Eine Möglichkeit, dem Kunden visuell darzustellen, was der Agent tut.

Die Rolle von Langfuse im Projekt

Langfuse ist das Rückgrat des für diese Arbeit verwendeten Agenten. Es ermöglicht uns, die einzelnen Schritte unseres Agenten zu verfolgen (Absichtsklassifizierung, Abruf, Generierung) und zeigt uns, wie sie alle zusammenarbeiten, sodass wir genau bestimmen können, wo etwas schief gelaufen ist, wenn eine Antwort falsch ist.

• Rückverfolgbarkeit – Wir werden versuchen, alle Schritte eines Agenten auf Langfuse mithilfe von Spans zu erfassen. Wenn ein Benutzer eine falsche Antwort erhält, können wir Span-Monitoring oder einen Hint verwenden, um genau zu identifizieren, wo im Prozess des Agenten der Fehler aufgetreten ist.
• Sitzungsverfolgung – Wir erfassen alle Interaktionen zwischen dem Benutzer und dem Agenten innerhalb einer Gruppierung, die durch ihr ` identifiziert wirdsession_id` auf dem Langfuse-Dashboard, damit wir alle Benutzerinteraktionen für den Kontext wiedergeben können.
• Rückkopplungsschleife – Wir werden Benutzer-Suggestions-Schaltflächen direkt in den Hint einbauen. Wenn ein Benutzer additionally eine Antwort ablehnt, können wir sofort herausfinden, welcher Abruf oder welche Eingabeaufforderung den Benutzer dazu veranlasst hat, die Antwort abzulehnen.

Erste Schritte

Sie können schnell und einfach mit der Set up des Agenten beginnen.

Voraussetzungen

Set up

Als Erstes müssen Sie die folgenden Abhängigkeiten installieren, die aus dem Langfuse SDK und denen von Google bestehen Generative KI.

pip set up langfuse streamlit google-generativeai python-dotenv numpy scikit-learn 

Konfiguration

Nachdem Sie die Set up der Bibliotheken abgeschlossen haben, müssen Sie eine erstellen .env Datei, in der Ihre Anmeldeinformationen sicher gespeichert werden.

GOOGLE_API_KEY=your_gemini_key
LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=https://cloud.langfuse.com 

Wie baut man?

Schritt 1: Die semantische Wissensdatenbank

Eine herkömmliche Stichwortsuche kann scheitern, wenn ein Benutzer unterschiedliche Wörter verwendet, additionally Synonyme verwendet. Daher möchten wir Vector Embeddings nutzen, um eine semantische Suchmaschine aufzubauen.

Rein durch Mathematik, d.h. Kosinusähnlichkeitwerden wir für jedes unserer Produkte einen „Bedeutungsvektor“ erstellen.

# db.py
from sklearn.metrics.pairwise import cosine_similarity
import google.generativeai as genai


def semantic_search(question):
    # Create a vector illustration of the question
    query_embedding = genai.embed_content(
        mannequin="fashions/text-embedding-004",
        content material=question
    )("embedding")

    # Utilizing math, discover the closest meanings to the question
    similarities = cosine_similarity((query_embedding), product_vectors)
    return get_top_matches(similarities)

Schritt 2: Das „Gehirn“ des intelligenten Routings

Wenn Benutzer „Hallo“ sagen, können wir die Benutzerabsicht mithilfe eines Klassifikators klassifizieren, sodass wir das Durchsuchen der Datenbank vermeiden können.

Sie werden sehen, dass wir mithilfe des auch Eingabe, Ausgabe und Latenz automatisch erkennen @langfuse.observe Dekorateur. Wie Magie!

@langfuse.observe(as_type="technology")
def classify_user_intent(user_input):
    immediate = f"""
    Use the next person enter to categorise the person's intent into one of many three classes:
    1. PRODUCT_SEARCH
    2. ORDER_STATUS
    3. GENERAL_CHAT

    Enter: {user_input}
    """

    # Name Gemini mannequin right here...
    intent = "PRODUCT_SEARCH"  # Placeholder return worth

    return intent

Schritt 3: Der Arbeitsablauf des Agenten

Wir fügen unseren Prozess zusammen. Der Agent nimmt wahr, erhält Eingaben, denkt (klassifiziert) und handelt dann (routet).

Wir verwenden die Methode lf_client.update_current_trace um die Konversation mit Metadateninformationen wie z. B. zu kennzeichnen session_id.

@langfuse.observe()  # Root Hint
def handle_customer_user_input(user_input, session_id):
    # Tag the session
    langfuse.update_current_trace(session_id=session_id)

    # Suppose
    intent = get_classified_intent(user_input)

    # Act primarily based on categorised intent
    if intent == "PRODUCT_SEARCH":
        context = use_semantic_search(user_input)
    elif intent == "ORDER_STATUS":
        context = check_order_status(user_input)
    else:
        context = None  # Non-compulsory fallback for GENERAL_CHAT or unknown intents

    # Return the response
    response = generate_ai_response(context, intent)
    return response

Schritt 4: Benutzeroberfläche und Feedbacksystem

Wir erstellen eine erweiterte Streamlit-Benutzeroberfläche. Eine wesentliche Änderung besteht darin, dass Suggestions-Schaltflächen einen Suggestions-Rating an Langfuse zurückgeben, der auf der individuellen Hint-ID basiert, die mit der spezifischen Benutzerkonversation verknüpft ist.

# app.py
col1, col2 = st.columns(2)

if col1.button("👍"):
    lf_client.rating(trace_id=trace_id, title="user-satisfaction", worth=1)

if col2.button("👎"):
    lf_client.rating(trace_id=trace_id, title="user-satisfaction", worth=0)

Eingaben, Ausgaben und Analyseergebnisse

Schauen wir uns die Anfrage eines Benutzers genauer an: „Verkaufen Sie Zubehör für Gaming-Systeme?“

1. Die Anfrage

• Benutzer: „Verkaufen Sie Zubehör für Gaming-Systeme?“
• Kontext: Keine exakte Übereinstimmung für das Schlüsselwort „Zubehör“.

2. Die Spur (Langfuse Level of Perspective)

Langfuse erstellt eine Hint-Ansicht, um die verschachtelte Hierarchie zu visualisieren:

TRACE: Agentengespräch (1,5 Sekunden)

• Technology: classify_intent –> Ausgabe = PRODUCT_SEARCH
• Spanne: Recover_Knowledge –> Semantische Suche = ordnet Spieldaten geometrisch der Quantum Wi-fi Mouse und dem UltraView Monitor zu.
• Technology: generate_ai_response –> Output = „Ja! Für Gaming-Systeme empfehlen wir die Quantum Wi-fi Mouse…“

3. Analyse

Sobald der Benutzer auf „Daumen hoch“ klickt, erhält Langfuse eine Punktzahl von 1. Sie erhalten die Gesamtsumme der „Daumen hoch“-Klicks professional Tag, um den Tagesdurchschnitt anzuzeigen. Außerdem steht Ihnen ein kumulatives visuelles Dashboard zur Verfügung:

• Durchschnittliche Latenz: Verlangsamt sich Ihre semantische Suche?
• Absichtsgenauigkeit: Halluziniert das Routing??
• Kosten / Sitzung: Wie viel kostet die Nutzung von Gemini?

Abschluss

Durch unsere Implementierung von Langfuse haben wir ein verborgen funktionierendes Chatbot-System in ein offen sichtbares Betriebssystem umgewandelt. Durch die Entwicklung von Produktfunktionen haben wir das Vertrauen der Benutzer aufgebaut.

Wir haben durch die Absichtsklassifizierung bewiesen, dass unser Agent „Denkfähigkeiten“ besitzt, während er durch die semantische Suche Dinge „verstehen“ und sich durch Benutzer-Suggestions-Scores Wissen „aneignen“ kann. Dieses architektonische Design dient als Grundlage für moderne KI-Systeme, die in realen Umgebungen arbeiten.

Häufig gestellte Fragen

Information Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Information Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
Du kannst mich auch erreichen unter (e mail protected)

Die Erstellung und Bereitstellung von Anwendungen, die Massive Language Fashions (LLMs) nutzen, bringt ihre eigenen Probleme mit sich. LLMs sind nicht-deterministischer Natur, können believable, aber falsche Informationen generieren und die Verfolgung ihrer Aktionen in verschachtelten Sequenzen kann sehr mühsam sein. In diesem Leitfaden werden wir sehen, wie sich Langfuse als wesentliches Instrument zur Lösung dieser Probleme erweist, indem es eine solide Grundlage für die vollständige Beobachtbarkeit, Bewertung und schnelle Bearbeitung von LLM-Anwendungen bietet.

Was ist Langfuse?

Langfuse ist eine bahnbrechende Beobachtbarkeits- und Bewertungsplattform, die Open Supply ist und speziell für LLM-Anwendungen entwickelt wurde. Es ist die Grundlage für die Verfolgung, Anzeige und Fehlerbehebung aller Phasen einer LLM-Interaktion, angefangen von der ersten Aufforderung bis hin zur endgültigen Antwort, unabhängig davon, ob es sich um einen einfachen Anruf oder ein kompliziertes Gespräch mit mehreren Gesprächen zwischen Agenten handelt.

Langfuse ist nicht nur ein Protokollierungstool, sondern auch ein Mittel zur systematischen Bewertung der LLM-Leistung, zum A/B-Testen von Eingabeaufforderungen und zum Sammeln von Benutzerfeedback, was wiederum dazu beiträgt, die Feedbackschleife zu schließen, die für iterative Verbesserungen unerlässlich ist. Der Hauptvorteil liegt in der Transparenz, die es in die LLM-Welt bringt und den Entwicklern so ermöglicht:

• LLM-Verhalten verstehen: Informieren Sie sich über die genauen gesendeten Aufforderungen, die eingegangenen Antworten und die Zwischenschritte in einer mehrstufigen Bewerbung.
• Probleme finden: Lokalisieren Sie schnell die Quelle von Fehlern, geringer Leistung oder unerwarteten Ausgaben.
• Qualitätsbewertung: Die Wirksamkeit von LLM-Antworten kann anhand der vordefinierten Metriken sowohl manuell als auch automatisiert gemessen werden.
• Verfeinern und verbessern: Datengesteuerte Erkenntnisse können zur Perfektionierung von Eingabeaufforderungen, Modellen und Anwendungslogik genutzt werden.
• Behandeln Sie Eingabeaufforderungen: Kontrollieren Sie die Model der Eingabeaufforderungen und testen Sie sie, um das beste LLM zu erhalten.

Hauptmerkmale und Konzepte

Langfuse bietet verschiedene Hauptfunktionen wie:

1. Rückverfolgung und Überwachung

Langfuse hilft uns dabei, die detaillierten Spuren jeder Interaktion zu erfassen, die LLM durchführt. Der „Hint“ ist im Grunde die Darstellung einer Finish-to-Finish-Benutzeranfrage oder eines Anwendungsflusses. Innerhalb eines Hint werden logische Arbeitseinheiten durch „Spans“ bezeichnet und Aufrufe eines LLM beziehen sich auf „Generationen“.

2. Auswertung

Langfuse ermöglicht die Auswertung sowohl manuell als auch programmgesteuert. Von den Entwicklern können benutzerdefinierte Metriken definiert werden, mit denen dann Auswertungen für verschiedene Datensätze durchgeführt und dann als LLM-basierte Evaluatoren integriert werden können.

3. Prompte Verwaltung

Langfuse bietet direkte Kontrolle über das Immediate-Administration sowie Speicher- und Versionierungsfunktionen. Es ist möglich, verschiedene Eingabeaufforderungen durch A/B-Checks zu testen und gleichzeitig die Genauigkeit über verschiedene Orte hinweg aufrechtzuerhalten, was auch den Weg für eine datengesteuerte Eingabeaufforderungsoptimierung ebnet.

4. Suggestions-Sammlung

Langfuse nimmt die Benutzervorschläge auf und integriert sie direkt in Ihre Spuren. Sie können bestimmte Bemerkungen oder Benutzerbewertungen mit der genauen LLM-Interaktion verknüpfen, die zu einer Ausgabe geführt hat, und uns so in Echtzeit Suggestions zur Fehlerbehebung und Verbesserung geben.

Warum Langfuse? Das Downside, das es löst

Herkömmliche Software program-Observability-Instruments weisen sehr unterschiedliche Eigenschaften auf und erfüllen die Kriterien für LLM-basierte Anwendungen in folgenden Aspekten nicht:

• Nichtdeterminismus: LLMs liefern selbst bei identischer Eingabe nicht immer das gleiche Ergebnis, was das Debuggen zu einer ziemlichen Herausforderung macht. Langfuse wiederum zeichnet die Eingaben und Ausgaben jeder Interaktion auf und liefert so ein klares Bild des Vorgangs in diesem Second.
• Sofortige Empfindlichkeit: Jede geringfügige Änderung an einer Eingabeaufforderung kann die Antwort von LLM vollständig ändern. Langfuse hilft dabei, den Überblick über Immediate-Versionen und deren Leistungsmetriken zu behalten.
• Komplexe Ketten: Die meisten LLM-Anwendungen zeichnen sich durch eine Kombination aus mehreren LLM-Aufrufen, verschiedenen Instruments und dem Abrufen von Daten (z. B. LAPPEN Architekturen). Die einzige Möglichkeit, den Fluss zu kennen und die Stelle zu lokalisieren, an der der Engpass oder der Fehler liegt, ist die Rückverfolgung. Langfuse präsentiert eine visuelle Zeitleiste für diese Interaktionen.
• Subjektive Qualität: Der Begriff „intestine“ für die Antwort eines LLM ist oft gleichbedeutend mit persönlicher Meinung. Langfuse ermöglicht sowohl objektive (z. B. Latenz, Token-Anzahl) als auch subjektive (menschliches Suggestions, LLM-basierte Bewertung) Qualitätsbewertungen.
• Kostenmanagement: Der Aufruf von LLM-APIs ist mit einem Preis verbunden. Das Verstehen und Optimieren Ihrer Kosten wird einfacher, wenn Langfuse Ihre Token-Nutzung und Ihr Anrufvolumen überwacht.
• Mangelnde Sichtbarkeit: Der Entwickler kann nicht sehen, wie sich seine LLM-Anwendungen auf dem Markt entwickeln, und daher ist es für ihn aufgrund der mangelnden Beobachtbarkeit schwierig, diese Anwendungen schrittweise zu verbessern.

Langfuse bietet nicht nur eine systematische Methode für LLM Interaktion, aber es verwandelt den Entwicklungsprozess auch in eine datengesteuerte, iterative Ingenieursdisziplin statt in Versuch und Irrtum.

Erste Schritte mit Langfuse

Bevor Sie Langfuse verwenden können, müssen Sie zunächst die Consumer-Bibliothek installieren und für die Übertragung von Daten an eine Langfuse-Instanz einrichten, bei der es sich entweder um eine in der Cloud gehostete oder eine selbst gehostete Instanz handeln kann.

Set up

Langfuse verfügt über Consumer-Bibliotheken, die sowohl für Python als auch für JavaScript/TypeScript verfügbar sind.

Python-Consumer

pip set up langfuse 

JavaScript/TypeScript-Consumer

npm set up langfuse 

Oder

yarn add langfuse 

Konfiguration

Denken Sie nach der Set up daran, den Consumer mit Ihren Projektschlüsseln und Ihrem Host einzurichten. Sie finden diese in Ihren Langfuse-Projekteinstellungen.

• public_key: Dies gilt für Frontend-Anwendungen oder für Fälle, in denen nur begrenzte und nicht vertrauliche Daten gesendet werden.
• geheimer_Schlüssel: Dies gilt für Backend-Anwendungen und -Szenarien, bei denen die vollständige Beobachtbarkeit, einschließlich sensibler Ein-/Ausgaben, erforderlich ist.
• Gastgeber: Dies bezieht sich auf die URL Ihrer Langfuse-Instanz (z. B. https://cloud.langfuse.com).
• Umfeld: Dies ist eine optionale Zeichenfolge, die zur Unterscheidung zwischen verschiedenen Umgebungen (z. B. Produktion, Staging, Entwicklung) verwendet werden kann.

Aus Sicherheits- und Flexibilitätsgründen wird es als bewährte Praxis angesehen, diese als Umgebungsvariablen zu definieren.

export LANGFUSE_PUBLIC_KEY="pk-lf-..." 
export LANGFUSE_SECRET_KEY="sk-lf-..." 
export LANGFUSE_HOST="https://cloud.langfuse.com" 
export LANGFUSE_ENVIRONMENT="improvement"

Initialisieren Sie dann den Langfuse-Consumer in Ihrer Anwendung:

Python-Beispiel

from langfuse import Langfuse
import os

langfuse = Langfuse(public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),    secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),    host=os.environ.get("LANGFUSE_HOST"))

JavaScript/TypeScript-Beispiel

import { Langfuse } from "langfuse";

const langfuse = new Langfuse({  publicKey: course of.env.LANGFUSE_PUBLIC_KEY,  secretKey: course of.env.LANGFUSE_SECRET_KEY,  host: course of.env.LANGFUSE_HOST});

Einrichten Ihres ersten Hint

Die grundlegende Einheit der Beobachtbarkeit in Langfuse ist die Spur. Ein Hint stellt typischerweise eine einzelne Benutzerinteraktion oder einen vollständigen Anforderungslebenszyklus dar. Innerhalb eines Hint protokollieren Sie einzelne LLM-Aufrufe (Generierung) und beliebige Rechenschritte (Span).

Lassen Sie uns dies anhand eines einfachen LLM-Aufrufs veranschaulichen OpenAIs API.

Python-Beispiel

import os
from openai import OpenAI
from langfuse import Langfuse
from langfuse.mannequin import InitialGeneration

# Initialize Langfuse
langfuse = Langfuse(
    public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),
    secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),
    host=os.environ.get("LANGFUSE_HOST"),
)

# Initialize OpenAI consumer
consumer = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def simple_llm_call_with_trace(user_input: str):
    # Begin a brand new hint
    hint = langfuse.hint(
        identify="simple-query",
        enter=user_input,
        metadata={"user_id": "user-123", "session_id": "sess-abc"},
    )

    strive:
        # Create a technology throughout the hint
        technology = hint.technology(
            identify="openai-generation",
            enter=user_input,
            mannequin="gpt-4o-mini",
            model_parameters={"temperature": 0.7, "max_tokens": 100},
            metadata={"prompt_type": "customary"},
        )

        # Make the precise LLM name
        chat_completion = consumer.chat.completions.create(
            mannequin="gpt-4o-mini",
            messages=({"function": "person", "content material": user_input}),
            temperature=0.7,
            max_tokens=100,
        )

        response_content = chat_completion.decisions(0).message.content material

        # Replace technology with the output and utilization
        technology.replace(
            output=response_content,
            completion_start_time=chat_completion.created,
            utilization={
                "prompt_tokens": chat_completion.utilization.prompt_tokens,
                "completion_tokens": chat_completion.utilization.completion_tokens,
                "total_tokens": chat_completion.utilization.total_tokens,
            },
        )

        print(f"LLM Response: {response_content}")
        return response_content

    besides Exception as e:
        # Document errors within the hint
        hint.replace(
            degree="ERROR",
            status_message=str(e)
        )
        print(f"An error occurred: {e}")
        elevate

    lastly:
        # Guarantee all knowledge is distributed to Langfuse earlier than exit
        langfuse.flush()


# Instance name
simple_llm_call_with_trace("What's the capital of France?")

Schließlich besteht Ihr nächster Schritt nach der Ausführung dieses Codes darin, zur Langfuse-Schnittstelle zu wechseln. Es wird einen neuen Hint „simple-query“ geben, der aus einer Technology „openai-generation“ besteht. Sie können darauf klicken, um die Eingabe, Ausgabe, das verwendete Modell und andere Metadaten anzuzeigen.

Kernfunktionen im Element

Das Erlernen des Umgangs mit Hint-, Span- und Generierungsobjekten ist die wichtigste Voraussetzung, um Langfuse nutzen zu können.

LLM-Anrufe verfolgen

• langfuse.hint(): Dieser Befehl startet einen neuen Hint. Der Container der obersten Ebene für einen gesamten Vorgang.
  • Identify: Der sehr aussagekräftige Identify der Spur.
  • Eingang: Die erste Eingabe des gesamten Verfahrens.
  • Metadaten: Ein Wörterbuch beliebiger Schlüssel-Wert-Paare zum Filtern und Analysieren (z. B. user_id, session_id, AB_test_variant).
  • Sitzungs-ID: (Optionally available) Eine Kennung, die von allen Traces gemeinsam genutzt wird, die aus derselben Benutzersitzung stammen.
  • Benutzer-ID: (Optionally available) Eine Kennung, die von allen Interaktionen eines bestimmten Benutzers gemeinsam genutzt wird.

• hint.span(): Dies ist ein logischer Schritt oder eine kleinere Operation innerhalb eines Hint, bei dem es sich nicht um eine direkte Eingabe-Ausgabe-Interaktion mit dem LLM handelt. Toolaufrufe, Datenbankabfragen oder komplexe Berechnungen können so nachvollzogen werden.
  • Identify: Identify des Spans (z. B. „retrieve-docs“, „parse-json“).
  • Eingang: Die für diese Spanne relevante Eingabe.
  • Ausgabe: Die von dieser Spanne erstellte Ausgabe.
  • Metadaten: Die Span-Metadaten werden als zusätzlich formatiert.
  • Ebene: Der Schweregrad (INFO, WARNUNG, FEHLER, DEBUG).
  • status_message: Eine Meldung, die mit dem Standing verknüpft ist (z. B. Fehlerdetails).
  • parent_observation_id: Verbindet diesen Span mit einem übergeordneten Span oder Hint für verschachtelte Strukturen.

• hint.technology(): Bezeichnet einen bestimmten LLM-Aufruf.
  • Identify: Der Identify der Technology (zum Beispiel „initial-response“, „refinement-step“).
  • Eingang: Die Eingabeaufforderung oder Nachrichten, die an das LLM übermittelt wurden.
  • Ausgabe: Die vom LLM erhaltene Antwort.
  • Modell: Das genaue LLM-Modell, das verwendet wurde (zum Beispiel „gpt-4o-mini„, „Claude-3-Opus“).
  • Modellparameter: Ein Wörterbuch bestimmter Modellparameter (wie temperature, max_tokens, top_p).
  • Verwendung: Ein Wörterbuch, das die Anzahl der verwendeten Token anzeigt (prompt_tokens, completion_tokens, total_tokens).
  • Metadaten: Zusätzliche Metadaten für den LLM-Aufruf.
  • parent_observation_id: Verknüpft diese Technology mit einem übergeordneten Span oder Hint.
  • immediate: (Optionally available) Kann eine bestimmte Eingabeaufforderungsvorlage identifizieren, die in Langfuse verwaltet wird.

Abschluss

Langfuse macht die Entwicklung und Wartung von LLM-basierten Anwendungen zu einem weniger anstrengenden Unterfangen, indem es sie in einen strukturierten und datengesteuerten Prozess umwandelt. Dies wird erreicht, indem Entwicklern durch umfassende Nachverfolgung, systematische Auswertung und leistungsstarkes Immediate-Administration wie nie zuvor Zugriff auf die Interaktionen mit dem LLM gewährt wird.

Darüber hinaus ermutigt es die Entwickler, ihre Arbeit mit Sicherheit zu debuggen, den Iterationsprozess zu beschleunigen und ihre KI-Produkte in Bezug auf Qualität und Leistung weiter zu verbessern. Daher stellt Langfuse die notwendigen Instrumente bereit, um sicherzustellen, dass LLM-Anwendungen vertrauenswürdig, kostengünstig und wirklich leistungsstark sind, unabhängig davon, ob Sie einen einfachen Chatbot oder einen anspruchsvollen autonomen Agenten entwickeln.

Häufig gestellte Fragen

Knowledge Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Knowledge Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
Du kannst mich auch erreichen unter (e-mail protected)