Freigeben über

Bewerten Sie Ihre KI-Agenten lokal mit dem Azure AI Evaluation SDK (Vorschau).

Von Bedeutung

Die in diesem Artikel markierten Elemente (Vorschau) sind aktuell als öffentliche Vorschau verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und sollte nicht für Produktionsworkloads verwendet werden. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

KI-Agents sind leistungsstarke Produktivitätsassistenten, um Workflows für geschäftliche Anforderungen zu erstellen. Sie bringen jedoch aufgrund ihrer komplexen Interaktionsmuster Herausforderungen für die Beobachtbarkeit mit sich. In diesem Artikel erfahren Sie, wie Sie integrierte Auswertungen lokal auf einfachen Agentdaten oder Agentnachrichten ausführen.

Um produktionsfähige agentische Anwendungen zu erstellen und Observability und Transparenz zu ermöglichen, benötigen Entwickler Tools, um nicht nur die endgültige Ausgabe der Workflows eines Agenten, sondern die Qualität und Effizienz der Workflows selbst zu bewerten. Betrachten Sie z. B. einen typischen agentischen Workflow:

Animation des Workflows des Agenten von der Benutzerabfrage über die Absichtsauflösung und die Toolaufrufe bis zur endgültigen Antwort.

Ein Ereignis wie eine Benutzerabfrage "Wetter morgen" löst einen agentischen Workflow aus. Es beginnt mit der Ausführung mehrerer Schritte, wie das Durchdenken von Benutzerabsichten, das Aufrufen von Tools und die Nutzung von Retrieval Augmented Generation, um eine endgültige Antwort zu erzeugen. In diesem Prozess ist die Bewertung der einzelnen Schritte des Workflows – zusammen mit der Qualität und Sicherheit der endgültigen Ausgabe – von entscheidender Bedeutung. Insbesondere formulieren wir diese Bewertungsaspekte in die folgenden Bewerter für Agenten:

  • Absichtsauflösung: Misst, ob der Agent die Absicht der benutzenden Person korrekt identifiziert.
  • Toolaufrufgenauigkeit: Misst, ob der Agent das richtige Funktionstool aufruft, um die Anforderung einer benutzenden Person aufzurufen.
  • Einhaltung der Aufgabe: Misst, ob die endgültige Antwort des Agenten den zugewiesenen Aufgaben gemäß seiner Systemnachricht und den vorherigen Schritten entspricht.

Sie können auch andere Qualitäts- und Sicherheitsaspekte Ihrer agentischen Workflows bewerten, indem Sie unsere umfassende Suite von integrierten Bewertern verwenden. Im Allgemeinen emittieren Agenten Agentnachrichten. Das Transformieren von Agentnachrichten in die richtigen Auswertungsdaten zur Verwendung unserer Evaluatoren kann eine nichttrivielle Aufgabe sein. Wenn Sie Ihren Agent mithilfe des Azure AI Agent Service erstellen, können Sie ihn nahtlos über unseren Konvertersupport auswerten. Wenn Sie Ihren Agent außerhalb des Azure AI-Agent-Diensts erstellen, können Sie unsere Auswertungen weiterhin entsprechend Ihrem agentischen Workflow verwenden, indem Sie Ihre Agentnachrichten in die erforderlichen Datenformate analysieren. Siehe Beispiele für die Auswertung anderer Agenten.

Erste Schritte

Installieren Sie zuerst das Auswertungspaket aus dem Azure KI Evaluation SDK:

pip install azure-ai-evaluation

Bewerten Sie Azure AI-Agenten

Wenn Sie jedoch azure AI Agent Service verwenden, können Sie Ihre Agents nahtlos über unsere Konverterunterstützung für Azure AI-Agent-Threads und -Ausführungen auswerten. Wir unterstützen diese Liste der Evaluatoren für Azure AI-Agent-Nachrichten aus unserem Konverter:

  • Qualität: IntentResolution, ToolCallAccuracy, TaskAdherence, Relevance, Coherence, Fluency
  • Sicherheit: CodeVulnerabilities, Violence, Self-harm, Sexual, HateUnfairness, IndirectAttack, ProtectedMaterials.

