Bewerten Sie Ihre KI-Agenten (Vorschau) (klassisch)

Gilt nur für:klassisches Foundry Portal. Dieser Artikel ist für das neue Foundry-Portal nicht verfügbar. Erfahren Sie mehr über das neue Portal.

KI-Agents sind leistungsstarke Produktivitätsassistenten, die Workflows für geschäftliche Anforderungen erstellen. Die Beobachtbarkeit ist jedoch aufgrund ihrer komplexen Interaktionsmuster eine Herausforderung. In diesem Artikel erfahren Sie, wie Sie Microsoft Foundry Agents oder andere Agents mit integrierten Bewertern auswerten.

Um produktionsreife agentische Anwendungen zu entwickeln und hierbei Transparenz und Beobachtbarkeit sicherzustellen, benötigen Entwickler Tools, um nicht nur die endgültigen Ergebnisse der Workflows eines Agenten, sondern auch die Qualität und Effizienz der Workflows zu bewerten.

Ein Ereignis wie ein Benutzer, der "Wetter morgen" abfragt, löst einen agentischen Workflow aus. Um eine endgültige Antwort zu erstellen, umfasst der Workflow die Verarbeitung von Benutzerabsichten, das Aufrufen von Tools und die Verwendung der abrufverstärkten Generierung.

In diesem Prozess ist die Bewertung der einzelnen Schritte des Workflows sowie die Qualität und Sicherheit der endgültigen Ausgabe von entscheidender Bedeutung. Diese Bewertungsaspekte werden in die folgenden Bewerter für Agenten formuliert:

• Erkennung der Benutzerabsicht: Misst, ob der Agent die Absicht des Benutzers korrekt identifiziert.
• Genauigkeit des Werkzeugaufrufs: Misst, ob der Agent die richtigen Werkzeugaufrufe für die Anforderung eines Benutzers tätigt.
• Einhaltung der Aufgabe: Misst, ob die endgültige Antwort des Agenten den zugewiesenen Aufgaben gemäß seiner Systemnachricht und den vorherigen Schritten entspricht.

Bewerten Sie andere Qualitäts- und Sicherheitsaspekte Ihrer agentischen Workflows mithilfe der umfassenden Suite integrierter Bewerter. Im Allgemeinen senden Agenten Agentennachrichten. Das Transformieren von Agentnachrichten in die richtigen Auswertungsdaten für die Evaluatoren kann eine Herausforderung darstellen. Wenn Sie Ihren Agent mithilfe des Foundry Agent Service erstellen, können Sie ihn nahtlos über unseren Konvertersupport auswerten. Wenn Sie Ihren Agenten außerhalb des Foundry Agent Service erstellen, können Sie die Bewertungstools trotzdem entsprechend Ihrem agentischen Arbeitsablauf verwenden, indem Sie Ihre Agentnachrichten in die erforderlichen Datenformate analysieren. Beispiele für die Auswertung anderer Agenten.

Beginnen

Installieren Sie das Evaluators-Paket aus dem Azure AI Evaluation SDK:

pip install azure-ai-evaluation

Microsoft Foundry Agenten bewerten

Wenn Sie Foundry Agent Service verwenden, können Sie Ihre Agents nahtlos auswerten, indem Sie unseren Konvertersupport für Microsoft Foundry Agents und Semantischer Kernel Agents verwenden. Die folgenden Evaluatoren unterstützen die vom Konverter zurückgegebenen Auswertungsdaten: IntentResolution, ToolCallAccuracy, TaskAdherence, Relevance und Groundedness.

Modellunterstützung für KI-unterstützte Bewerter

AzureOpenAI- und OpenAI-Begründungsmodelle und Nicht-Begründungsmodelle unterstützen den LLM-Evaluator abhängig von den Evaluatoren.

Verwenden Sie für eine komplexe Auswertung, die verfeinertes Denken erfordert, ein starkes Begründungsmodell wie 4.1-mini für eine ausgewogene Kombination von Leistungs- und Kosteneffizienz.

Unterstützung der Toolanrufeauswertung

ToolCallAccuracyEvaluator unterstützt die Auswertung in Microsoft Foundry Agent für die folgenden Tools:

