Snabbstart: Utvärdera din värdbaserade agent

azd Kontrollera att agenten är distribuerad och kan anropas från projektkatalogen:

azd ai agent show

Skicka en testprompt:

azd ai agent invoke "Write a haiku about deploying cloud applications."

Du bör se ett svar inom några sekunder.

1. Öppna Foundry-portalen och gå till ditt projekt.
2. Välj din agent och välj sedan fliken Lekplats .
3. Skicka en testprompt, till exempel Write a haiku about deploying cloud applications.

Du bör se ett svar inom några sekunder.

Installera Foundry SDK:

pip install "azure-ai-projects>=2.0.0" azure-identity

Ange två miljövariabler och skapa sedan projektklienten. Ställ in FOUNDRY_PROJECT_ENDPOINT på projektets slutpunkt och FOUNDRY_MODEL_NAME på en distribution för chattkomplettering som ska användas som bedömningsmodell. Följande kodexempel förutsätter att du kör dem i den här kontexten:

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

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
model_deployment = os.environ["FOUNDRY_MODEL_NAME"]

credential = DefaultAzureCredential()
project_client = AIProjectClient(endpoint=endpoint, credential=credential)
client = project_client.get_openai_client()

Bekräfta att din distribuerade agent är registrerad och tillgänglig. Ersätt <your-agent-name> med den värdbaserade agentens namn:

agent = project_client.agents.get("<your-agent-name>")
print(f"Found agent: {agent.name}")

Anropet returnerar agenten om den finns, eller utlöser ett fel om namnet är fel eller om agenten inte har distribuerats.

Installera Foundry SDK och OpenAI evals-klienten:

dotnet add package Azure.AI.Projects --prerelease
dotnet add package OpenAI
dotnet add package Azure.Identity

Ange två miljövariabler och skapa sedan klienterna. Ställ in FOUNDRY_PROJECT_ENDPOINT på projektets slutpunkt och FOUNDRY_MODEL_NAME på en distribution för chattkomplettering som ska användas som bedömningsmodell. Följande kodexempel förutsätter att du kör dem i den här kontexten:

using System.ClientModel;
using System.Text.Json;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Core;
using Azure.Identity;
using OpenAI;
using OpenAI.Evals;

#pragma warning disable AAIP001, OPENAI001

var endpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")!;
var modelDeployment = Environment.GetEnvironmentVariable("FOUNDRY_MODEL_NAME")!;

var credential = new DefaultAzureCredential();
AIProjectClient projectClient = new(new Uri(endpoint), credential);

// OpenAI-compatible evals client bound to the Foundry project endpoint.
// A Microsoft Entra token works as the credential because both use "Authorization: Bearer".
var token = credential.GetToken(new TokenRequestContext(["https://ai.azure.com/.default"])).Token;
EvaluationClient evalClient = new(
    new ApiKeyCredential(token),
    new OpenAIClientOptions { Endpoint = new Uri($"{endpoint}/openai/v1") });

Bekräfta att din distribuerade agent är registrerad och tillgänglig. Ersätt <your-agent-name> med den värdbaserade agentens namn:

ProjectsAgentRecord agent = projectClient.AgentAdministrationClient.GetAgent("<your-agent-name>");
Console.WriteLine($"Found agent: {agent.Name}");

Anropet returnerar agenten om den finns, eller utlöser ett fel om namnet är fel eller om agenten inte har distribuerats.

Installera Foundry SDK:

npm install @azure/ai-projects @azure/identity dotenv

Ange två miljövariabler och skapa sedan projektklienten. Ställ in FOUNDRY_PROJECT_ENDPOINT på projektets slutpunkt och FOUNDRY_MODEL_NAME på en distribution för chattkomplettering som ska användas som bedömningsmodell. Följande kodexempel förutsätter att du kör dem i den här kontexten:

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import "dotenv/config";

const endpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"] || "";
const modelDeployment = process.env["FOUNDRY_MODEL_NAME"] || "";

const projectClient = new AIProjectClient(
  endpoint,
  new DefaultAzureCredential(),
);
const client = projectClient.getOpenAIClient();

Bekräfta att din distribuerade agent är registrerad och tillgänglig. Ersätt <your-agent-name> med den värdbaserade agentens namn:

const agent = await projectClient.agents.get("<your-agent-name>");
console.log(`Found agent: ${agent.name}`);

Anropet returnerar agenten om den finns, eller utlöser ett fel om namnet är fel eller om agenten inte har distribuerats.

Referens: KLASSEN AIProjectClient

Skapa först en JSONL-fil med testfrågor för din agent. Varje rad är ett JSON-objekt med ett query fält. Spara den i agentens källmapp, som src/<your-agent-name>/tests/queries.jsonl:

{"query": "Write a haiku about deploying cloud applications."}

Skapa sedan en eval.yaml fil i samma agentkällamapp som src/<your-agent-name>/eval.yaml. Den pekar på din datauppsättning och visar de inbyggda utvärderarna som ska tillämpas. Sökvägen dataset.local_uri är relativ till den här mappen. Ersätt <your-agent-name> med namnet på din värdbaserade agent och <your-chat-completion-deployment> med driftsättningen av bedömningsmodellen:

name: agent-eval
agent:
  name: <your-agent-name>
  kind: hosted
dataset:
  local_uri: tests/queries.jsonl
evaluators:
  - builtin.intent_resolution
  - builtin.task_adherence
options:
  eval_model: <your-chat-completion-deployment>
max_samples: 15

Värdet eval_model är den bedömningsmodell som poängsätter svar. Du kan återanvända distributionen som agenten redan använder.

1. Öppna agenten i Foundry-portalen och välj fliken Utvärdering och välj sedan Skapa.
2. För Välj utvärderingsmål väljer du Agent.
3. För Välj utvärderingsområde väljer du Enskilda omgångar.
4. För Välj datakälla väljer du Befintlig datauppsättning och väljer en CSV- eller JSONL-fil med testfrågor från projektets datatillgångar.
5. Om steget Konfigurera agenter visas granskar du agenten och godkänner standardanvändarprompten. {{item.query}} Justera bara om agenten förväntar sig ett annat indataformat.
6. För Välj testvillkor väljer du en eller flera agentutvärderingar, till exempel uppgiftsefterlevnad och avsiktsmatchning.

Håll guiden öppen. Du skickar utvärderingen i nästa steg.

Skapa först en JSONL-fil med testfrågor för din agent. Varje rad är ett JSON-objekt med ett query fält. Spara den som queries.jsonl:

{"query": "Write a haiku about deploying cloud applications."}

Ladda upp filen som en datauppsättning i projektet:

dataset = project_client.datasets.upload_file(
    name="agent-test-queries",
    version="1",
    file_path="./queries.jsonl",
)

Välj sedan inbyggda utvärderare och mappa indata. Parametern data_mapping talar om för varje utvärderare var frågan och agentsvaret ska hittas. AI-assisterade utvärderare behöver en domarmodell i initialization_parameters; värdet måste vara en distribution för chattkomplettering i ditt projekt.

from azure.ai.projects.models import TestingCriterionAzureAIEvaluator

testing_criteria = [
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="Intent Resolution",
        evaluator_name="builtin.intent_resolution",
        initialization_parameters={"model": model_deployment},
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{sample.output_items}}",
        },
    ),
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="Task Adherence",
        evaluator_name="builtin.task_adherence",
        initialization_parameters={"model": model_deployment},
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{sample.output_items}}",
        },
    ),
]

Skapa utvärderingen. Den definierar testdataschemat och testkriterierna och fungerar som en container för en eller flera körningar:

from openai.types.eval_create_params import DataSourceConfigCustom

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {"query": {"type": "string"}},
        "required": ["query"],
    },
    include_sample_schema=True,
)