Hinweis

ToolCallAccuracyEvaluator unterstützt nur die Funktionstool-Auswertung des Azure AI-Agents, unterstützt aber keine integrierte Toolauswertung. Die Agentnachrichten müssen mindestens ein Funktionstool aufweisen, das tatsächlich zur Auswertung aufgerufen wird.

Hier sehen Sie ein Beispiel, um einen Azure AI-Agent nahtlos zu erstellen und auszuwerten. Unabhängig von der Bewertung erfordert der Azure AI Foundry Agent Service pip install azure-ai-projects azure-identity, eine Verbindungskette zum Azure AI-Projekt und die unterstützten Modelle.

Erstellen von Agent-Threads und -Ausführungen

import os, json
import pandas as pd
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from typing import Set, Callable, Any
from azure.ai.projects.models import FunctionTool, ToolSet

from dotenv import load_dotenv

load_dotenv()

# Define some 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.
    # Here, we'll 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,
}

# Adding Tools to be used by Agent 
functions = FunctionTool(user_functions)

toolset = ToolSet()
toolset.add(functions)


# Create the agent
AGENT_NAME = "Seattle Tourist Assistant"

project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"],
)

agent = project_client.agents.create_agent(
    model=os.environ["MODEL_DEPLOYMENT_NAME"],
    name=AGENT_NAME,
    instructions="You are a helpful assistant",
    toolset=toolset,
)
print(f"Created agent, ID: {agent.id}")

thread = project_client.agents.create_thread()
print(f"Created thread, ID: {thread.id}")

# Create message to thread
MESSAGE = "Can you fetch me the weather in Seattle?"

message = project_client.agents.create_message(
    thread_id=thread.id,
    role="user",
    content=MESSAGE,
)
print(f"Created message, ID: {message.id}")

run = project_client.agents.create_and_process_run(thread_id=thread.id, agent_id=agent.id)

print(f"Run finished with status: {run.status}")

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

print(f"Run ID: {run.id}")

# display messages
for message in project_client.agents.list_messages(thread.id, order="asc").data:
    print(f"Role: {message.role}")
    print(f"Content: {message.content[0].text.value}")
    print("-" * 40)

Auswerten einer einzelnen Agent-Ausführung

Sobald die Agentenläufe erstellt sind, können Sie unseren Konverter ganz einfach verwenden, um die Daten der Azure AI-Agent-Threads in die erforderlichen Auswertungsdaten zu transformieren, die die Evaluatoren verstehen können.

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

# Initialize the converter for Azure AI 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)

Und das ist es! Sie müssen die Eingabeanforderungen für jeden Evaluator nicht lesen und alle Schritte ausführen, um sie zu analysieren. Sie müssen lediglich Ihren Evaluator auswählen und den Evaluator in dieser einzelnen Ausführung aufrufen. Für die Modellauswahl empfehlen wir ein starkes Begründungsmodell wie o3-mini und Modelle, die danach veröffentlicht wurden. Wir richten eine Liste der Qualitäts- und Sicherheitsbewertung in quality_evaluators und safety_evaluators ein und verweisen darauf in Auswertung mehrerer Agent-Ausführungen oder eines Threads.

# specific to agentic workflows
from azure.ai.evaluation import IntentResolutionEvaluator, TaskAdherenceEvaluator, ToolCallAccuracyEvaluator 
# other quality as well as risk and safety metrics
from azure.ai.evaluation import RelevanceEvaluator, CoherenceEvaluator, CodeVulnerabilityEvaluator, ContentSafetyEvaluator, IndirectAttackEvaluator, FluencyEvaluator
from azure.ai.projects.models import ConnectionType
from azure.identity import DefaultAzureCredential

import os
from dotenv import load_dotenv
load_dotenv()

model_config = project_client.connections.get_default(
                                            connection_type=ConnectionType.AZURE_OPEN_AI,
                                            include_credentials=True) \
                                         .to_evaluator_model_config(
                                            deployment_name="o3-mini",
                                            api_version="2023-05-15",
                                            include_credentials=True
                                          )