• Dateisuche
• Azure KI-Suche
• Bing-Verankerung
• Benutzerdefinierte Bing-Suche
• SharePoint Grundlagen
• Codedolmetscher
• Fabric Data-Agenten
• OpenAPI
• Funktionstool (benutzerdefinierte Tools)

Wenn Sie jedoch ein nicht unterstütztes Tool im Agentenlauf verwenden, wird ein 'Pass' ausgegeben und ein Grund genannt, warum die Auswertung der aufgerufenen Tools nicht unterstützt wird, um diese Fälle leichter herauszufiltern. Um die Auswertung zu aktivieren, schließen Sie nicht unterstützte Tools als benutzerdefinierte Tools ein.

In diesem Beispiel wird gezeigt, wie Sie einen Microsoft Foundry-Agent erstellen und auswerten. Unabhängig von der Auswertung benötigt der Foundry Agent Service pip install azure-ai-projects azure-identity, eine Foundry-Projekt-Verbindungszeichenfolge und die unterstützten Modelle.

Erstellen von Agentthreads und -ausführung

Agents können Tools verwenden. Hier sehen Sie ein Beispiel für das Erstellen von benutzerdefinierten Tools für den Agenten, indem eine simulierte Wetterfunktion beispielsweise verwendet wird:

from azure.ai.projects.models import FunctionTool, ToolSet
from typing import Set, Callable, Any
import json

# Define a custom Python function.
def fetch_weather(location: str) -> str:
    """
    Fetches the weather information for the specified location.

    :param location (str): The location to fetch weather for.
    :return: Weather information as a JSON string.
    :rtype: str
    """
    # In a real-world scenario, you'd integrate with a weather API.
    # In the following code snippet, we mock the response.
    mock_weather_data = {"Seattle": "Sunny, 25°C", "London": "Cloudy, 18°C", "Tokyo": "Rainy, 22°C"}
    weather = mock_weather_data.get(location, "Weather data not available for this location.")
    weather_json = json.dumps({"weather": weather})
    return weather_json

user_functions: Set[Callable[..., Any]] = {
    fetch_weather,
}

# Add tools that the agent will use. 
functions = FunctionTool(user_functions)

toolset = ToolSet()
toolset.add(functions)

AGENT_NAME = "Seattle Tourist Assistant"

Wenn Sie ein Foundry-Projekt (non-Hub) verwenden, erstellen Sie einen Agent mit dem Toolset wie folgt:

Erstellen Sie einen Agent mit dem Toolset wie folgt:

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

# Create an Azure AI Client from an endpoint, copied from your Foundry project.
# You need to login to Azure subscription via Azure CLI and set the environment variables
# Foundry project endpoint, example: AZURE_AI_PROJECT=https://your-account.services.ai.azure.com/api/projects/your-project
project_endpoint = os.environ["AZURE_AI_PROJECT"]  # Ensure the PROJECT_ENDPOINT environment variable is set

# Create an AIProjectClient instance
project_client = AIProjectClient(
    endpoint=project_endpoint,
    credential=DefaultAzureCredential(),  # Use Azure Default Credential for authentication
)

# Create an agent with the toolset 
agent = project_client.agents.create_agent(
    model=os.environ["MODEL_DEPLOYMENT_NAME"],  # Model deployment name
    name="my-agent",  # Name of the agent
    instructions="You are a helpful agent",  # Instructions for the agent
    toolset=toolset
)
print(f"Created agent, ID: {agent.id}")

# Create a thread for communication
thread = project_client.agents.threads.create()
print(f"Created thread, ID: {thread.id}")

# Add a message to the thread
message = project_client.agents.messages.create(
    thread_id=thread.id,
    role="user",  # Role of the message sender
    content="What is the weather in Seattle today?",  # Message content
)
print(f"Created message, ID: {message.id}")

# Create and process an agent run
run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)
print(f"Run finished with status: {run.status}")

# Check if the run failed
if run.status == "failed":
    print(f"Run failed: {run.last_error}")

# Fetch and log all messages
messages = project_client.agents.messages.list(thread_id=thread.id)
for message in messages:
    print(f"Role: {message.role}, Content: {message.content}")
    

Auswerten einer einzelnen Agentausführung

Nachdem Sie Agentausführungen erstellt haben, verwenden Sie den Konverter, um die Threaddaten des Microsoft Foundry-Agents in die erforderlichen Auswertungsdaten zu transformieren, die von den Evaluatoren verstanden werden können.

