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)

Haben Sie Schwierigkeiten, KI-Systeme zuverlässig und konsistent zu machen? Viele Groups stehen vor dem gleichen Downside. Ein leistungsstarker LLM liefert großartige Ergebnisse, aber ein günstigeres Modell versagt bei derselben Aufgabe oft. Dies erschwert die Skalierung von Produktionssystemen. Harness Engineering bietet eine Lösung. Anstatt das Modell zu ändern, bauen Sie ein System darauf auf. Sie verwenden Eingabeaufforderungen, Instruments, Middleware und Auswertungen, um das Modell zu zuverlässigen Ausgaben zu führen. In diesem Artikel habe ich mithilfe von einen zuverlässigen KI-Codierungsagenten erstellt Die DeepAgents von LangChain Und LangSmith. Wir testen seine Leistung auch mit Customary Maßstäbe.

Was ist Harness Engineering?

Der Schwerpunkt des Harness Engineering liegt auf dem Aufbau eines strukturierten Programs rund um ein LLM, um die Zuverlässigkeit zu verbessern. Anstatt die Modelle zu ändern, steuern Sie die Umgebungen, in denen sie funktionieren. Ein Harness umfasst eine Systemeingabeaufforderung, Instruments oder APIs, einen Testaufbau und Middleware, die das Verhalten des Modells steuert. Das Ziel besteht darin, den Aufgabenerfolg zu verbessern und die Kosten zu verwalten und dabei dasselbe zugrunde liegende Modell zu verwenden.

Für diesen Artikel verwenden wir die DeepAgents-Bibliothek von LangChain. DeepAgents fungiert als Agenten-Harness mit integrierten Funktionen wie Aufgabenplanung, einem speicherinternen virtuellen Dateisystem und Subagenten-Spawning. Diese Funktionen tragen dazu bei, den Arbeitsablauf des Agenten zu strukturieren und zuverlässiger zu machen.

Lesen Sie auch: Ein Leitfaden zu LangGraph und LangSmith zum Erstellen von KI-Agenten

Auswertung und Metriken

HumanEval ist ein Benchmark, der 164 handgefertigte Python-Probleme zur Bewertung der funktionalen Korrektheit umfasst. Wir werden diese Daten verwenden, um die KI-Agenten zu testen, die wir erstellen werden.

• Go@1 (Erfolg beim ersten Schuss): Der Prozentsatz der Probleme, die das Modell in einem einzigen Versuch korrekt gelöst hat. Dies ist der Goldstandard für Produktionssysteme, bei denen Benutzer auf einmal eine korrekte Antwort erwarten.
• Go@okay (Erfolg bei mehreren Stichproben): Die Wahrscheinlichkeit, dass mindestens eine von okay generierten Stichproben korrekt ist. Dies wird verwendet, um das Wissen oder die Erkundungskraft des Modells zu messen.

Erstellen eines Codierungsagenten mit Harness Engineering

Wir werden einen Codierungsagenten erstellen und ihn anhand der von uns definierten Benchmarks und Metriken bewerten. Der Agent wird mithilfe der DeepAgents-Bibliothek von LangChain implementiert und nutzt die Ideen des Harness Engineering zum Aufbau des KI-Programs.

Voraussetzungen (API-Schlüssel)

1. Besuchen Sie die LangSmith Dashboard und klicken Sie auf die Schaltfläche „Beobachtbarkeit einrichten“. Dann sehen Sie diesen Bildschirm. Klicken Sie nun auf die Possibility „API-Schlüssel generieren“ und halten Sie den LangSmith-Schlüssel bereit.

2. Wir benötigen außerdem einen OpenAI-API-Schlüssel und verwenden das gpt-5-Modell als Gehirn des Programs. Den API-Schlüssel erhalten Sie bei diesen Hyperlink.

Installationen

!git clone https://github.com/openai/human-eval.git 
!sed -i '/evaluate_functional_correctness/d' human-eval/setup.py 
!pip set up -qU ./human-eval deepagents langchain-openai 

Initialisierungen

import os 
from google.colab import userdata 

os.environ('LANGCHAIN_TRACING_V2') = 'true' 
os.environ('LANGSMITH_API_KEY')    = userdata.get('LANGSMITH_API_KEY')  
os.environ('LANGSMITH_PROJECT')    = 'DeepAgent' 
os.environ('OPENAI_API_KEY') = userdata.get('OPENAI_API_KEY')

Definieren der Eingabeaufforderungen

from langsmith import Shopper
from langchain_core.prompts import ChatPromptTemplate

ls = Shopper()