quality_evaluators = {evaluator.__name__: evaluator(model_config=model_config) for evaluator in [IntentResolutionEvaluator, TaskAdherenceEvaluator, ToolCallAccuracyEvaluator, CoherenceEvaluator, FluencyEvaluator, RelevanceEvaluator]}


## Using Azure AI Foundry Hub
azure_ai_project = {
    "subscription_id": os.environ.get("AZURE_SUBSCRIPTION_ID"),
    "resource_group_name": os.environ.get("AZURE_RESOURCE_GROUP"),
    "project_name": os.environ.get("AZURE_PROJECT_NAME"),
}
## Using Azure AI Foundry Development Platform, 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():
   try:
      result = evaluator(**converted_data)
      print(name)
      print(json.dumps(result, indent=4)) 
   except:
      print("Note: if there is no tool call to evaluate in the run history, ToolCallAccuracyEvaluator will raise an error")
      pass

Ausgabeformat

Das Ergebnis der KI-unterstützten Qualitätsbewertungen für ein Abfrage- und Antwortpaar ist ein Wörterbuch mit:

  • {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.

Um die Verständlichkeit weiter zu verbessern, akzeptieren alle Bewerter einen binären Schwellenwert (es sei denn, sie geben bereits binäre Ausgaben aus) und geben zwei neue Schlüssel aus. Für den Binarisierungsschwellenwert wird ein Standardwert festgelegt, und der Benutzer kann ihn überschreiben. 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.
  • additional_details enthält Debuginformationen zur Qualität eines einzelnen Agentenlaufs.

Beispielausgabe für einige Bewertende:

{
    "intent_resolution": 5.0, # likert scale: 1-5 integer 
    "intent_resolution_result": "pass", # pass because 5 > 3 the threshold
    "intent_resolution_threshold": 3,
    "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.",
    "additional_details": {
        "conversation_has_intent": true,
        "agent_perceived_intent": "fetch the weather in Seattle",
        "actual_user_intent": "fetch the weather in Seattle",
        "correct_intent_detected": true,
        "intent_resolved": true
    }
}
{
    "task_adherence": 5.0, # likert scale: 1-5 integer 
    "task_adherence_result": "pass", # pass because 5 > 3 the threshold
    "task_adherence_threshold": 3,
    "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": 1.0,  # this is the average of all correct tool calls (or passing rate) 
    "tool_call_accuracy_result": "pass", # pass because 1.0 > 0.8 the threshold
    "tool_call_accuracy_threshold": 0.8,
    "per_tool_call_details": [
        {
            "tool_call_accurate": true,
            "tool_call_accurate_reason": "The tool call is directly relevant to the user's query, uses the correct parameter, and the parameter value is correctly extracted from the conversation.",
            "tool_call_id": "call_2svVc9rNxMT9F50DuEf1XExx"
        }
    ]
}

Auswerten mehrerer Agent-Ausführungen oder -Threads

Um mehrere Agentausführungen oder Threads auszuwerten, empfehlen wir die Verwendung der Batch-API evaluate() für die asynchrone Auswertung. Konvertieren Sie zunächst Ihre Agentthreaddaten über unseren Konvertersupport in eine Datei:

import json
from azure.ai.evaluation import AIAgentConverter

# Initialize the converter
converter = AIAgentConverter(project_client)

# Specify a file path to save agent output (which is evaluation input data)
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}")

Mit den in einer Codezeile vorbereiteten Auswertungsdaten können Sie die Evaluatoren auswählen, um die Qualität der Agenten zu bewerten und einen Batch-Bewertungslauf zu starten. Hier beziehen wir uns auf dieselbe Liste von Qualitäts- und Sicherheitsbewertungen im Abschnitt Bewerten einer einzigen Agentenausführungquality_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 Azure AI Foundry project for rich visualization 
    azure_ai_project={
        "subscription_id": os.environ["AZURE_SUBSCRIPTION_ID"],
        "project_name": os.environ["PROJECT_NAME"],
        "resource_group_name": os.environ["RESOURCE_GROUP_NAME"],
    }
)
# Inspect the average scores at a high-level
print(response["metrics"])
# Use the URL to inspect the results on the UI
print(f'AI Foundary URL: {response.get("studio_url")}')