import json, os
from azure.ai.evaluation import AIAgentConverter, IntentResolutionEvaluator

# Initialize the converter for Microsoft Foundry agents.
converter = AIAgentConverter(project_client)

# Specify the thread and run ID.
thread_id = thread.id
run_id = run.id

converted_data = converter.convert(thread_id, run_id)

Das wars! converted_data enthält alle Eingaben, die für diese Bewerter erforderlich sind. Sie müssen die Eingabeanforderungen für jeden Evaluator nicht lesen oder die Eingaben analysieren. Wählen Sie Ihren Evaluator aus und rufen Sie den Evaluator bei diesem einzelnen Durchlauf auf. Abhängig von den Evaluatoren unterstützen wir Azure OpenAI oder OpenAI reasoning models und Nicht-Reasoning-Modelle für die Bewertung:

Verwenden Sie bei komplexen Aufgaben, die eine verfeinerte Begründung für die Auswertung erfordern, ein starkes Begründungsmodell wie o3-mini oder die anschließend veröffentlichten o-Series-Minimodelle für eine ausgewogene Balance aus Leistungsfähigkeit in der Begründung und Kosteneffizienz.

Sie richten eine Liste der Qualitäts- und Sicherheitsbewertenden in quality_evaluators und safety_evaluators ein. Sie verweisen auf sie beim Auswerten mehrerer Agent-Läufe oder eines Threads.

# This is specific to agentic workflows.
from azure.ai.evaluation import IntentResolutionEvaluator, TaskAdherenceEvaluator, ToolCallAccuracyEvaluator 
# Other quality, risk, and safety metrics:
from azure.ai.evaluation import RelevanceEvaluator, CoherenceEvaluator, CodeVulnerabilityEvaluator, ContentSafetyEvaluator, IndirectAttackEvaluator, FluencyEvaluator
from azure.identity import DefaultAzureCredential

import os
from dotenv import load_dotenv
load_dotenv()

model_config = {
    "azure_deployment": os.getenv("AZURE_DEPLOYMENT_NAME"),
    "api_key": os.getenv("AZURE_OPENAI_API_KEY"),
    "azure_endpoint": os.getenv("AZURE_OPENAI_ENDPOINT"),
    "api_version": os.getenv("AZURE_API_VERSION"),
}

# example config for a reasoning model
reasoning_model_config = {
    "azure_deployment": "o4-mini",
    "api_key": os.getenv("AZURE_OPENAI_API_KEY"),
    "azure_endpoint": os.getenv("AZURE_OPENAI_ENDPOINT"),
    "api_version": os.getenv("AZURE_API_VERSION"),
}

# Evaluators you might want to use with reasoning models 
quality_evaluators = {evaluator.__name__: evaluator(model_config=reasoning_model_config, is_reasoning_model=True) for evaluator in [IntentResolutionEvaluator, TaskAdherenceEvaluator, ToolCallAccuracyEvaluator]}

# Other evaluators you might NOT want to use with reasoning models 
quality_evaluators.update({ evaluator.__name__: evaluator(model_config=model_config) for evaluator in [CoherenceEvaluator, FluencyEvaluator, RelevanceEvaluator]})

## Using Foundry (non-Hub) project endpoint, example: AZURE_AI_PROJECT=https://your-account.services.ai.azure.com/api/projects/your-project
azure_ai_project = os.environ.get("AZURE_AI_PROJECT")

safety_evaluators = {evaluator.__name__: evaluator(azure_ai_project=azure_ai_project, credential=DefaultAzureCredential()) for evaluator in [ContentSafetyEvaluator, IndirectAttackEvaluator, CodeVulnerabilityEvaluator]}

# Reference the quality and safety evaluator list above.
quality_and_safety_evaluators = {**quality_evaluators, **safety_evaluators}

for name, evaluator in quality_and_safety_evaluators.items():
    result = evaluator(**converted_data)
    print(name)
    print(json.dumps(result, indent=4)) 

Ausgabeformat

KI-unterstützte Qualitätsbewertungen geben ein Ergebnis für ein Abfrage- und Antwortpaar zurück. Das Ergebnis ist ein Wörterbuch, das Folgendes umfasst:

• {metric_name}: Stellt eine numerische Bewertung auf einer Likert-Skala (ganze Zahl 1 bis 5) oder einen Gleitkommawert zwischen 0 und 1 bereit.
• {metric_name}_label: Stellt eine binäre Beschriftung bereit, wenn die Metrik natürlich eine binäre Bewertung ausgibt.
• {metric_name}_reason: Erläutert, warum für jeden Datenpunkt eine bestimmte Bewertung oder Beschriftung angegeben wurde.
• details: Optionale Ausgabe mit Debug-Informationen zur Qualität eines einzelnen Agentendurchlaufs.

Um die Klarheit zu verbessern, akzeptieren alle Bewerter einen binären Schwellenwert (es sei denn, ihre Ausgaben sind bereits binär) und generieren zwei neue Schlüssel. Für den Binarisierungsschwellenwert wird eine Standardeinstellung festgelegt, die der Benutzer außer Kraft setzen kann. Die beiden neuen Schlüssel sind:

• {metric_name}_result: Eine "pass"- oder "fail"-Zeichenfolge basierend auf einem Binarisierungsschwellenwert.
• {metric_name}_threshold: Ein numerischer Binarisierungsschwellenwert, der standardmäßig oder vom Benutzer festgelegt wird.

Sehen Sie sich die folgende Beispielausgabe für einige Bewertungswerkzeuge an.

{
    "intent_resolution": 5.0, # likert scale: 1-5 integer 
    "intent_resolution_threshold": 3,
    "intent_resolution_result": "pass", # pass because 5 > 3 the threshold
    "intent_resolution_reason": "The assistant correctly understood the user's request to fetch the weather in Seattle. It used the appropriate tool to get the weather information and provided a clear and accurate response with the current weather conditions in Seattle. The response fully resolves the user's query with all necessary information."
}
{
    "task_adherence": 5.0, # likert scale: 1-5 integer 
    "task_adherence_threshold": 3,
    "task_adherence_result": "pass", # pass because 5 > 3 the threshold
    "task_adherence_reason": "The response accurately follows the instructions, fetches the correct weather information, and relays it back to the user without any errors or omissions."
}
{
    "tool_call_accuracy": 5,  # a score between 1-5, higher is better
    "tool_call_accuracy_threshold": 3,
    "tool_call_accuracy_result": "pass", # pass because 5 > 3 the threshold
    "details": { ... } # helpful details for debugging the tool calls made by the agent
}

Auswerten mehrerer Läufe oder Threads von Agenten

Verwenden Sie die Batch-API evaluate() für die asynchrone Auswertung, um mehrere Agentausführungen oder Threads auszuwerten. Konvertieren Sie zunächst Ihre Agentthreaddaten mithilfe der Konverterunterstützung in eine Datei:

import json
from azure.ai.evaluation import AIAgentConverter

# Initialize the converter.
converter = AIAgentConverter(project_client)

# Specify a file path to save the agent output (evaluation input data) to.
filename = os.path.join(os.getcwd(), "evaluation_input_data.jsonl")

evaluation_data = converter.prepare_evaluation_data(thread_ids=thread_id, filename=filename) 

print(f"Evaluation data saved to {filename}")

Indem Sie die Auswertungsdaten in einer Codezeile vorbereiten, können Sie die Evaluatoren auswählen, um die Agentqualität zu bewerten und einen Batchauswertungslauf zu übermitteln. Verweisen Sie im folgenden Beispiel auf dieselbe Liste der Qualitäts- und Sicherheitsevaluatoren im Abschnitt Bewerten eines einzelnen Agentendurchlaufsquality_and_safety_evaluators:

import os
from dotenv import load_dotenv
load_dotenv()

# Batch evaluation API (local):
from azure.ai.evaluation import evaluate

response = evaluate(
    data=filename,
    evaluation_name="agent demo - batch run",
    evaluators=quality_and_safety_evaluators,
    # optionally, log your results to your Foundry project for rich visualization 
    azure_ai_project=os.environ.get("AZURE_AI_PROJECT"),  # example: https://your-account.services.ai.azure.com/api/projects/your-project
)
# Inspect the average scores at a high level.
print(response["metrics"])
# Use the URL to inspect the results on the UI.
print(f'Foundry URL: {response.get("studio_url")}')