PROMPTS = {
    "coding-agent-1": (
        "You're a Python coding assistant.n"
        "Given a operate signature and docstring, full the implementation.n"
        "Return ONLY the finished Python operate — no prose, no markdown fences."
    ),

    "coding-agent-2": (
        "You're a Python coding assistant with a self-verification self-discipline.n"
        "Steps you MUST comply with:n"
        "1. Learn the docstring and edge circumstances rigorously.n"
        "2. Write the implementation.n"
        "3. Mentally run the offered examples in opposition to your code.n"
        "4. If any instance fails, rewrite and repeat step 3.n"
        "Return ONLY the finished Python operate. No prose, no markdown fences."
    ),

    "coding-agent-3": (
        "You're an professional Python engineer. Assume step-by-step earlier than coding.n"
        "nProcess:n"
        "<suppose>n"
        "  - Restate what the operate should do in a single sentence.n"
        "  - Listing nook circumstances (empty inputs, negatives, giant values).n"
        "  - Select the best appropriate algorithm.n"
        "</suppose>n"
        "Then output the finished Python operate verbatim — no markdown, no rationalization."
    ),
}

for title, textual content in PROMPTS.objects():
    immediate = ChatPromptTemplate.from_messages(
        (("system", textual content), ("human", "{enter}"))
    )

    ls.push_prompt(title, object=immediate)
    print(f"pushed: {title}")

Ausgabe:

pushed: coding-agent-1 
pushed: coding-agent-2 
pushed: coding-agent-3

Wir haben die Eingabeaufforderungen definiert und an LangSmith weitergeleitet. Sie können dasselbe im Abschnitt „Eingabeaufforderungen“ im LangSmith-Dashboard überprüfen:

Definition unseres ersten Agenten

from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

PROMPT = "coding-agent-1"

pulled = ls.pull_prompt(PROMPT)
system_prompt = pulled.messages(0).immediate.template

print(f"Loaded immediate: {PROMPT}")
print(system_prompt(:120), "...")

mannequin = init_chat_model("openai:gpt-5-mini")

# Creating the DeepAgent
agent = create_deep_agent(
    mannequin=mannequin,
    system_prompt=system_prompt,
)

print("nAgent prepared")

Der Agent sollte einsatzbereit sein. Er verwendet die zuvor definierte Eingabeaufforderung „coding-agent-1“.

Testen Sie den Agenten

# Obtain the HumanEval benchmark dataset (164 Python coding issues)
!wget -q https://github.com/openai/human-eval/uncooked/grasp/knowledge/HumanEval.jsonl.gz -O HumanEval.jsonl.gz

# Import required libraries
import gzip
import json

# Operate to learn the HumanEval dataset
def read_problems(path="HumanEval.jsonl.gz"):
    issues = {}

    attempt:
        with gzip.open(path, "rt") as f:
            for line in f:
                p = json.masses(line)
                issues(p("task_id")) = p
    besides FileNotFoundError:
        print("Dataset file not discovered.")

    return issues

# Load all issues
issues = read_problems()

# Extract job IDs
task_ids = listing(issues.keys())

# Print whole variety of issues
print(f"Whole issues: {len(task_ids)}")

# Elective: examine the primary drawback
instance = issues(task_ids(0))

print("nExample Job ID:", instance("task_id"))
print("nPrompt:n", instance("immediate"))
print("nCanonical Resolution:n", instance("canonical_solution"))

Gesamtprobleme: 164

Wir haben jetzt 164 Codierungsprobleme, die wir zum Testen des Programs verwenden können.

Code mit dem Agenten generieren

import re

def extract_code(textual content: str, immediate: str) -> str:
    """Return simply the finished operate, stripping any markdown wrapping."""
    
    textual content = re.sub(r"```pythons*", "", textual content)
    textual content = re.sub(r"```s*", "", textual content)

    if textual content.strip().startswith("def "):
        return textual content.strip()

    return immediate + textual content


def resolve(drawback: dict) -> str:
    consequence = agent.invoke(
        {"messages": ({"position": "consumer", "content material": drawback("immediate")})},
        config={
            "metadata": {
                "task_id": drawback("task_id"),
                "prompt_name": PROMPT,
            }
        },
    )

    uncooked = consequence("messages")(-1).content material
    return extract_code(uncooked, drawback("immediate"))


# Check the system on the primary drawback earlier than operating the total analysis
pattern = issues(task_ids(0))
code = resolve(pattern)

print(code)

Ausgabe:

Großartig! Wir haben ein funktionierendes System. Testen wir es jetzt an 5 Codierungsproblemen!

import pandas as pd

# Calculate move@1 and common latency
handed = sum(r("handed") for r in outcomes)
pass_at_1 = handed / len(outcomes)
avg_latency = sum(r("latency_s") for r in outcomes) / len(outcomes)

print(f"Outcomes : move@1 = {pass_at_1:.2%}  ({handed}/{len(outcomes)})")
print(f"Avg latency = {avg_latency:.1f}s")

