Utvärdera dina AI-agenter lokalt med Azure AI Evaluation SDK (förhandsversion)

AI-agenter är kraftfulla produktivitetsassistenter som kan skapa arbetsflöden för affärsbehov. Observerbarhet kan dock vara en utmaning på grund av deras komplexa interaktionsmönster. I den här artikeln får du lära dig hur du kör inbyggda utvärderare lokalt på enkla agentdata eller agentmeddelanden.

För att skapa produktionsklara agentprogram och möjliggöra observerbarhet och transparens behöver utvecklare verktyg för att utvärdera inte bara slututdata från en agents arbetsflöden, utan även själva arbetsflödenas kvalitet och effektivitet.

En händelse som en användare som frågar "väder i morgon" utlöser ett agentiskt arbetsflöde. För att skapa ett slutligt svar kör det agentdrivna arbetsflödet flera steg som omfattar resonemang kring användarens avsikter, användning av verktyg och hämtningsförstärkt generering. I den här processen är det viktigt att utvärdera varje steg i arbetsflödet och kvaliteten och säkerheten för de slutliga utdata. Vi formulerar dessa utvärderingsaspekter i följande utvärderare för agenter:

• Avsiktsmatchning: Mäter om agenten identifierar användarens avsikt korrekt.
• Noggrannhet för verktygsanrop: Mäter om agenten gjorde rätt funktionsverktygsanrop till en användares begäran.
• Uppgiftsefterlevnad: Mäter om agentens slutliga svar följer dess tilldelade uppgifter, enligt dess systemmeddelande och tidigare steg.

Du kan också utvärdera andra kvalitets- och säkerhetsaspekter i dina agentiska arbetsflöden med hjälp av vår omfattande uppsättning inbyggda utvärderare. I allmänhet skickar agenter ut agentmeddelanden. Att omvandla agentmeddelanden till rätt utvärderingsdata för våra utvärderare att använda kan vara en komplicerad uppgift. Om du skapar din agent med Hjälp av Foundry Agent Service kan du sömlöst utvärdera den via vårt konverterarstöd. Om du skapar din agent utanför Foundry Agent Service kan du fortfarande använda våra utvärderare efter behov för ditt agentiska arbetsflöde genom att parsa dina agentmeddelanden i de dataformat som krävs. Se exempel i Utvärdera andra agenter.

Kom igång

Installera utvärderingspaketet från Azure AI-utvärderings-SDK:n:

pip install azure-ai-evaluation

Utvärdera Azure AI-agenter

Om du använder Foundry Agent Service kan du sömlöst utvärdera dina agenter med hjälp av vårt konverterarstöd för Azure AI-agenter och semantiska kernelagenter. Följande utvärderare stöds för utvärderingsdata som returneras av konverteraren: IntentResolution, ToolCallAccuracy, TaskAdherence, Relevanceoch Groundedness.

Modellstöd för AI-assisterade utvärderare

Vi stöder AzureOpenAI- eller OpenAI-resonemangsmodeller och icke-resonemangsmodeller för LLM-domaren beroende på utvärderarna:

För komplex utvärdering som kräver förfinade resonemang rekommenderar vi en stark resonemangsmodell som 4.1-mini med en balans mellan resonemangsprestanda och kostnadseffektivitet.

Stöd för utvärdering av verktygsanrop

ToolCallAccuracyEvaluator stöder utvärdering i Azure AI Agent för följande verktyg:

• Filsökning
• Azure AI-sökning
• Grundläggning i Bing
• Anpassad Bing-sökning
• SharePoint Grundläggning
• Kodtolkare
• Infrastrukturdataagent
• OpenAPI
• Funktionsverktyg (användardefinierade verktyg)

Men om ett verktyg som inte stöds används i agentkörningen returnerar det ett "pass" och en orsak till att utvärdering av de anropade verktygen inte stöds, vilket underlättar filtreringen av dessa fall. Vi rekommenderar att du omsluter verktyg som inte stöds som användardefinierade verktyg för att aktivera utvärdering.

Här är ett exempel som visar hur du sömlöst skapar och utvärderar en Azure AI-agent. Separat från utvärderingen kräver pip install azure-ai-projects azure-identityAzure AI Foundry Agent Service , en Anslutningssträng för Azure AI-projekt och de modeller som stöds.

Skapa agenttrådar och -körningar

Agenter kan använda verktyget. Här är ett exempel på hur du skapar anpassade verktyg som du avser att agenten ska använda, med en mock väderfunktion som exempel.

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"

