Skip to content
Questa pagina non è ancora disponibile nella tua lingua. Viene mostrata la versione in inglese.

Agentische Annotation

KI-Agenten mit spezialisierten Trace-Anzeigen, 12 Formatkonvertern und zweckgebauten Annotationsschemata evaluieren.

Agentische Annotation

Neu in v2.3.0

KI-Agenten werden zunehmend für komplexe mehrstufige Aufgaben eingesetzt: Websuche, Code schreiben, APIs aufrufen und Unter-Agenten orchestrieren. Zu beurteilen, ob ein Agent tatsächlich das Richtige getan hat, erfordert jedoch menschliches Urteilsvermögen auf einer Granularitätsebene, die herkömmliche Annotationswerkzeuge nicht unterstützen können. Ein einzelner Agenten-Trace kann Dutzende von Schritten, Tool-Aufrufe, Zwischenüberlegungen, Screenshots und Verzweigungsentscheidungen enthalten. Annotatoren müssen all diesen Kontext sehen, effizient navigieren und strukturierte Evaluierungen sowohl auf Trace-Ebene als auch auf Einzelschrittebene liefern.

Potatos System für agentische Annotation adressiert dies mit drei Fähigkeiten:

  1. 12 Trace-Formatkonverter, die Agenten-Logs aus beliebigen gängigen Frameworks in ein einheitliches Format normalisieren
  2. 3 spezialisierte Anzeigetypen, optimiert für verschiedene Agenten-Modalitäten (Tool-Nutzung, Websuche, Chat)
  3. 9 vorgefertigte Annotationsschemata, die die häufigsten Evaluierungsdimensionen für Agenten abdecken

Trace-Formatkonverter

Agenten-Traces liegen je nach Framework in sehr unterschiedlichen Formaten vor. Potato liefert 12 Konverter, die diese in eine einheitliche interne Darstellung normalisieren. Sie geben den Konverter in Ihrer Konfiguration an oder lassen Potato das Format automatisch erkennen.

Konverter-Referenz

KonverterQuellformatExtrahierte Schlüsselfelder
openaiOpenAI Assistants API / Function-Calling-Logsmessages, tool_calls, function results
anthropicAnthropic Claude tool_use / Messages APIcontent blocks, tool_use, tool_result
swebenchSWE-bench-Aufgaben-Tracespatch, test results, trajectory
opentelemetryOpenTelemetry-Span-Exporte (JSON)spans, attributes, events, parent-child
mcpModel-Context-Protocol-Sitzungentool definitions, call/response pairs
multi_agentCrewAI / AutoGen / LangGraph Multi-Agent-Logsagent roles, delegation, message passing
langchainLangChain-Callback-Traceschain runs, LLM calls, tool invocations
langfuseLangFuse-Beobachtungsexportegenerations, spans, scores
reactReAct-Stil Thought/Action/Observation-Logsthought, action, action_input, observation
webarenaWebArena / VisualWebArena-Trace-JSONactions, screenshots, DOM snapshots, URLs
atifAgent Trace Interchange Format (ATIF)steps, observations, metadata
raw_webRohe Browser-Aufzeichnungen (HAR + Screenshots)requests, responses, screenshots, timings

Konfiguration

Geben Sie den Konverter in Ihrer Projektkonfiguration an:

yaml
agentic:
  enabled: true
  trace_converter: react
  trace_file: "data/agent_traces.jsonl"

Jede Zeile in der Trace-Datei sollte ein JSON-Objekt mit dem rohen Agenten-Trace sein. Der Konverter übernimmt den Rest.

Für Multi-Agent-Traces, bei denen verschiedene Agenten unterschiedliche Frameworks verwenden, können Sie Konverter pro Agent angeben:

yaml
agentic:
  enabled: true
  trace_converter: multi_agent
  trace_file: "data/multi_agent_traces.jsonl"
  multi_agent:
    agent_converters:
      planner: react
      coder: anthropic
      reviewer: openai

Automatische Erkennung

Wenn Sie sich nicht sicher sind, welchen Konverter Sie verwenden sollen, setzen Sie trace_converter: auto:

yaml
agentic:
  enabled: true
  trace_converter: auto
  trace_file: "data/traces.jsonl"

Potato analysiert die ersten 10 Traces und wählt den am besten passenden Konverter anhand von Feldsignaturen aus. Eine Warnung wird ausgegeben, wenn die Konfidenz unter 80 % liegt – in diesem Fall sollten Sie den Konverter explizit angeben.