# Convert outcomes to DataFrame for simpler inspection
df = pd.DataFrame(outcomes)
print(df(("task_id", "handed", "latency_s")).to_string(index=False))

# Print failed duties for debugging
print("n── Failures ──")
for _, row in df(~df("handed")).iterrows():
    print(f"n{'─'*60}")
    print(f"TASK: {row('task_id')}")
    print(row("code")(:400))  # Present first 400 chars of code

Ausgabe:

Großartig! Wir haben die Assessments erfolgreich durchgeführt und können auch die Latenz jedes einzelnen Assessments sehen. Öffnen wir LangSmith, um die Token-Nutzung, die Kosten und andere Particulars anzuzeigen.

Öffnen Sie LangSmith -> Gehen Sie zum Abschnitt „Tracing“ -> Öffnen Sie das DeepAgent-Projekt:

Dies wird nützlich sein, um unsere Ergebnisse mit dem neuen Agenten zu vergleichen, den wir erstellen werden.

Definieren eines neuen Agenten

from deepagents import create_deep_agent
from langchain.brokers.middleware import ModelCallLimitMiddleware
from langchain.chat_models import init_chat_model

SYSTEM_PROMPT = "coding-agent-3"
pulled = ls.pull_prompt(SYSTEM_PROMPT)
system_prompt = pulled.messages(0).immediate.template

# Construct the agent
base_model = init_chat_model("openai:gpt-5-mini")

new_agent = create_deep_agent(
    mannequin=base_model,
    system_prompt=system_prompt,
    middleware=(
        # Restrict mannequin calls to 2 per invocation
        ModelCallLimitMiddleware(
            run_limit=2,
            exit_behavior="finish",
        ),
    ),
)

def resolve(drawback: dict) -> str:
    consequence = new_agent.invoke(
        {"messages": ({"position": "consumer", "content material": drawback("immediate")})},
        config={
            "metadata": {
                "task_id": drawback("task_id"),
                "prompt_name": SYSTEM_PROMPT,
            }
        },
    )

    uncooked = consequence("messages")(-1).content material
    return extract_code(uncooked, drawback("immediate"))

Testen des neuen Agenten

import time
from human_eval.execution import check_correctness

N_PROBLEMS = 5
TIMEOUT = 5  # seconds per check case

outcomes = ()

for task_id in task_ids(:N_PROBLEMS):
    drawback = issues(task_id)
    t0 = time.time()
    
    # Resolve the issue utilizing the agent
    code = resolve(drawback)
    
    latency = time.time() - t0
    
    # Examine correctness of the generated code
    consequence = check_correctness(drawback, code, timeout=TIMEOUT)
    
    outcomes.append({
        "task_id": task_id,
        "handed": consequence("handed"),
        "latency_s": spherical(latency, 2),
        "code": code,
    })
    
    standing = "PASS" if consequence("handed") else "FAIL"
    print(f"{standing}  {task_id:30s}  {latency:.1f}s")

Wir können sehen, dass unser Immediate-3 vier Probleme bestanden hat, aber ein Codierungsproblem nicht lösen konnte.

Abschluss

Bedeutet das, dass unser Immediate-1 besser warfare? Die Antwort ist nicht so einfach: Wir müssen Go@1-Assessments mehrmals ausführen, um die Konsistenz des Agenten zu testen, und zwar mit einer Testgröße, die viel größer als 5 ist. Dies hilft uns, die durchschnittliche Latenz, die Kosten und den wichtigsten Faktor zu ermitteln: die Aufgabenzuverlässigkeit. Auch das Finden und Anschließen der richtigen Middleware kann dazu beitragen, dass das System unseren Anforderungen entspricht. Es sind Middlewares vorhanden, um die Fähigkeiten des Agenten zu erweitern und die Anzahl der Modellaufrufe, Toolaufrufe und vieles mehr zu steuern. Es ist wichtig, den Agenten zu bewerten, und LangSmith kann sicherlich bei der Rückverfolgbarkeit helfen, die Eingabeaufforderungen speichern und auch Fehler (falls vorhanden) des Agenten anzeigen. Es ist wichtig zu beachten, dass sich Immediate Engineering zwar auf das konzentriert EingangHarness Engineering konzentriert sich auf die Umfeld Und Einschränkungen.

Häufig gestellte Fragen

Leidenschaftlich für Technologie und Innovation, Absolvent des Vellore Institute of Expertise. Derzeit arbeite ich als Knowledge Science Trainee mit Schwerpunkt auf Knowledge Science. Großes Interesse an Deep Studying und generativer KI, begierig darauf, modernste Techniken zu erforschen, um komplexe Probleme zu lösen und wirkungsvolle Lösungen zu schaffen.