Om du använder Azure AI Foundry-projekt (icke-Hub) skapar du en agent med verktygsuppsättningen på följande sätt:

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 Azure AI Foundry project.
# You need to login to Azure subscription via Azure CLI and set the environment variables
# Azure AI 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}")
    

Utvärdera en enskild agentkörning

När du har skapat agentkörningar kan du enkelt använda konverteraren för att omvandla Azure AI-agentens tråddata till de utvärderingsdata som utvärderarna kan förstå.

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)

Och det är allt! converted_data innehåller alla indata som krävs för dessa utvärderare. Du behöver inte läsa indatakraven för varje utvärderare och utföra något arbete för att parsa indata. Allt du behöver göra är att välja utvärderaren och anropa utvärderaren på den här enkla körningen. Vi stöder AzureOpenAI- eller OpenAI-resonemangsmodeller och icke-resonemangsmodeller för domaren beroende på utvärderarna:

För komplexa uppgifter som kräver förfinade resonemang för utvärderingen rekommenderar vi en stark resonemangsmodell som eller o-seriens minimodeller som o3-mini släpps efteråt med en balans mellan resonemangsprestanda och kostnadseffektivitet.

Vi har konfigurerat en lista över kvalitets- och säkerhetsutvärderingar i quality_evaluators och safety_evaluators, och använder dem vid utvärdering av flera agentkörningar eller en tråd.

# 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_API_KEY"),
    "azure_endpoint": os.getenv("AZURE_ENDPOINT"),
    "api_version": os.getenv("AZURE_API_VERSION"),
}

# example config for a reasoning model
reasoning_model_config = {
    "azure_deployment": "o3-mini",
    "api_key": os.getenv("AZURE_API_KEY"),
    "azure_endpoint": os.getenv("AZURE_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 Azure AI 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)) 

Utdataformat

AI-assisterade kvalitetsutvärderingar levererar ett resultat för ett fråge- och svarspar. Resultatet är en ordlista som innehåller:

• {metric_name}: Ger en numerisk poäng, på en Likert-skala (heltal 1 till 5) eller en flyttal mellan 0 och 1.
• {metric_name}_label: Tillhandahåller en binär etikett (om måttet naturligt matar ut en binär poäng).
• {metric_name}_reason: Förklarar varför en viss poäng eller etikett angavs för varje datapunkt.
• details: Valfria utdata som innehåller felsökningsinformation om kvaliteten på en enda agentkörning.

För att ytterligare förbättra begripligheten accepterar alla utvärderare ett binärt tröskelvärde (såvida inte deras utdata redan är binära) och matar ut två nya nycklar. För tröskelvärdet för binarisering anges ett standardvärde som användaren kan åsidosätta. De två nya nycklarna är:

• {metric_name}_result: En "pass" eller "fail"-sträng baserat på ett tröskelvärde för binarisering.
• {metric_name}_threshold: Ett numeriskt tröskelvärde för binarisering som angetts som standard eller av användaren.

Se följande exempelutdata för vissa utvärderare:

{
    "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
}

Utvärdera flera agentkörningar eller trådar

För att utvärdera flera agentkörningar eller trådar rekommenderar vi att du använder batch-API evaluate() :et för asynkron utvärdering. Först konverterar du dina agenttrådsdata till en fil via vårt stöd för konverteraren:

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}")

Med utvärderingsdata som har förberetts i en kodrad kan du välja utvärderarna för att utvärdera agentkvaliteten och skicka en batchutvärderingskörning. I följande exempel refererar vi till samma lista över kvalitets- och säkerhetsutvärderare i avsnittet Utvärdera en enda agentkörningquality_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=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'AI Foundry URL: {response.get("studio_url")}')

Efter URL:en omdirigeras du till Foundry. Du kan visa dina utvärderingsresultat i ditt Azure AI-projekt och felsöka ditt program. Med hjälp av orsaksfält och pass/fail kan du enkelt utvärdera kvalitet och säkerhetsprestanda för dina program. Du kan köra och jämföra flera körningar för att testa regression eller förbättringar.

Med Azure AI Evaluation SDK-klientbiblioteket kan du sömlöst utvärdera dina Azure AI-agenter via vårt konverterarstöd, vilket möjliggör observerbarhet och transparens i agentiska arbetsflöden.

Utvärdera andra agenter

Om du använder agenter utanför Azure AI Foundry Agent Service kan du fortfarande utvärdera dem genom att förbereda rätt data för valfri utvärderare.