evaluation = client.evals.create(
    name="Agent Quality Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)
print(f"Evaluation created: {evaluation.id}")

Skapa först en JSONL-fil med testfrågor för din agent. Varje rad är ett JSON-objekt med ett query fält. Spara den som queries.jsonl:

{"query": "Write a haiku about deploying cloud applications."}

Ladda upp filen som en datauppsättning i projektet:

AIProjectDataset dataset = projectClient.Datasets.UploadFile(
    name: "agent-test-queries",
    version: "1",
    filePath: "./queries.jsonl");

Välj sedan inbyggda utvärderare och mappa indata. Parametern data_mapping talar om för varje utvärderare var frågan och agentsvaret ska hittas. AI-assisterade utvärderare behöver en domarmodell i initialization_parameters; värdet måste vara en distribution för chattkomplettering i ditt projekt.

var testingCriteria = new object[]
{
    new
    {
        type = "azure_ai_evaluator",
        name = "Intent Resolution",
        evaluator_name = "builtin.intent_resolution",
        initialization_parameters = new { model = modelDeployment },
        data_mapping = new { query = "{{item.query}}", response = "{{sample.output_items}}" },
    },
    new
    {
        type = "azure_ai_evaluator",
        name = "Task Adherence",
        evaluator_name = "builtin.task_adherence",
        initialization_parameters = new { model = modelDeployment },
        data_mapping = new { query = "{{item.query}}", response = "{{sample.output_items}}" },
    },
};

Skapa utvärderingen. Den definierar testdataschemat och testkriterierna och fungerar som en container för en eller flera körningar:

var createEvaluation = new
{
    name = "Agent Quality Evaluation",
    data_source_config = new
    {
        type = "custom",
        item_schema = new
        {
            type = "object",
            properties = new { query = new { type = "string" } },
            required = new[] { "query" },
        },
        include_sample_schema = true,
    },
    testing_criteria = testingCriteria,
};

ClientResult evaluationResult = evalClient.CreateEvaluation(
    BinaryContent.Create(BinaryData.FromObjectAsJson(createEvaluation)));
string evaluationId = JsonDocument.Parse(evaluationResult.GetRawResponse().Content.ToString())
    .RootElement.GetProperty("id").GetString()!;
Console.WriteLine($"Evaluation created: {evaluationId}");

Skapa först en JSONL-fil med testfrågor för din agent. Varje rad är ett JSON-objekt med ett query fält. Spara den som queries.jsonl:

{"query": "Write a haiku about deploying cloud applications."}

Ladda upp filen som en datauppsättning i projektet:

const dataset = await projectClient.datasets.uploadFile(
  "agent-test-queries",
  "1",
  "./queries.jsonl",
);

Välj sedan inbyggda utvärderare och mappa indata. Parametern data_mapping talar om för varje utvärderare var frågan och agentsvaret ska hittas. AI-assisterade utvärderare behöver en domarmodell i initialization_parameters; värdet måste vara en distribution för chattkomplettering i ditt projekt.

const testingCriteria = [
  {
    type: "azure_ai_evaluator",
    name: "Intent Resolution",
    evaluator_name: "builtin.intent_resolution",
    initialization_parameters: { model: modelDeployment },
    data_mapping: {
      query: "{{item.query}}",
      response: "{{sample.output_items}}",
    },
  },
  {
    type: "azure_ai_evaluator",
    name: "Task Adherence",
    evaluator_name: "builtin.task_adherence",
    initialization_parameters: { model: modelDeployment },
    data_mapping: {
      query: "{{item.query}}",
      response: "{{sample.output_items}}",
    },
  },
];

Skapa utvärderingen. Den definierar testdataschemat och testkriterierna och fungerar som en container för en eller flera körningar:

const dataSourceConfig = {
  type: "custom",
  item_schema: {
    type: "object",
    properties: { query: { type: "string" } },
    required: ["query"],
  },
  include_sample_schema: true,
};

const evaluation = await client.evals.create({
  name: "Agent Quality Evaluation",
  data_source_config: dataSourceConfig,
  testing_criteria: testingCriteria,
});
console.log(`Evaluation created: ${evaluation.id}`);

Kör utvärderingen från azd-arbetsytans rot:

azd ai agent eval run --config eval.yaml

Kommandot läser eval.yaml, skickar varje fråga till din agent, poängsätter svaren och skriver ut en sammanfattning när den är klar:

Eval run started
   Eval: eval_b36748dede424e4ba3f8e6c99ca2cf27
   Run:  evalrun_5f72ef189ad24790a32128e6f230b131
   (✓) Done  Eval run

Results:    1 total, 1 passed, 0 failed, 0 errored

Per-criteria results:
  intent_resolution: 1 passed, 0 failed, 0 errored
  task_adherence: 1 passed, 0 failed, 0 errored

1. I steget Granska och skicka anger du ett namn för utvärderingen.
2. Granska mål, omfång, datakälla och valda utvärderare.
3. Välj Skicka för att starta körningen.

Skapa en körning som skickar varje testfråga till din agent och tillämpar utvärderarna. Ersätt <your-agent-name> med den värdbaserade agentens namn:

eval_run = client.evals.runs.create(
    eval_id=evaluation.id,
    name="Agent Evaluation Run",
    data_source={
        "type": "azure_ai_target_completions",
        "source": {"type": "file_id", "id": dataset.id},
        "input_messages": {
            "type": "template",
            "template": [
                {
                    "type": "message",
                    "role": "user",
                    "content": {"type": "input_text", "text": "{{item.query}}"},
                }
            ],
        },
        "target": {
            "type": "azure_ai_agent",
            "name": "<your-agent-name>",
            # "version": "1",  # Optional; omit to use the latest version
        },
    },
)

print(f"Evaluation run started: {eval_run.id}")

Skapa en körning som skickar varje testfråga till din agent och tillämpar utvärderarna. Ersätt <your-agent-name> med den värdbaserade agentens namn:

var createRun = new
{
    name = "Agent Evaluation Run",
    data_source = new
    {
        type = "azure_ai_target_completions",
        source = new { type = "file_id", id = dataset.Id },
        input_messages = new
        {
            type = "template",
            template = new object[]
            {
                new { type = "message", role = "user", content = new { type = "input_text", text = "{{item.query}}" } },
            },
        },
        // Add a "version" property to the target to pin a specific agent version; omit to use the latest.
        target = new { type = "azure_ai_agent", name = "<your-agent-name>" },
    },
};

ClientResult runResult = evalClient.CreateEvaluationRun(
    evaluationId, BinaryContent.Create(BinaryData.FromObjectAsJson(createRun)));
string runId = JsonDocument.Parse(runResult.GetRawResponse().Content.ToString())
    .RootElement.GetProperty("id").GetString()!;
Console.WriteLine($"Evaluation run started: {runId}");

Skapa en körning som skickar varje testfråga till din agent och tillämpar utvärderarna. Ersätt <your-agent-name> med den värdbaserade agentens namn:

const evalRun = await client.evals.runs.create(evaluation.id, {
  name: "Agent Evaluation Run",
  data_source: {
    type: "azure_ai_target_completions",
    source: { type: "file_id", id: dataset.id },
    input_messages: {
      type: "template",
      template: [
        {
          type: "message",
          role: "user",
          content: { type: "input_text", text: "{{item.query}}" },
        },
      ],
    },
    target: {
      type: "azure_ai_agent",
      name: "<your-agent-name>",
      // version: "1", // Optional; omit to use the latest version
    },
  },
});

console.log(`Evaluation run started: ${evalRun.id}`);

Lista de senaste utvärderingarna:

azd ai agent eval list

    Eval ID                                Name        Status of last run  Runs
    -------                                ----        ------------------  ----
*   eval_b36748dede424e4ba3f8e6c99ca2cf27  agent-eval  Completed           1

* = active eval in current environment

Visa den senaste utvärderingen och dess körningar:

azd ai agent eval show

Eval:   eval_b36748dede424e4ba3f8e6c99ca2cf27
Name:   agent-eval
Agent:  <your-agent-name>
Runs:   1

Recent runs:
  Run ID                                    Status     Passed  Failed  Created
  ------                                    ------     ------  ------  -------
  evalrun_5f72ef189ad24790a32128e6f230b131  Completed  1/1     0       2026-06-17 14:52 UTC

Använd resultaten för att bekräfta vilken agentversion som utvärderades och vilka bedömarpoäng som genererades. Om du vill se information per utvärderare och en länk till rapporten i Foundry-portalen kör du azd ai agent eval show <eval-id> --eval-run-id <run-id>.

1. Informationssidan visar målet, datamängden, statusen, tokenanvändningen och en aggregerad poäng för varje utvärderare.
2. Välj namnet på körningen för att visa resultat för varje rad: varje fråga, agentens svar, utvärderarens poäng och förklaring av poängen.

Vänta tills processen är klar och skriv sedan ut statusen och rapport-URL:en som öppnar resultaten i Foundry-portalen:

import time

while True:
    run = client.evals.runs.retrieve(run_id=eval_run.id, eval_id=evaluation.id)
    if run.status in ["completed", "failed"]:
        break
    time.sleep(5)

print(f"Status: {run.status}")
print(f"Report URL: {run.report_url}")

På körningsnivå kan du se sammanställda antal godkända och underkända för varje utvärderare:

print(run.result_counts)
for criteria in run.per_testing_criteria_results:
    print(criteria.testing_criteria, "passed:", criteria.passed, "failed:", criteria.failed)

ResultCounts(errored=0, failed=0, passed=1, total=1, skipped=0)
Intent Resolution passed: 1 failed: 0
Task Adherence passed: 1 failed: 0

För information på radnivå listar du utdataobjekten. Varje resultat innehåller utvärderarens namn, pass eller fail och en poäng:

for item in client.evals.runs.output_items.list(run_id=eval_run.id, eval_id=evaluation.id):
    for result in item.results:
        print(item.id, result.name, "passed:", result.passed, "score:", result.score)

Polla tills det är klart och skriv sedan ut statusen och rapportens URL som öppnar resultaten i Foundry-portalen:

JsonElement run = default;
while (true)
{
    ClientResult runStatus = evalClient.GetEvaluationRun(evaluationId, runId, options: null);
    run = JsonDocument.Parse(runStatus.GetRawResponse().Content.ToString()).RootElement;
    string status = run.GetProperty("status").GetString()!;
    if (status is "completed" or "failed") break;
    Thread.Sleep(TimeSpan.FromSeconds(5));
}

Console.WriteLine($"Status: {run.GetProperty("status").GetString()}");
Console.WriteLine($"Report URL: {run.GetProperty("report_url").GetString()}");

På körningsnivå kan du se sammanställda antal godkända och underkända för varje utvärderare:

Console.WriteLine(run.GetProperty("result_counts").GetRawText());
foreach (JsonElement criteria in run.GetProperty("per_testing_criteria_results").EnumerateArray())
{
    Console.WriteLine(
        $"{criteria.GetProperty("testing_criteria").GetString()} " +
        $"passed: {criteria.GetProperty("passed").GetInt32()} " +
        $"failed: {criteria.GetProperty("failed").GetInt32()}");
}

För information på radnivå listar du utdataobjekten. Varje resultat innehåller utvärderarens namn, pass eller fail och en poäng:

ClientResult outputItems = evalClient.GetEvaluationRunOutputItems(
    evaluationId, runId, limit: 100, order: null, after: null, outputItemStatus: null, options: null);
foreach (JsonElement item in JsonDocument.Parse(outputItems.GetRawResponse().Content.ToString())
    .RootElement.GetProperty("data").EnumerateArray())
{
    foreach (JsonElement result in item.GetProperty("results").EnumerateArray())
    {
        Console.WriteLine(
            $"{item.GetProperty("id").GetString()} {result.GetProperty("name").GetString()} " +
            $"passed: {result.GetProperty("passed")} score: {result.GetProperty("score")}");
    }
}

Polla tills det är klart och skriv sedan ut statusen och rapportens URL som öppnar resultaten i Foundry-portalen:

let run = evalRun;
while (!["completed", "failed"].includes(run.status)) {
  run = await client.evals.runs.retrieve(run.id, {
    eval_id: evaluation.id,
  });
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

console.log(`Status: ${run.status}`);
console.log(`Report URL: ${run.report_url}`);

På körningsnivå kan du se sammanställda antal godkända och underkända för varje utvärderare:

console.log(JSON.stringify(run.result_counts));
for (const criteria of run.per_testing_criteria_results) {
  console.log(
    criteria.testing_criteria,
    "passed:",
    criteria.passed,
    "failed:",
    criteria.failed,
  );
}

{"errored":0,"failed":0,"passed":1,"total":1,"skipped":0}
Intent Resolution passed: 1 failed: 0
Task Adherence passed: 1 failed: 0

För information på radnivå listar du utdataobjekten. Varje resultat innehåller utvärderarens namn, pass eller fail och en poäng:

for await (const item of client.evals.runs.outputItems.list(run.id, {
  eval_id: evaluation.id,
})) {
  for (const result of item.results) {
    console.log(item.id, result.name, "passed:", result.passed, "score:", result.score);
  }
}