Nachdem Sie die URL ausgewählt haben, werden Sie zu Foundry umgeleitet. Zeigen Sie die Auswertungsergebnisse in Ihrem Foundry-Projekt an, und debuggen Sie Ihre Anwendung. Verwenden Sie Grundfelder und Pass-/Fail-Ergebnisse, um die Qualität und Sicherheitsleistung Ihrer Anwendungen zu bewerten. Sie können mehrere Läufe ausführen und vergleichen, um Regressionen oder Verbesserungen zu testen.

Verwenden Sie die Azure AI Evaluation SDK Client-Bibliothek, um Ihre Microsoft Foundry Agenten mit Konverterunterstützung auszuwerten und so die Beobachtbarkeit und Transparenz der Agent-Workflows zu ermöglichen.

Andere Agenten auswerten

Wenn Sie Agents außerhalb des Agentendiensts verwenden, können Sie diese weiterhin auswerten, indem Sie die richtigen Daten für die Auswertungen Ihrer Wahl vorbereiten.

Agents senden in der Regel Nachrichten, um mit einem Benutzer oder anderen Agents zu interagieren. Integrierte Auswerter akzeptieren einfache Datentypen wie Zeichenfolgen in query, response und ground_truth gemäß den Anforderungen an die Einzelvorgangsdateneingabe. Das Extrahieren dieser einfachen Datentypen aus Agentnachrichten kann jedoch aufgrund der komplexen Interaktionsmuster von Agents und Framework-Unterschieden schwierig sein. Beispielsweise kann eine einzelne Benutzerabfrage eine lange Liste von Agentnachrichten auslösen, in der Regel mit mehreren aufgerufenen Toolaufrufen.

Wie im folgenden Beispiel veranschaulicht, können Sie die Unterstützung von Agentnachrichten für die folgenden integrierten Auswertungen aktivieren, um diese Aspekte des agentischen Workflows auszuwerten. Diese Bewerter könnten tool_calls oder tool_definitions als agentenspezifische Parameter beim Bewerten von Agenten verwenden.

• Message: dict OpenAI-Formatnachricht, die Agentinteraktionen mit einem Benutzer beschreibt, wobei die query Systemnachricht als erste Nachricht enthalten muss.
• ToolCall: dict gibt Toolaufrufe an, die während agent-Interaktionen mit einem Benutzer aufgerufen werden.
• ToolDefinition: dict beschreibt die tools, die für einen Agent verfügbar sind.

Für ToolCallAccuracyEvaluator müssen Sie entweder response oder tool_calls angeben.

GroundednessEvaluator erfordert tool_definitions, die Fundierung der Antworten des Agenten im Hinblick auf die Werkzeugaussagen zu evaluieren, die der Agent erhält.

Die folgenden Beispiele zeigen die beiden Datenformate: einfache Agentdaten und Agentnachrichten. Aufgrund der eindeutigen Anforderungen dieser Bewerter beziehen Sie sich jedoch auf die Beispielnotizbücher, die die möglichen Eingabepfade für jeden Evaluator veranschaulichen.

Alle integrierten KI-unterstützten Qualitätsevaluatoren geben ein Bestehen oder Nichtbestehen für jede Eingabe aus.

Einfache Agentdaten

Im einfachen Agent-Datenformat sind query und response einfache Python Zeichenfolgen. Zum Beispiel:

import os
import json
from azure.ai.evaluation import AzureOpenAIModelConfiguration
from azure.identity import DefaultAzureCredential
from azure.ai.evaluation import IntentResolutionEvaluator, ResponseCompletenessEvaluator
  
model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    azure_deployment=os.environ["MODEL_DEPLOYMENT_NAME"],
)
 
intent_resolution_evaluator = IntentResolutionEvaluator(model_config)

# Evaluate the query and response as strings.
# The following is a positive example. Intent is identified and understood and the response correctly resolves user intent.
result = intent_resolution_evaluator(
    query="What are the opening hours of the Eiffel Tower?",
    response="Opening hours of the Eiffel Tower are 9:00 AM to 11:00 PM.",
)
print(json.dumps(result, indent=4))
 

Siehe die folgende Ausgabe (siehe Ausgabeformat für Details):

{
    "intent_resolution": 5.0,
    "intent_resolution_result": "pass",
    "intent_resolution_threshold": 3,
    "intent_resolution_reason": "The response provides the opening hours of the Eiffel Tower, which directly addresses the user's query. The information is clear, accurate, and complete, fully resolving the user's intent.",
}