Agenter genererar vanligtvis meddelanden för att interagera med en användare eller andra agenter. Våra inbyggda utvärderare kan acceptera enkla datatyper, till exempel strängar i query, responseoch ground_truth enligt kraven för indata med en enda tur. Det kan dock vara en utmaning att extrahera dessa enkla datatyper från agentmeddelanden på grund av de komplexa interaktionsmönstren för agenter och ramverksskillnader. Till exempel kan en enskild användarfråga utlösa en lång lista med agentmeddelanden, vanligtvis med flera anrop som anropas.

Som vi ser i följande exempel aktiverar vi agentmeddelandestöd för följande inbyggda utvärderare för att utvärdera dessa aspekter av agentiskt arbetsflöde. Dessa utvärderare kan ta tool_calls eller tool_definitions som parametrar som är unika för agenter vid utvärdering av agenter.

• Message: dict OpenAI-liknande meddelande som beskriver agentinteraktioner med en användare, där query måste innehålla ett systemmeddelande som det första meddelandet.
• ToolCall: dict som anger verktygsanrop som anropas under agentinteraktioner med en användare.
• ToolDefinition: dict som beskriver de verktyg som är tillgängliga för en agent.

För ToolCallAccuracyEvaluatormåste antingen response eller tool_calls anges.

GroundednessEvaluator måste tool_definitions tillhandahållas för att utvärdera hur välgrundade agentens svar är med avseende på de verktygsutdata som agenten tar emot.

Här följer exempel på de två dataformaten: enkla agentdata och agentmeddelanden. Men på grund av de unika kraven för dessa utvärderare rekommenderar vi att du refererar till exempelanteckningsböckerna, som illustrerar möjliga indatasökvägar för varje utvärderare.

Precis som med andra inbyggda AI-assisterade kvalitetsutvärderingarIntentResolutionEvaluator och TaskAdherenceEvaluator utdata en Likert-poäng (heltal 1-5; högre poäng är bättre). ToolCallAccuracyEvaluator matar ut överföringshastigheten för alla verktygsanrop som görs (en flyttal mellan 0 och 1) baserat på användarfråga. För att ytterligare förbättra begripligheten accepterar alla utvärderare ett binärt tröskelvärde och matar ut två nya nycklar. För tröskelvärdet för binarisering anges ett standardvärde och användaren kan åsidosätta det. De två nya nycklarna är:

• {metric_name}_result: En "pass" eller "fail"-sträng baserat på ett tröskelvärde för binarisering.
• {metric_name}_threshold: Ett numeriskt tröskelvärde för binarisering som angetts som standard eller av användaren.

Enkla agentdata

I enkelt agentdataformat query och response är enkla Python-strängar. Till exempel:

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))
 

Se följande utdata (utforska Utdataläge för detaljer):

{
    "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.",
}

Anrop och definitioner för agentverktyg

Se följande exempel på tool_calls och 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."
                            }
                        }
                    }
                }]

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))

Se följande utdata (utforska Utdataläge för detaljer):

{
    "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
}

Agentmeddelandeschema

I agentmeddelandeformat query och response är en lista över OpenAI-meddelanden. query Innehåller tidigare interaktioner mellan agent och användare fram till den sista användarfrågan och placerar systemmeddelandet från agenten överst i listan, och response innehåller agentens sista meddelande som svar på den senaste användarfrågan.

Det förväntade indataformatet för utvärderarna är en Python-lista med meddelanden på följande sätt:

[
  {
    "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
      }
    ]
  }
]

Exempel på fråge- och svarsobjekt:

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."
            }
        ]
    }
]

Se ett exempel på utvärdering av agentmeddelandena med ToolCallAccuracyEvaluator:

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))

Se följande utdata (utforska Utdataläge för detaljer):

{
    "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
}

Det här utvärderingsschemat hjälper dig att parsa dina agentdata utanför Azure AI Foundry Agent Service, så att du kan använda våra utvärderare för att stödja observerbarhet i dina agentiska arbetsflöden.

Exempel på anteckningsböcker

Nu är du redo att prova ett exempel för var och en av dessa utvärderare:

• Avsiktslösning
• Anropsnoggrannhet för verktyg
• Uppgiftsefterlevnad
• Svars fullständighet
• Utvärdering av Azure AI-agenten från slutpunkt till slutpunkt

Relaterat innehåll

• Dokumentation om Python SDK-klientreferens för Azure AI-utvärdering
• Felsökningsguide för Azure AI Evaluation SDK-klienten
• Läs mer om utvärderingsmåtten
• Utvärdera dina generativa AI-applikationer på distans i molnet
• Läs mer om att simulera testdatauppsättningar för utvärdering
• Visa dina utvärderingsresultat i ett Azure AI-projekt
• Kom igång med att skapa en chattapp med hjälp av Azure AI Foundry SDK
• Kom igång med utvärderingsexempel