Benutzerdefinierte Konverter

Wenn Ihr Agenten-Framework nicht aufgelistet ist, können Sie einen Python-Konverter schreiben:

python
# converters/my_converter.py
from potato.agentic.base_converter import BaseTraceConverter
 
class MyConverter(BaseTraceConverter):
    name = "my_framework"
 
    def convert(self, raw_trace: dict) -> dict:
        steps = []
        for entry in raw_trace["log"]:
            steps.append({
                "type": entry.get("kind", "action"),
                "content": entry["text"],
                "timestamp": entry.get("ts"),
                "metadata": entry.get("extra", {}),
            })
        return {"steps": steps}

In der Konfiguration registrieren:

yaml
agentic:
  trace_converter: custom
  custom_converter: "converters/my_converter.py:MyConverter"

Anzeigetypen

Sobald Traces konvertiert sind, rendert Potato sie mit einem von drei spezialisierten Anzeigetypen. Jeder ist für eine andere Agenten-Modalität optimiert.

1. Agent-Trace-Anzeige

Die Standardanzeige für Tool-nutzende Agenten (OpenAI Function Calling, Anthropic tool_use, ReAct, LangChain usw.). Jeder Schritt wird als Karte mit farblicher Codierung nach Schritttyp gerendert.

yaml
agentic:
  enabled: true
  trace_converter: openai
  display_type: agent_trace
 
  agent_trace_display:
    # Color coding for step types
    colors:
      thought: "#6E56CF"
      action: "#3b82f6"
      observation: "#22c55e"
      error: "#ef4444"
      system: "#6b7280"
 
    # Collapsible sections
    collapse_observations: true
    collapse_threshold: 500    # characters before auto-collapsing
 
    # Step numbering
    show_step_numbers: true
    show_timestamps: true
 
    # Tool call rendering
    render_json: true          # pretty-print JSON arguments
    syntax_highlight: true     # highlight code in observations

Funktionen:

  • Schrittkarten mit farbigem linken Rand zur Typkennzeichnung (Gedanke, Aktion, Beobachtung, Fehler)
  • Einklappbare Abschnitte für lange Beobachtungen oder Tool-Ausgaben (konfigurierbare Schwelle)
  • JSON-Formatierung für Tool-Aufruf-Argumente und strukturierte Antworten
  • Syntaxhervorhebung für Code-Blöcke in Beobachtungen
  • Schrittzeitleiste in der Seitenleiste für einen Überblick über den gesamten Trace
  • Springe-zu-Schritt-Navigation für lange Traces

2. Web-Agent-Trace-Anzeige

Speziell entwickelt für websuche-Agenten (WebArena, VisualWebArena, rohe Browser-Aufzeichnungen). Rendert Screenshots mit SVG-Overlays, die zeigen, wo der Agent geklickt, getippt oder gescrollt hat.

yaml
agentic:
  enabled: true
  trace_converter: webarena
  display_type: web_agent
 
  web_agent_display:
    # Screenshot rendering
    screenshot_max_width: 900
    screenshot_quality: 85
 
    # SVG overlay for agent actions
    overlay:
      enabled: true
      click_marker: "circle"       # circle, crosshair, or arrow
      click_color: "#ef4444"
      click_radius: 20
      type_highlight: "#3b82f6"    # highlight for text input fields
      scroll_indicator: true
 
    # Filmstrip view
    filmstrip:
      enabled: true
      thumbnail_width: 150
      show_action_labels: true
 
    # DOM snapshot display
    show_dom_snapshot: false        # optional raw DOM view
    show_url_bar: true
    show_action_description: true

Funktionen:

  • Screenshot-Galerie mit Vollansicht und Zoom
  • SVG-Overlays zeigen Klickziele (rote Kreise), Texteingabebereiche (blaue Markierungen) und Scrollrichtungen
  • Filmstreifen-Ansicht unten mit allen Screenshots als Vorschaubilder zur schnellen Navigation
  • Aktionsbeschreibung unter jedem Screenshot (z. B. "Klick auf Schaltfläche 'In den Warenkorb'")
  • URL-Leiste mit der aktuellen Seiten-URL bei jedem Schritt
  • Vorher/Nachher-Vergleich für Schritte, die den Seiteninhalt ändern

3. Interaktive Chat-Anzeige

Zur Evaluierung von Konversationsagenten und Chatbots. Unterstützt zwei Untermodi: Live-Chat, bei dem Annotatoren in Echtzeit mit dem Agenten interagieren, und Trace-Review, bei dem Annotatoren eine aufgezeichnete Konversation evaluieren.