Agenttoolaufrufe und -definitionen

Sehen Sie sich die folgenden Beispiele für tool_calls und tool_definitions bei ToolCallAccuracyEvaluator an:

import json 

query = "How is the weather in Seattle?"
tool_calls = [{
                    "type": "tool_call",
                    "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ",
                    "name": "fetch_weather",
                    "arguments": {
                        "location": "Seattle"
                    }
            },
            {
                    "type": "tool_call",
                    "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ",
                    "name": "fetch_weather",
                    "arguments": {
                        "location": "London"
                    }
            }]

tool_definitions = [{
                    "name": "fetch_weather",
                    "description": "Fetches the weather information for the specified location.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The location to fetch weather for."
                            }
                        }
                    }
                }]

from azure.ai.evaluation import ToolCallAccuracyEvaluator

tool_call_accuracy = ToolCallAccuracyEvaluator(model_config) # reuse the config defined above
response = tool_call_accuracy(query=query, tool_calls=tool_calls, tool_definitions=tool_definitions)
print(json.dumps(response, indent=4))

Sehen Sie sich die folgende Ausgabe an (siehe Ausgabeformat für Details):

{
    "tool_call_accuracy": 3,  # a score between 1-5, higher is better
    "tool_call_accuracy_result": "fail",
    "tool_call_accuracy_threshold": 4,
    "details": { ... } # helpful details for debugging the tool calls made by the agent
}

Agent-Nachrichtenschema

Im Agent-Nachrichtenformat query und response sind Listen von Nachrichten im Stil von OpenAI. Insbesondere überträgt query die vergangenen Agent-Benutzer-Interaktionen, die zur letzten Benutzeranfrage führen, und erfordert, dass die Systemnachricht (des Agents) an der Spitze der Liste steht. response enthält die letzte Nachricht des Agenten als Antwort auf die letzte Benutzerabfrage.

Das erwartete Eingabeformat für die Evaluatoren ist eine Python Liste der Nachrichten wie folgt:

[
  {
    "role": "system" | "user" | "assistant" | "tool",
    "createdAt": "ISO 8601 timestamp",     // Optional for 'system'
    "run_id": "string",                    // Optional, only for assistant/tool in tool call context
    "tool_call_id": "string",              // Optional, only for tool/tool_result
    "name": "string",                      // Present if it's a tool call
    "arguments": { ... },                  // Parameters passed to the tool (if tool call)
    "content": [
      {
        "type": "text" | "tool_call" | "tool_result",
        "text": "string",                  // if type == text
        "tool_call_id": "string",         // if type == tool_call
        "name": "string",                 // tool name if type == tool_call
        "arguments": { ... },             // tool args if type == tool_call
        "tool_result": { ... }            // result if type == tool_result
      }
    ]
  }
]

Beispielabfrage- und Antwortobjekte:

query = [
    {
        "role": "system",
        "content": "You are an AI assistant interacting with Azure Maps services to serve user requests."
    },
    {
        "createdAt": "2025-04-25T23:55:43Z",
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Find the address for coordinates 41.8781,-87.6298."
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:45Z",
        "run_id": "run_DGE8RWPS8A9SmfCg61waRx9u",
        "role": "assistant",
        "content": [
            {
                "type": "tool_call",
                "tool_call_id": "call_nqNyhOFRw4FmF50jaCCq2rDa",
                "name": "azure_maps_reverse_address_search",
                "arguments": {
                    "lat": "41.8781",
                    "lon": "-87.6298"
                }
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:47Z",
        "run_id": "run_DGE8RWPS8A9SmfCg61waRx9u",
        "tool_call_id": "call_nqNyhOFRw4FmF50jaCCq2rDa",
        "role": "tool",
        "content": [
            {
                "type": "tool_result",
                "tool_result": {
                    "address": "300 South Federal Street, Chicago, IL 60604",
                    "position": {
                        "lat": "41.8781",
                        "lon": "-87.6298"
                    }
                }
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:48Z",
        "run_id": "run_DGE8RWPS8A9SmfCg61waRx9u",
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The address for the coordinates 41.8781, -87.6298 is 300 South Federal Street, Chicago, IL 60604."
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:50Z",
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "What timezone corresponds to 41.8781,-87.6298?"
            }
        ]
    },
]

response = [
    {
        "createdAt": "2025-04-25T23:55:52Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "role": "assistant",
        "content": [
            {
                "type": "tool_call",
                "tool_call_id": "call_qi2ug31JqzDuLy7zF5uiMbGU",
                "name": "azure_maps_timezone",
                "arguments": {
                    "lat": 41.878100000000003,
                    "lon": -87.629800000000003
                }
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:54Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "tool_call_id": "call_qi2ug31JqzDuLy7zF5uiMbGU",
        "role": "tool",
        "content": [
            {
                "type": "tool_result",
                "tool_result": {
                    "ianaId": "America/Chicago",
                    "utcOffset": None,
                    "abbreviation": None,
                    "isDaylightSavingTime": None
                }
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:55Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The timezone for the coordinates 41.8781, -87.6298 is America/Chicago."
            }
        ]
    }
]

Ein Beispiel für die Auswertung von Agentnachrichten mithilfe von ToolCallAccuracyEvaluator finden Sie unter:

import json

# The user asked a question.
query = [
    {
        "role": "system",
        "content": "You are a friendly and helpful customer service agent."
    },
    # Past interactions are omitted. 
    # ...
    {
        "createdAt": "2025-03-14T06:14:20Z",
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Hi, I need help with the last 2 orders on my account #888. Could you please update me on their status?"
            }
        ]
    }
]
# The agent emits multiple messages to fulfill the request.
response = [
    {
        "createdAt": "2025-03-14T06:14:30Z",
        "run_id": "0",
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "Hello! Let me quickly look up your account details."
            }
        ]
    },
    {
        "createdAt": "2025-03-14T06:14:35Z",
        "run_id": "0",
        "role": "assistant",
        "content": [
            {
                "type": "tool_call",
                "tool_call_id": "tool_call_20250310_001",
                "name": "get_orders",
                "arguments": {
                    "account_number": "888"
                }
            }
        ]
    },
    # Many more messages are omitted. 
    # ...
    # Here is the agent's final response:
    {
        "createdAt": "2025-03-14T06:15:05Z",
        "run_id": "0",
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The order with ID 123 has been shipped and is expected to be delivered on March 15, 2025. However, the order with ID 124 is delayed and should now arrive by March 20, 2025. Is there anything else I can help you with?"
            }
        ]
    }
]

# An example of tool definitions available to the agent:
tool_definitions = [
    {
        "name": "get_orders",
        "description": "Get the list of orders for a given account number.",
        "parameters": {
            "type": "object",
            "properties": {
                "account_number": {
                    "type": "string",
                    "description": "The account number to get the orders for."
                }
            }
        }
    },
    # Other tool definitions are omitted. 
    # ...
]

result = tool_call_accuracy(
    query=query,
    response=response,
    tool_definitions=tool_definitions 
)
print(json.dumps(result, indent=4))

Weitere Informationen finden Sie in der folgenden Ausgabe ( Referenzausgabeformat ):

{
    "tool_call_accuracy": 2,  # a score between 1-5, higher is better
    "tool_call_accuracy_result": "fail",
    "tool_call_accuracy_threshold": 3,
    "details": { ... } # helpful details for debugging the tool calls made by the agent
}

Dieses Auswertungsschema hilft beim Analysieren von Agentdaten außerhalb des Agentdiensts und ermöglicht die Verwendung integrierter Auswertungen zur Unterstützung der Observierbarkeit in Agentworkflows.

Beispielnotizbücher

Probieren Sie ein Beispiel für jeden dieser Evaluatoren aus.

• Intent-Auflösung
• Genauigkeit des Toolaufrufs
• Aufgabentreue
• Vollständigkeit der Antwort
• End-to-End Microsoft Foundry-Agentenbewertung

Verwandte Inhalte

• Azure AI Evaluation Python SDK-Clientreferenzdokumentation
• Azure AI Evaluation SDK-Client-Problembehandlungshandbuch
• Informationen zu den Auswertungsmetriken
• Auswerten von generativen KI-Anwendungen remote in der Cloud
• Informationen zum Simulieren von Testdatensätzen für die Auswertung
• Anzeigen von Auswertungsergebnissen in einem Foundry-Projekt
• Get started building a chat app using the Microsoft Foundry SDK
• Erste Schritte mit Auswertungsbeispielen