Nach dem URI werden Sie zu Foundry umgeleitet, um Ihre Auswertungsergebnisse in Ihrem Azure AI-Projekt anzuzeigen und Ihre Anwendung zu debuggen. Mithilfe von Begründungsfeldern und der Angabe „Bestanden“/„Nicht Bestanden“ können Sie die Leistung im Hinblick auf Qualität und Sicherheit Ihrer Anwendungen einfach bewerten. Sie können mehrere Läufe ausführen und vergleichen, um Regressionen oder Verbesserungen zu testen.

Mit der Clientbibliothek des Azure AI Evaluation SDK können Sie Ihre Azure AI-Agents nahtlos über die Unterstützung unseres Konverters auswerten, wodurch Transparenz und Nachvollziehbarkeit in agentenbezogenen Workflows ermöglicht werden.

Auswerten anderer Agents

Für Agents außerhalb des Azure AI Foundry Agent Service können Sie sie trotzdem auswerten, indem Sie die richtigen Daten für die Auswertungen Ihrer Wahl vorbereiten.

Agents geben in der Regel Nachrichten aus, um mit einem Benutzer oder anderen Agents zu interagieren. Unsere integrierten Bewertungen können einfache Datentypen wie z. B. Zeichenfolgen in query, response, ground_truth gemäß den Anforderungen an einteilige Dateneingabe akzeptieren. Es kann jedoch eine Herausforderung sein, diese einfachen Daten aus Agentnachrichten zu extrahieren, aufgrund der komplexen Interaktionsmuster von Agenten und Unterschiede im Framework. Beispielsweise kann eine einzelne Benutzerabfrage eine lange Liste von Agentnachrichten auslösen, in der Regel mit mehreren aufgerufenen Toolaufrufen.

Wie im Beispiel veranschaulicht, haben wir die Unterstützung von Agentnachrichten speziell für diese integrierten Evaluatoren IntentResolutionaktiviert, ToolCallAccuracyTaskAdherence um diese Aspekte des agentischen Workflows zu bewerten. Diese Auswertungen verwenden tool_calls oder tool_definitions als Parameter, die für Agents eindeutig sind.

Auswerter query response tool_calls tool_definitions
IntentResolutionEvaluator Erforderlich: Union[str, list[Message]] Erforderlich: Union[str, list[Message]] Nicht verfügbar Wahlfrei: list[ToolCall]
ToolCallAccuracyEvaluator Erforderlich: Union[str, list[Message]] Wahlfrei: Union[str, list[Message]] Wahlfrei: Union[dict, list[ToolCall]] Erforderlich: list[ToolDefinition]
TaskAdherenceEvaluator Erforderlich: Union[str, list[Message]] Erforderlich: Union[str, list[Message]] Nicht verfügbar Wahlfrei: list[ToolCall]
  • Message: dict Openai-Art-Nachricht, die Agentinteraktionen mit einem Benutzer beschreibt, wobei query eine Systemnachricht als erste Nachricht enthalten muss.
  • ToolCall: dict Angeben von Toolaufrufen, die während agent-Interaktionen mit einem Benutzer aufgerufen werden.
  • ToolDefinition: dict Das Beschreiben der Tools, die einem Agenten zur Verfügung stehen.

Für ToolCallAccuracyEvaluator muss entweder response oder tool_calls bereitgestellt werden.

Wir veranschaulichen einige Beispiele für die beiden Datenformate: einfache Agentdaten und Agentnachrichten. Aufgrund der eindeutigen Anforderungen dieser Bewerter empfehlen wir jedoch, auf die Beispielnotizbücher zu verweisen, die die möglichen Eingabepfade für jeden Evaluator veranschaulichen.