yaml
agentic:
  enabled: true
  display_type: interactive_chat
 
  interactive_chat_display:
    mode: trace_review         # or "live_chat"
 
    # Trace review settings
    trace_review:
      show_system_prompt: false
      show_token_counts: true
      show_latency: true
      message_grouping: turn    # "turn" or "message"
 
    # Live chat settings (when mode: live_chat)
    live_chat:
      proxy: openai             # agent proxy to use
      max_turns: 20
      timeout_seconds: 60
      show_typing_indicator: true
      allow_regenerate: true
 
    # Common settings
    show_role_labels: true
    role_colors:
      user: "#3b82f6"
      assistant: "#6E56CF"
      system: "#6b7280"
      tool: "#22c55e"

Trace-Review-Modus rendert eine aufgezeichnete Konversation mit optionalen Token-Zählungen und Latenz pro Nachricht. Annotatoren können einzelne Turns oder die gesamte Konversation bewerten.

Live-Chat-Modus verbindet Annotatoren über das Agent-Proxy-System (siehe unten) mit einem laufenden Agenten. Annotatoren führen eine Konversation mit dem Agenten und annotieren dann das Ergebnis.


Bewertungen pro Turn

Für Dialog- und mehrstufige Evaluierungen benötigen Sie häufig Bewertungen für einzelne Turns anstatt (oder zusätzlich zu) dem gesamten Trace. Potato unterstützt Annotationen pro Turn für alle Anzeigetypen.

yaml
annotation_schemes:
  # Overall trace rating
  - annotation_type: likert
    name: overall_quality
    description: "Rate the overall quality of this agent trace"
    min: 1
    max: 5
    labels:
      1: "Very Poor"
      5: "Excellent"
 
  # Per-turn ratings
  - annotation_type: per_turn_rating
    name: step_correctness
    description: "Was this step correct?"
    target: agentic_steps        # binds to trace steps
    rating_type: radio
    labels:
      - "Correct"
      - "Partially Correct"
      - "Incorrect"
      - "Unnecessary"
 
  - annotation_type: per_turn_rating
    name: step_explanation
    description: "Explain any issues with this step"
    target: agentic_steps
    rating_type: text
    conditional:
      show_when:
        step_correctness: ["Partially Correct", "Incorrect", "Unnecessary"]

Bewertungen pro Turn erscheinen neben jeder Schrittkarte. Der conditional-Block ermöglicht die Anzeige von Folgefragen nur bei bestimmten Bewertungen, was die Benutzeroberfläche übersichtlich hält.

Ausgabeformat für Bewertungen pro Turn

Annotationen pro Turn werden mit Schrittindizes gespeichert:

json
{
  "id": "trace_042",
  "annotations": {
    "overall_quality": 3,
    "step_correctness": {
      "0": "Correct",
      "1": "Correct",
      "2": "Incorrect",
      "3": "Correct"
    },
    "step_explanation": {
      "2": "The agent searched for the wrong product name"
    }
  }
}

Agent-Proxy-System

Für Live-Evaluierungsaufgaben, bei denen Annotatoren in Echtzeit mit einem Agenten interagieren, bietet Potato eine Agent-Proxy-Schicht. Der Proxy sitzt zwischen der Annotationsoberfläche und dem Agenten-Backend und protokolliert die gesamte Konversation zur späteren Überprüfung.

yaml
agentic:
  enabled: true
  display_type: interactive_chat
 
  agent_proxy:
    type: openai                 # openai, http, or echo
 
    # OpenAI proxy
    openai:
      model: "gpt-4o"
      api_key: ${OPENAI_API_KEY}
      system_prompt: "You are a helpful customer service agent."
      temperature: 0.7
      max_tokens: 1024

Proxy-Typen

OpenAI-Proxy leitet Nachrichten an eine OpenAI-kompatible API weiter:

yaml
agent_proxy:
  type: openai
  openai:
    model: "gpt-4o"
    api_key: ${OPENAI_API_KEY}
    system_prompt: "You are a helpful assistant."
    temperature: 0.7

HTTP-Proxy leitet Nachrichten an einen beliebigen HTTP-Endpunkt weiter (Ihr eigener Agenten-Server):

yaml
agent_proxy:
  type: http
  http:
    url: "https://my-agent.example.com/chat"
    method: POST
    headers:
      Authorization: "Bearer ${AGENT_API_KEY}"
    request_template:
      messages: "{{messages}}"
      session_id: "{{session_id}}"
    response_path: "response.content"
    timeout_seconds: 30

