Avaliadores de agentes (prévia) (clássico)

Exibição no momento:Versão do portal - do Foundry (clássico)Alternar para a versão do novo portal do Foundry

Agentes são assistentes poderosos de produtividade. Eles planejam, tomam decisões e executam ações. Os agentes normalmente raciocinam com base nas intenções do usuário nas conversas, selecionam as ferramentas corretas para atender aos pedidos dos usuários e completam tarefas conforme as instruções. O Microsoft Foundry suporta esses avaliadores específicos de agentes para fluxos de trabalho agentes:

• Resolução de intenção (prévia)
• Precisão das chamadas de ferramenta (prévia)
• Adesão à tarefa (prévia)

Avaliando agentes de IA do Azure

Agentes emitem mensagens, e fornecer entradas normalmente requer a análise dessas mensagens para extrair informações relevantes. Se você está construindo agentes usando o Azure AI Agent Service, o serviço oferece integração nativa para avaliação que recebe diretamente as mensagens dos agentes. Para um exemplo, veja Avaliar agentes de IA.

Além de IntentResolution, ToolCallAccuracy, e TaskAdherence, que são específicos para fluxos de trabalho agentes, você pode avaliar outros aspectos de qualidade e segurança desses fluxos usando um conjunto abrangente de avaliadores embutidos. O Foundry suporta esta lista de avaliadores para mensagens de agentes de IA do Azure do nosso conversor:

• Qualidade: IntentResolution, ToolCallAccuracy, TaskAdherence, Relevance, Coherence, , e Fluency
• Segurança: CodeVulnerabilities, Violence, Self-harm, Sexual, HateUnfairness, IndirectAttack, , e ProtectedMaterials

Este artigo inclui exemplos de IntentResolution, ToolCallAccuracy, e TaskAdherence. Para exemplos de outros avaliadores com mensagens de agentes de IA Azure, veja avaliando agentes de Azure IA.

Configuração de modelos para avaliadores assistidos por IA

Para referência, nos seguintes trechos de código, os avaliadores assistidos por IA usam uma configuração de modelo para o grande juiz de modelo de linguagem (juiz LLM):

import os
from azure.ai.evaluation import AzureOpenAIModelConfiguration
from dotenv import load_dotenv
load_dotenv()

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ["AZURE_ENDPOINT"],
    api_key=os.environ.get("AZURE_API_KEY"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
)

Suporte a modelos avaliadores

Azure AI Agent Service suporta modelos de raciocínio AzureOpenAI ou OpenAI raciocínio e modelos não raciocínios para o juiz LLM, dependendo dos avaliadores:

Para avaliações complexas que exigem raciocínio refinado, use um modelo de raciocínio forte, como 4.1-mini um equilíbrio entre desempenho e eficiência de custos.

Intent resolution

IntentResolutionEvaluator Mede o quão bem o sistema identifica e entende a solicitação de um usuário. Esse entendimento inclui o quão bem ela escopa a intenção do usuário, faz perguntas para esclarecer e lembra os usuários finais sobre seu escopo de capacidades. Uma pontuação mais alta indica melhor identificação da intenção do usuário.

Exemplo de resolução de intenção

from azure.ai.evaluation import IntentResolutionEvaluator

intent_resolution = IntentResolutionEvaluator(model_config=model_config, threshold=3)
intent_resolution(
    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."
)

Saída de resolução de intenção

A pontuação numérica usa uma escala de Likert (inteiro de 1 a 5), onde uma pontuação maior é melhor. Dado um limiar numérico (padrão é 3), o avaliador responde aprovado se a pontuação for maior ou igual ao limiar, ou falhar caso contrário. Usar o motivo e outros campos pode ajudar você a entender por que a pontuação é alta ou baixa.

{
    "intent_resolution": 5,
    "intent_resolution_result": "pass",
    "intent_resolution_threshold": 3,
    "intent_resolution_reason": "The response provides the opening hours of the Eiffel Tower clearly and accurately, directly addressing the user's query. It includes specific times, which fully resolves the user's request for information about the opening hours.",
}

Se você constrói agentes fora do Foundry Agent Service, esse avaliador aceita um esquema típico para mensagens de agente. Para explorar um caderno de exemplo, veja Resolução de Intenções.

Precisão das chamadas de ferramenta

ToolCallAccuracyEvaluator mede a precisão e eficiência das chamadas de ferramenta feitas por um agente em uma execução. Ele fornece uma pontuação de 1 a 5 baseada em:

• A relevância e utilidade da ferramenta utilizada
• A correção dos parâmetros usados nas chamadas de ferramentas
• As contagens de chamadas perdidas ou excessivas

Suporte para avaliação de chamadas de ferramenta