Wie bei anderen integrierten KI-unterstützten Qualitätsbewertungen werden und IntentResolutionEvaluator mit einer Likert-Bewertung ausgegeben (Ganzzahl zwischen 1 und 5; höhere Punktzahl ist besser). ToolCallAccuracyEvaluator gibt die Erfolgsrate aller Toolaufrufe (eine Gleitkommazahl zwischen 0 und 1) auf Grundlage der Benutzeranfrage aus. Um die Verständlichkeit weiter zu verbessern, akzeptieren alle Bewerter einen binären Schwellenwert und geben zwei neue Schlüssel aus. Für den Binarisierungsschwellenwert wird ein Standardwert festgelegt, und der Benutzer kann ihn überschreiben. 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.

Einfache Agentdaten

Im einfachen Agent-Datenformat query und response handelt es sich um einfache Python-Zeichenfolgen. 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)

# Evaluating query and response as strings
# 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))

Ausgabe (details finden Sie im Ausgabeformat ):

{
    "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.",
    "additional_details": {
        "conversation_has_intent": true,
        "agent_perceived_intent": "inquire about the opening hours of the Eiffel Tower",
        "actual_user_intent": "inquire about the opening hours of the Eiffel Tower",
        "correct_intent_detected": true,
        "intent_resolved": true
    }
}

Beispiele für tool_calls und tool_definitions für ToolCallAccuracyEvaluator:

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."
                            }
                        }
                    }
                }]
response = tool_call_accuracy(query=query, tool_calls=tool_calls, tool_definitions=tool_definitions)
print(json.dumps(response, indent=4))

Ausgabe (details finden Sie im Ausgabeformat ):

{
    "tool_call_accuracy": 0.5,
    "tool_call_accuracy_result": "fail",
    "tool_call_accuracy_threshold": 0.8,
    "per_tool_call_details": [
        {
            "tool_call_accurate": true,
            "tool_call_accurate_reason": "The TOOL CALL is directly relevant to the user's query, uses appropriate parameters, and the parameter values are correctly extracted from the conversation. It is likely to provide useful information to advance the conversation.",
            "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ"
        },
        {
            "tool_call_accurate": false,
            "tool_call_accurate_reason": "The TOOL CALL is not relevant to the user's query about the weather in Seattle and uses a parameter value that is not present or inferred from the conversation.",
            "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ"
        }
    ]
}

Agentnachrichten

Im Agent-Nachrichtenformat sind query und response eine Liste von sogenannten OpenAI-Nachrichten. query umfasst insbesondere die vergangenen Agent-Benutzerinteraktionen bis zur letzten Benutzeranfrage und setzt die Systemnachricht (des Agents) an den Anfang der Liste; und response enthält die letzte Nachricht des Agents als Antwort auf die letzte Benutzeranfrage. Beispiel:

import json

# user asked a question
query = [
    {
        "role": "system",
        "content": "You are a friendly and helpful customer service agent."
    },
    # past interactions 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 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 omitted 
    # ...
]

result = intent_resolution_evaluator(
    query=query,
    response=response,
    # optionally provide the tool definitions
    tool_definitions=tool_definitions 
)
print(json.dumps(result, indent=4))

Ausgabe (details finden Sie im Ausgabeformat ):

{
    "tool_call_accuracy": 0.5,
    "tool_call_accuracy_result": "fail",
    "tool_call_accuracy_threshold": 0.8,
    "per_tool_call_details": [
        {
            "tool_call_accurate": true,
            "tool_call_accurate_reason": "The TOOL CALL is directly relevant to the user's query, uses appropriate parameters, and the parameter values are correctly extracted from the conversation. It is likely to provide useful information to advance the conversation.",
            "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ"
        },
        {
            "tool_call_accurate": false,
            "tool_call_accurate_reason": "The TOOL CALL is not relevant to the user's query about the weather in Seattle and uses a parameter value that is not present or inferred from the conversation.",
            "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ"
        }
    ]
}

Dieses Auswertungsschema hilft Ihnen, Ihre Agentdaten außerhalb des Azure AI Foundry Agent Service zu analysieren, damit Sie unsere Auswertungen verwenden können, um die Observierbarkeit in Ihren agentischen Workflows zu unterstützen.

Beispiel-Notebooks

Jetzt sind Sie bereit, ein Beispiel für jede dieser Bewertungen auszuprobieren.

Verwandte Inhalte