Echo-Proxy spiegelt die Nachricht des Nutzers zurück (nützlich für Tests und UI-Entwicklung):

yaml
agent_proxy:
  type: echo
  echo:
    prefix: "[Echo] "
    delay_ms: 500

Vorgefertigte Annotationsschemata

Potato liefert 9 Annotationsschemata, die speziell für die Agentenevaluierung entwickelt wurden. Verwenden Sie sie direkt oder als Ausgangspunkt für eigene Schemata.

SchemaTypBeschreibung
agent_task_successradioBinäres Erfolg/Misserfolg mit Option für Teilerfolg
agent_step_correctnessper_turn_rating (radio)Bewertung korrekt/inkorrekt/unnötig pro Schritt
agent_error_taxonomyper_turn_rating (multiselect)12-Kategorien-Fehler-Taxonomie (falsches Tool, Halluzination, Schleife usw.)
agent_safetyradio + textErkennung von Sicherheitsverletzungen mit Schweregrad-Skala
agent_efficiencylikertBewertung, ob der Agent einen effizienten Weg gewählt hat
agent_instruction_followinglikertBewertung der Einhaltung der ursprünglichen Benutzeranweisung
agent_explanation_qualitylikertBewertung der Qualität von Agenten-Begründungen/Erklärungen
agent_web_action_correctnessper_turn_rating (radio)Web-Aktionsevaluierung pro Schritt (korrektes Ziel, korrekter Aktionstyp)
agent_conversation_qualitymultirateMehrdimensionale Chat-Qualität (Hilfsbereitschaft, Genauigkeit, Ton, Sicherheit)

Vorgefertigtes Schema nach Name laden:

yaml
annotation_schemes:
  - preset: agent_task_success
  - preset: agent_step_correctness
  - preset: agent_error_taxonomy

Oder Vorlagen mit eigenen Schemata kombinieren:

yaml
annotation_schemes:
  - preset: agent_task_success
  - preset: agent_step_correctness
 
  # Custom schema alongside presets
  - annotation_type: text
    name: evaluator_notes
    description: "Any additional observations about this agent trace"
    label_requirement:
      required: false

Vollständiges Beispiel: Evaluierung eines ReAct-Agenten

Vollständige Konfiguration zur Evaluierung von ReAct-Agenten-Traces mit Bewertungen pro Schritt:

yaml
# project config
task_name: "ReAct Agent Evaluation"
task_dir: "."
 
data_files:
  - "data/react_traces.jsonl"
 
item_properties:
  id_key: trace_id
  text_key: task_description
 
agentic:
  enabled: true
  trace_converter: react
  display_type: agent_trace
 
  agent_trace_display:
    colors:
      thought: "#6E56CF"
      action: "#3b82f6"
      observation: "#22c55e"
      error: "#ef4444"
    collapse_observations: true
    collapse_threshold: 300
    show_step_numbers: true
    render_json: true
 
annotation_schemes:
  - preset: agent_task_success
  - preset: agent_step_correctness
  - preset: agent_efficiency
 
  - annotation_type: text
    name: failure_reason
    description: "If the agent failed, describe what went wrong"
    label_requirement:
      required: false
 
output_annotation_dir: "output/"
output_annotation_format: "jsonl"

Beispiel-Eingabedaten (data/react_traces.jsonl):

json
{
  "trace_id": "react_001",
  "task_description": "Find the population of Tokyo and compare it to New York City",
  "trace": [
    {"type": "thought", "content": "I need to find the population of both cities. Let me search for Tokyo first."},
    {"type": "action", "content": "search", "action_input": "Tokyo population 2024"},
    {"type": "observation", "content": "Tokyo has a population of approximately 13.96 million in the city proper..."},
    {"type": "thought", "content": "Now I need to find New York City's population."},
    {"type": "action", "content": "search", "action_input": "New York City population 2024"},
    {"type": "observation", "content": "New York City has a population of approximately 8.34 million..."},
    {"type": "thought", "content": "Tokyo (13.96M) has about 67% more people than NYC (8.34M)."},
    {"type": "action", "content": "finish", "action_input": "Tokyo has ~13.96 million people vs NYC's ~8.34 million, making Tokyo about 67% larger by population."}
  ]
}

Server starten:

bash
potato start config.yaml -p 8000

Weiterführende Informationen

Implementierungsdetails finden Sie in der Quelldokumentation.