ToolCallAccuracyEvaluator suporta avaliação no Serviço de Agente para as seguintes ferramentas:

• File Search
• Pesquisa de IA do Azure 
• Bing Grounding
• Pesquisa Personalizada do Bing
• SharePoint Grounding
• Code Interpreter
• Agente de Dados do Fabric
• OpenAPI
• Ferramenta de Função (ferramentas definidas pelo usuário)

Se uma ferramenta não suportada for usada na execução do agente, o avaliador gera uma passagem e explica que a avaliação das ferramentas não é suportada. Essa abordagem facilita a filtragem desses casos. Recomendamos que você inclua ferramentas não suportadas como ferramentas definidas pelo usuário para permitir a avaliação.

Exemplo de precisão das chamadas de ferramenta

from azure.ai.evaluation import ToolCallAccuracyEvaluator

tool_call_accuracy = ToolCallAccuracyEvaluator(model_config=model_config, threshold=3)

# provide the agent response with tool calls 
tool_call_accuracy(
    query="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."
            }
        ]
    }
    ],   
    tool_definitions=[
                {
                    "name": "azure_maps_timezone",
                    "description": "local time zone information for a given latitude and longitude.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "lat": {
                                "type": "float",
                                "description": "The latitude of the location."
                            },
                            "lon": {
                                "type": "float",
                                "description": "The longitude of the location."
                            }
                        }
                    }
                }
    ]
)

# alternatively, provide the tool calls directly without the full agent response
tool_call_accuracy(
    query="How is the weather in Seattle?",
    tool_calls=[{
                    "type": "tool_call",
                    "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ",
                    "name": "fetch_weather",
                    "arguments": {
                        "location": "Seattle"
                    }
                }],
    tool_definitions=[{
                    "id": "fetch_weather",
                    "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."
                            }
                        }
                    }
                }
    ]
)

Saída de precisão das chamadas de ferramenta

A pontuação numérica está em uma escala de Likert (inteiro de 1 a 5). Uma pontuação mais alta é melhor. Dado um limiar numérico (padrão para 3), o avaliador também fornece aprovação se a pontuação >= limiar, ou reprovação caso contrário. Use os campos de detalhe de razão e chamada de ferramenta para entender por que a pontuação é alta ou baixa.

{
    "tool_call_accuracy": 5,
    "tool_call_accuracy_result": "pass",
    "tool_call_accuracy_threshold": 3,
    "details": {
        "tool_calls_made_by_agent": 1,
        "correct_tool_calls_made_by_agent": 1,
        "per_tool_call_details": [
            {
                "tool_name": "fetch_weather",
                "total_calls_required": 1,
                "correct_calls_made_by_agent": 1,
                "correct_tool_percentage": 100%,
                "tool_call_errors": 0,
                "tool_call_success_result": "pass"
            }
        ],
        "excess_tool_calls": {
            "total": 0,
            "details": []
        },
        "missing_tool_calls": {
            "total": 0,
            "details": []
        }
    }
}

Se você construir agentes fora do Azure AI Agent Service, esse avaliador aceita um esquema típico para mensagens de agente. Para um caderno de exemplo, veja Precisão nas Chamadas de Ferramentas.

Task adherence

Em vários sistemas de IA orientados a tarefas, como sistemas agentes, é importante avaliar se o agente mantém o caminho para concluir uma tarefa, em vez de fazer passos ineficientes ou fora do escopo. TaskAdherenceEvaluator Mede o quão bem a resposta de um agente segue suas tarefas atribuídas, de acordo com as instruções de tarefa e as ferramentas disponíveis. A instrução da tarefa é extraída da mensagem do sistema e da consulta do usuário. Uma pontuação mais alta indica melhor adesão às instruções do sistema para resolver a tarefa.

Exemplo de adesão a tarefas

from azure.ai.evaluation import TaskAdherenceEvaluator

task_adherence = TaskAdherenceEvaluator(model_config=model_config)
task_adherence(
        query="What are the best practices for maintaining a healthy rose garden during the summer?",
        response="Make sure to water your roses regularly and trim them occasionally."                         
)

Resultado de adesão à tarefa

O avaliador indica aprovação ou reprovação , caso contrário. Use o campo razão para entender a razão por trás da pontuação

{
    "task_adherence_result": "fail",
    "task_adherence_reason": "The response partially addresses the query by mentioning relevant practices but lacks critical details and depth, making it insufficient for a comprehensive understanding of maintaining a rose garden in summer."
}

Se você está construindo agentes fora do Azure AI Agent Service, esse avaliador aceita um esquema típico para mensagens de agente. Para um caderno de exemplo, veja Adesão a Tarefas.

Related content

• Como executar avaliação em lote em um conjunto de dados
• Como executar avaliação em lote em um alvo
• Como executar a avaliação do agente