Quickstart: Een gehoste agent optimaliseren

• azd CLI (Azure Developer CLI).

• Azure CLI voor verificatie.

• De microsoft.foundry extensie voor azd (0.1.40-preview of hoger van de azure.ai.agents afhankelijkheid):

  azd ext install microsoft.foundry
  

  Als deze al is geïnstalleerd, voert u een upgrade uit:

  azd ext upgrade microsoft.foundry
  

• Azure CLI voor verificatie.

• Python 3.10 of hoger.

• De Python pakketten die in dit pad worden gebruikt:

  pip install "azure-ai-projects>=2.5.0" azure-ai-agentserver-optimization azure-identity python-dotenv
  

• Een bestaand Foundry-project dat al de gehoste agent, geregistreerde gegevensset en evaluator bevat die u wilt gebruiken voor optimalisatie.

• Azure CLI voor verificatie.

• .NET 10 SDK of hoger.

• De .NET pakketten die in dit pad worden gebruikt.

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

• Een bestaand Foundry-project dat al de gehoste agent, geregistreerde gegevensset en evaluator bevat die u wilt gebruiken voor optimalisatie.

• Visual Studio Code.

• Microsoft Foundry Toolkit voor Visual Studio Code versie 1.6.4 of hoger, aangemeld bij Azure. Foundry Toolkit installeert en werkt de Microsoft Foundry Skill bij die door deze werkstroom wordt gebruikt.

• GitHub Copilot in Visual Studio Code met toegang tot de agentmodus. Foundry Toolkit verzendt de aanvraag Agent Optimizer naar GitHub Copilot nadat u de agentwerkruimte hebt geselecteerd.

• Azure CLI en Azure Developer CLI (AZD) geïnstalleerd en geverifieerd:

  az login
  azd auth login
  

• Een codeeragenthost waarop de Microsoft Foundry Skill is geïnstalleerd.

• Azure CLI en Azure Developer CLI (AZD) geïnstalleerd en geverifieerd:

  az login
  azd auth login
  

• De microsoft.foundry extensie voor AZD. Installeer deze voordat u de werkstroom start:

  azd ext install microsoft.foundry
  

  Als deze al is geïnstalleerd, voert u een upgrade uit:

  azd ext upgrade microsoft.foundry
  

Stap 1: Het project maken

Initialiseer een nieuw project op basis van de voorbeeldsjabloon voor optimalisatie:

mkdir my-agent && cd my-agent
azd ai agent init -t https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/bring-your-own/responses/optimization-customer-support/azure.yaml .

Met deze sjabloon importeert u het Optimization Customer Support sample, een voor optimalisatie geschikte, in Python gehoste agent die gebruikmaakt van de bring-your-own-aanpak en het Responses-protocol. Het vertegenwoordigt een ondersteuningsagent voor consumentenelektronica die ordervragen afhandelt, retourneert, garantieclaims, probleemoplossing, klachten, aanbevelingen en escalatie. De bewust minimale basislijninstructie maakt de verbeteringen van instructieoptimalisatie en vaardigheidsdetectie eenvoudig te vergelijken.

Het voorbeeld roept load_config() aan om de basislijn- of kandidaatconfiguratie te laden en omvat .agent_configs/baseline/, eval.yaml, gegevenssets voor volledige en snelle evaluatie, containerconfiguratie en het Foundry-implementatiemanifest. De interactieve stroom importeert deze bestanden en vraagt om uw Azure-abonnement, regio en modelimplementatie-instellingen.

Stap 2: Inrichten en implementeren

De Azure resources verifiëren en inrichten:

az login
azd auth login
azd provision

Het inrichten duurt ongeveer twee minuten en maakt een Foundry-account, project, Azure Container Registry en modelimplementaties.

Rol de agent uit:

azd deploy

De implementatie testen:

azd ai agent invoke "What is 2+2?"

Stap 3: Evaluatiepakket genereren en optimaliseren

Genereer een evaluatiedataset en beoordelaars voor uw agent:

azd ai agent eval generate

Met deze stap worden eval.yaml, een testdataset en score-evaluatoren gemaakt op basis van de instructies van uw agent. De optimizer gebruikt deze bestanden om verbetering te meten.

Voer de optimizer uit:

azd ai agent optimize --max-candidates 2

De CLI vraagt u om een optimalisatiemodel te selecteren. Als u de prompt wilt overslaan, geeft u deze rechtstreeks door:

azd ai agent optimize --max-candidates 2 --optimize-model gpt-5

De CLI detecteert uw agent op basis van azure.yaml en gebruikt automatisch de gegenereerde eval.yaml. Met twee kandidaten wordt optimalisatie doorgaans in ongeveer 8 minuten voltooid. De voortgang wordt in real-time weergegeven:

Optimizing agent "customer-support-py"...
  Config: eval.yaml
  Baseline saved to .agent_configs/baseline/metadata.yaml
  Job ID: opt_162bd0f09....
  Status: pending
  Portal: <OPTIMIZATION-JOB-URL>

Gebruik de portal-URL om uw taak in de Foundry-portal te bewaken.

Het evaluatiemodel beoordeelt elk antwoord (elk chatvoltooiingsmodel werkt). Het optimalisatiemodel (--optimize-model) genereert verbeterde kandidaten en moet afkomstig zijn uit de ondersteunde lijst (gpt-5-familie of DeepSeek). U kunt optimization_model ook instellen onder options: in eval.yaml om te voorkomen dat u de vlag telkens moet meegeven.

Stap 4: Rol de winnaar uit

De ster (*) in de uitvoer geeft de beste kandidaat aan. Pas de geoptimaliseerde configuratie lokaal toe en implementeer vervolgens:

azd ai agent optimize apply --candidate <candidate-id>
azd deploy

Met de opdracht apply downloadt u de geoptimaliseerde configuratie naar .agent_configs/<candidate_id>/ en werkt u uw azure.yaml bij om de nieuwe instructies te gebruiken. Met de opdracht deploy wordt de geoptimaliseerde agent live gezet met CodeDeploy.

Roep uw agent aan om de verbetering te controleren:

azd ai agent invoke "What is your return policy?"

U kunt ook een evaluatie uitvoeren om de scoreverbetering te bevestigen:

azd ai agent eval run

Python SDK-pad

Gebruik de volgende stappen als u de optimizer wilt uitvoeren vanuit Python in plaats van de Azure Developer CLI-werkstroom die eerder is beschreven.

In dit pad wordt ervan uitgegaan dat u al de volgende resources in een bestaand Foundry-project hebt:

• Een gehoste agent voor optimalisatie
• Een geregistreerde trainingsgegevensset.
• Een geregistreerde evaluator.

In tegenstelling tot de eerder beschreven Azure Developer CLI-workflow wordt er via de Python SDK-route niet automatisch een project opgezet en worden eval.yaml, een gegevensset of evaluatoren niet voor u gegenereerd. Als u wilt dat het voorbeeld deze onderdelen automatisch maakt, gebruikt u eerst azd ai agent eval generate.

1. Een bestand maken .env

Maak een werkmap en voeg vervolgens een .env bestand toe met deze waarden:

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
FOUNDRY_AGENT_NAME=<your-hosted-agent-name>
DATASET_NAME=<your-registered-dataset-name>
EVALUATOR_NAME=<your-registered-evaluator-name>
DATASET_VERSION=1
POLL_INTERVAL_SECONDS=10
EVAL_MODEL=<your-eval-model-deployment-name>
OPTIMIZATION_MODEL=<your-optimization-model-deployment-name>

Voer het script uit vanuit dezelfde werkmap, zodat load_dotenv() het .env bestand automatisch kan worden geladen. Als u deze liever vanuit een andere map uitvoert, stelt u eerst dezelfde waarden in uw shell-omgeving in.

Gebruik het exacte projecteindpunt op de overzichtspagina van uw Foundry-project. Het Python script verzendt de eerste aanvraag onmiddellijk. Als FOUNDRY_PROJECT_ENDPOINT dit slechts een tijdelijke aanduiding is of verwijst naar het verkeerde project, mislukt de uitvoering met ResourceNotFound: The project does not exist.

Stel EVAL_MODEL en OPTIMIZATION_MODEL in op deploymentnamen die al in je Foundry-project bestaan, en niet alleen op namen van modelfamilies. Als uw projectimplementatie bijvoorbeeld een naam gpt-4.1-mini heeft of DeepSeek-V3.2, gebruikt u die exacte implementatienaam in .env.

2. Voer de optimalisatietaak uit

Maak een bestand met de naam optimize_hosted_agent.py in dezelfde map als .env:

"""
DESCRIPTION:
    Create an optimization job for a hosted agent using the latest agent
    optimization API, poll the job to completion, and list its candidates.

USAGE:
    python optimize_hosted_agent_v3.py

    Before running the sample:

    pip install azure-ai-projects azure-ai-agentserver-optimization azure-identity python-dotenv

    Set these environment variables with your own values:
    1) FOUNDRY_PROJECT_ENDPOINT - Required. The Microsoft Foundry project endpoint.
    2) FOUNDRY_AGENT_NAME       - Required. The hosted agent name.
    3) DATASET_NAME             - Required. The registered training dataset name.
    4) EVALUATOR_NAME           - Required. The registered evaluator name.
    5) DATASET_VERSION          - Optional. The dataset version. Defaults to "1".
    6) EVAL_MODEL               - Optional. The evaluation model. Defaults to "gpt-4o".
    7) OPTIMIZATION_MODEL       - Optional. The optimization model. Defaults to "gpt-5".
    8) POLL_INTERVAL_SECONDS    - Optional. Seconds between status polls. Defaults to 10.
    9) OPTIMIZATION_JOB_ID      - Optional. An existing job ID to resume instead of creating a job.
   10) OPTIMIZATION_LOCAL_DIR   - Optional. Path to the local .agent_configs directory.
   11) CREDENTIAL_PROCESS_TIMEOUT_SECONDS
                                - Optional. Credential subprocess timeout. Defaults to 60.
"""

import os
import time
from pathlib import Path

from azure.ai.agentserver.optimization import load_config, load_skills_from_dir
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    AgentOptimizationBaselineAgentConfiguration,
    AgentOptimizationCandidateExpand,
    AgentOptimizationCandidateSearchConfiguration,
    AgentOptimizationConfiguration,
    AgentOptimizationEvaluationConfiguration,
    AgentOptimizationEvaluator,
    AgentOptimizationFoundryAgentTargetConfiguration,
    AgentOptimizationJob,
    AgentOptimizationModelConfiguration,
    AgentOptimizationSkill,
    AgentOptimizationSpace,
    AgentOptimizationTargetCompletionDatasetReferenceDataSource,
    AgentOptimizationTargetCompletionEvaluationSet,
    EvaluationModelConfiguration,
    JobStatus,
    TargetAttribute,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
agent_name = os.environ["FOUNDRY_AGENT_NAME"]
dataset_name = os.environ["DATASET_NAME"]
evaluator_name = os.environ["EVALUATOR_NAME"]
dataset_version = os.environ.get("DATASET_VERSION", "1")
eval_model = os.environ.get("EVAL_MODEL", "gpt-4o")
optimization_model = os.environ.get("OPTIMIZATION_MODEL", "gpt-5")
poll_interval_seconds = int(os.environ.get("POLL_INTERVAL_SECONDS", "10"))
existing_job_id = os.environ.get("OPTIMIZATION_JOB_ID")
credential_process_timeout_seconds = int(
    os.environ.get("CREDENTIAL_PROCESS_TIMEOUT_SECONDS", "60")
)

# Reads the hosted agent's baseline config from .agent_configs/baseline/metadata.yaml.
optimization_config = load_config()

target_attributes = [TargetAttribute.INSTRUCTIONS]
baseline_configuration = None
if optimization_config:
    loaded_skills = optimization_config.skills
    if not loaded_skills and optimization_config.skills_dir:
        loaded_skills = load_skills_from_dir(Path(optimization_config.skills_dir))

    skills = [
        AgentOptimizationSkill(
            name=skill.name,
            description=skill.description,
            body=skill.body or None,
        )
        for skill in loaded_skills
    ]

    if skills:
        target_attributes.append(TargetAttribute.SKILLS)
    if optimization_config.tool_definitions:
        target_attributes.append(TargetAttribute.TOOLS)

    baseline_configuration = AgentOptimizationBaselineAgentConfiguration(
        system_prompt=optimization_config.instructions,
        current_model=optimization_config.model,
        skills=skills or None,
        tools=optimization_config.tool_definitions or None,
    )

with (
    DefaultAzureCredential(
        process_timeout=credential_process_timeout_seconds
    ) as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
    job_request = AgentOptimizationJob(
        target_configuration=AgentOptimizationFoundryAgentTargetConfiguration(
            name=agent_name
        ),
        optimization_model_configuration=AgentOptimizationModelConfiguration(
            model=optimization_model
        ),
        optimization_configuration=AgentOptimizationConfiguration(
            evaluation_configuration=AgentOptimizationEvaluationConfiguration(
                training_set=AgentOptimizationTargetCompletionEvaluationSet(
                    source=AgentOptimizationTargetCompletionDatasetReferenceDataSource(
                        name=dataset_name,
                        version=dataset_version,
                    )
                ),
                evaluators=[AgentOptimizationEvaluator(name=evaluator_name)],
                evaluation_model=EvaluationModelConfiguration(model=eval_model),
            ),
            candidate_search_configuration=AgentOptimizationCandidateSearchConfiguration(
                max_candidates=2
            ),
            baseline_agent_configuration=baseline_configuration,
            agent_optimization_space=AgentOptimizationSpace(
                target_attributes=target_attributes
            ),
        ),
    )

    if existing_job_id:
        job_id = existing_job_id
    else:
        poller = project_client.agents.begin_create_optimization_job(
            job=job_request,
            polling=False,
        )
        job_id = poller.details.get("job_id")
        if not isinstance(job_id, str):
            raise RuntimeError(
                "The create operation did not return an optimization job ID."
            )

    print(f"Optimization job ID: {job_id}")

    terminal_statuses = {
        JobStatus.SUCCEEDED,
        JobStatus.FAILED,
        JobStatus.CANCELLED,
    }
    job = project_client.agents.get_optimization_job(job_id=job_id)
    print("Optimization job started, waiting for completion...")
    while job.status not in terminal_statuses:
        print(f"\tstatus=`{job.status}`")
        time.sleep(poll_interval_seconds)
        job = project_client.agents.get_optimization_job(job_id=job_id)
    print(f"\tstatus=`{job.status}`")

    for warning in job.warnings or []:
        print(f"[WARNING] {warning}")

    if job.status == JobStatus.FAILED:
        message = job.error.message if job.error else "<no error message>"
        raise RuntimeError(f"Optimization job `{job.id}` failed: {message}")
    if job.status == JobStatus.CANCELLED:
        raise RuntimeError(f"Optimization job `{job.id}` was cancelled.")
    if job.result is None:
        raise RuntimeError(f"Optimization job `{job.id}` completed without a result.")

    result = job.result
    summary = result.candidate_summary
    if summary:
        print(f"Baseline candidate: {summary.baseline_id}")
        print(f"Best candidate: {summary.best_id}")
        print(f"Completed optimized candidates: {summary.completed_candidate_count}")
        if summary.baseline_score is not None:
            print(f"Baseline score: {summary.baseline_score:.4f}")
        if summary.best_score is not None:
            print(f"Best score: {summary.best_score:.4f}")
    if result.termination_reason:
        print(f"Termination reason: {result.termination_reason}")

    for candidate in project_client.agents.list_optimization_candidates(
        job_id=job_id,
        expand=[AgentOptimizationCandidateExpand.MUTATIONS],
    ):
        details = [
            f"{candidate.name}: candidate_id={candidate.candidate_id}",
            f"status={candidate.status}",
        ]
        if candidate.evaluation:
            if candidate.evaluation.score is not None:
                details.append(f"score={candidate.evaluation.score:.4f}")
            if candidate.evaluation.avg_tokens is not None:
                details.append(f"avg_tokens={candidate.evaluation.avg_tokens:.0f}")
        print(", ".join(details))

Voer het script uit:

python optimize_hosted_agent.py

De id van de optimalisatietaak wordt direct na indiening afgedrukt; gebruik deze om de voortgang in de Foundry-portal te controleren.

Wanneer de taak succesvol wordt voltooid, toont het script de winnende kandidaat en diens candidate_id.

In tegenstelling tot azd ai agent optimize maakt de stroom van de Python-SDK geen lokaal .agent_configs/baseline/metadata.yaml-bestand aan. De metagegevens van de optimalisatietaak blijven in het geretourneerde job object en in het antwoord van de Foundry-service, inclusief de basislijnkandidaat, de beste kandidaat en de scorelijst.

3. De winnende kandidaat toepassen

Als u ook werkt met het lokale azd-project dat in het bovenstaande CLI-proces wordt gebruikt, past u de winnende kandidaat toe met de candidate_id die door het Python-script is geretourneerd:

azd ai agent optimize apply --candidate <candidate-id>
azd deploy

Als u alleen het resultaat hoeft te inspecteren, gebruikt u de kandidaatscores en evaluatie-id’s die door het script worden weergegeven om de winnende configuratie in Foundry te beoordelen voordat u deze promoveert.

Pad van de C# SDK

Gebruik de volgende stappen als u de optimizer wilt uitvoeren vanuit .NET in plaats van de Azure Developer CLI-werkstroom te gebruiken die eerder is beschreven.

In dit pad wordt ervan uitgegaan dat u al de volgende resources in een bestaand Foundry-project hebt:

• Een gehoste agent voor optimalisatie
• Een geregistreerde trainingsgegevensset.
• Een geregistreerde evaluator, zoals de ingebouwde builtin.task_adherence evaluator.

In tegenstelling tot de eerder beschreven werkwijze met de Azure Developer CLI, wordt er via het .NET SDK-traject niet automatisch een project of eval.yaml, een gegevensset of evaluatoren voor je gegenereerd. Als u wilt dat het voorbeeld deze onderdelen automatisch maakt, gebruikt u eerst azd ai agent eval generate.

1. Uw omgevingsvariabelen instellen

Maak een console-app en stel deze waarden in uw shell in voordat u deze uitvoert:

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
FOUNDRY_AGENT_NAME=<your-hosted-agent-name>
DATASET_NAME=<your-registered-dataset-name>
DATASET_VERSION=1
EVALUATOR_NAME=builtin.task_adherence
EVAL_MODEL=<your-eval-model-deployment-name>
OPTIMIZATION_MODEL=<your-optimization-model-deployment-name>

Gebruik het exacte projecteindpunt op de overzichtspagina van uw Foundry-project.

Stel EVAL_MODEL en OPTIMIZATION_MODEL in op deploymentnamen die al in je Foundry-project bestaan, en niet alleen op namen van modelfamilies. Het optimalisatiemodel moet een redeneringsmodel zijn dat door de optimizer wordt ondersteund. Als u een niet-ondersteunde implementatie kiest, geeft de service een fout weer waarin de toegestane modellen worden vermeld.

2. Voer de optimalisatietaak uit

Vervang Program.cs door de volgende code.

Voor agentoptimalisatie is de AgentsOptimization=V2Preview functieheader vereist voor elk verzoek. De FoundryFeaturesPolicy klasse in dit voorbeeld voegt die header toe aan elke aanvraag die de client verzendt:

using System.ClientModel.Primitives;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;

#pragma warning disable AAIP001

// Adds the feature header that agent optimization requires.
public sealed class FoundryFeaturesPolicy(string features) : PipelinePolicy
{
    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int index)
    {
        message.Request.Headers.Set("Foundry-Features", features);
        ProcessNext(message, pipeline, index);
    }

    public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int index)
    {
        message.Request.Headers.Set("Foundry-Features", features);
        return ProcessNextAsync(message, pipeline, index);
    }
}

public static class Program
{
    public static void Main()
    {
        var endpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")!;
        var agentName = Environment.GetEnvironmentVariable("FOUNDRY_AGENT_NAME")!;
        var datasetName = Environment.GetEnvironmentVariable("DATASET_NAME")!;
        var datasetVersion = Environment.GetEnvironmentVariable("DATASET_VERSION") ?? "1";
        var evaluatorName = Environment.GetEnvironmentVariable("EVALUATOR_NAME") ?? "builtin.task_adherence";
        var evalModel = Environment.GetEnvironmentVariable("EVAL_MODEL")!;
        var optimizationModel = Environment.GetEnvironmentVariable("OPTIMIZATION_MODEL")!;

        var options = new AIProjectClientOptions();
        options.AddPolicy(new FoundryFeaturesPolicy("AgentsOptimization=V2Preview"), PipelinePosition.PerCall);

        AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential(), options);
        AgentOptimizationJobs optimizationJobs = projectClient.AgentAdministrationClient.GetAgentOptimizationJobs();

        OptimizationJob job = new()
        {
            Inputs = new OptimizationJobInputs(
                new OptimizationAgentIdentifier(agentName),
                new OptimizationReferenceDatasetInput(datasetName) { Version = datasetVersion },
                new[] { new OptimizationEvaluatorRef(evaluatorName) })
            {
                Options = new OptimizationOptions
                {
                    MaxCandidates = 2,
                    EvalModel = evalModel,
                    OptimizationModel = optimizationModel,
                    // The optimizer needs at least one optimizable target, such as the
                    // baseline system prompt, the tool definitions, or skills.
                    OptimizationConfig =
                    {
                        ["system_prompt"] = BinaryData.FromObjectAsJson(
                            "You are a helpful assistant that answers user requests accurately and concisely."),
                    },
                },
            },
        };

        OptimizationJob created = optimizationJobs.Create(job);
        Console.WriteLine($"Optimization job started: {created.Id}");

        OptimizationJob current = created;
        while (current.Status != AgentsJobStatus.Succeeded
            && current.Status != AgentsJobStatus.Failed
            && current.Status != AgentsJobStatus.Cancelled)
        {
            Thread.Sleep(TimeSpan.FromSeconds(20));
            current = optimizationJobs.Get(created.Id);
            Console.WriteLine($"\tstatus=`{current.Status}`");
        }

        Console.WriteLine($"Final status: {current.Status}");

        if (current.Result is not null)
        {
            Console.WriteLine($"Baseline candidate: {current.Result.Baseline}");
            Console.WriteLine($"Best candidate: {current.Result.Best}");

            foreach (OptimizationCandidate candidate in current.Result.Candidates)
            {
                Console.WriteLine(
                    $"{candidate.Name}: candidate_id={candidate.CandidateId}, " +
                    $"avg_score={candidate.AvgScore:F4}, " +
                    $"avg_tokens={candidate.AvgTokens:F0}");
            }
        }
    }
}

De app uitvoeren:

dotnet run

Wanneer de taak slaagt, toont de app de winnende kandidaat en de candidate_id ervan:

Optimization job started: opt_<job-id>
        status=`in_progress`
        status=`succeeded`
Final status: succeeded
Baseline candidate: cand_opt_<job-id>_0000
Best candidate: cand_opt_<job-id>_0000
baseline: candidate_id=cand_opt_<job-id>_0000, avg_score=1.0000, avg_tokens=0

In tegenstelling tot azd ai agent optimize maakt de .NET SDK-werkstroom geen lokaal .agent_configs/baseline/metadata.yaml-bestand. De metagegevens van de optimalisatietaak blijven in het geretourneerde taakobject en in het antwoord van de Foundry-service, inclusief de basislijnkandidaat, de beste kandidaat en de scorelijst.

3. De winnende kandidaat toepassen

Als u ook werkt vanuit het lokale azd-project dat in de CLI-workflow wordt gebruikt, past u de winnende kandidaat toe met behulp van de candidate_id die door de app is geretourneerd:

azd ai agent optimize apply --candidate <candidate-id>
azd deploy

Als u alleen het resultaat hoeft te bekijken, gebruikt u de kandidaatscores en evaluatie-id's die door de app worden weergegeven om de winnende configuratie in Foundry te beoordelen voordat u deze promoot.

De optimalisatie uitvoeren in VS Code

Foundry Toolkit bevat een systeemeigen agentoptimalisatie-ervaring voor geïmplementeerde gehoste agents. Vanuit de agentspeelplaats kunt u een optimalisatieuitvoering starten, kandidaten vergelijken met de basislijn, configuratiewijzigingen inspecteren en de beste kandidaat implementeren.

Stap 1: Selecteer een uitgerolde gehoste agent

1. Selecteer Foundry Toolkit in de activiteitenbalk.
2. Selecteer onder Mijn resourcesde optie Agents.
3. Als u een geïmplementeerde gehoste agent hebt, selecteert u deze om de speeltuin van de gehoste agent te openen.
4. Als u geen geïmplementeerde gehoste agent hebt, voltooit u het VS Code-pad in quickstart: Uw eerste gehoste agent implementeren. Nadat de implementatie is voltooid, gaat u terug naar Agents en selecteert u de nieuwe gehoste agent.

Stap 2: Een optimalisatieuitvoering starten

1. Selecteer het tabblad Optimaliseren .

1. Selecteer Nieuwe optimalisatie.

2. In Werkruimte selecteren kiest u de werkruimte die de code van de geselecteerde gehoste agent bevat:

   • Selecteer huidige werkruimte als de huidige werkruimte de agentcode en het azure.yaml bijbehorende bestand bevat.
   • Selecteer Bladeren... om de werkruimte met de agentcode te openen.

   Foundry Toolkit gebruikt de werkruimtebestanden om de optimalisatie voor te bereiden en een kandidaat toe te passen op de overeenkomende azure.ai.agent service.

1. Foundry Toolkit opent GitHub Copilot Chat en verzendt een Agent Optimizer-aanvraag die is gevuld met het type, de naam en het foundry-projecteindpunt van de geselecteerde agent.

2. Beantwoord de vier optimalisatievragen in Copilot Chat:

   Invoer	Wat u moet verstrekken
   Evaluatiemetrieken	Voer de metrieken of beoordelaars in die u wilt gebruiken. Als u deze niet hebt, kiest u of u de ingebouwde standaardinstellingen van de optimizer wilt uitvoeren azd ai agent eval generate of gebruiken.
   Dataset	Selecteer de optimalisatiegegevensset. Als u er geen hebt, kiest u of u de ingebouwde standaardinstellingen van de optimizer wilt uitvoeren azd ai agent eval generate of gebruiken.
   Maximum aantal kandidaten	Voer het maximum aantal kandidaten in dat moet worden gegenereerd, zoals 2.
   Optimalisatiemodel	Selecteer een bestaande implementatie in de ondersteunde optimalisatiemodellen.

GitHub Copilot wacht op deze invoer voordat de optimalisatie wordt gestart. De gegenereerde aanvraag instrueert Copilot om uitsluitend de Agent Optimizer-workflow van de Microsoft Foundry Skill en Azure Developer CLI-opdrachten te gebruiken. Er worden geen Foundry MCP-hulpprogramma's gebruikt. Copilot:

• Inspecteert de agentcode in de geselecteerde werkruimte.
• Initialiseert een AZD-omgeving op basis van bestaande azure.yaml- en .env-waarden, als het project er nog geen heeft.
• Configureert de agent voor optimalisatie en rolt de bijgewerkte gehoste agent uit.
• Maakt eval.yaml in de servicemap van de agent.
• Start de optimalisatie nadat u de voorgestelde bestandswijzigingen en -opdrachten hebt bekeken en goedgekeurd.

Nadat Copilot de taak heeft ingediend, gaat u terug naar het tabblad Optimaliseren. De uitvoering wordt weergegeven onder Optimalisatieuitvoeringen. De tabel toont de uitvoerings-id, status, aantal kandidaten, basislijnscore, beste score en aanmaaktijd.

Stap 3: de beste kandidaat vergelijken en implementeren

1. Wanneer de uitvoering is voltooid, selecteert u deze onder Optimalisatieuitvoeringen.
2. Vergelijk de Baseline- en Best-scores. Controleer de scoredetails voor elke kandidaat en selecteer Wijzigingen weergeven om de configuratiewijzigingen te controleren.
3. Als de beste kandidaat de basislijn verbetert, selecteert u De beste kandidaat implementeren om de huidige agent bij te werken. Als u deze wilt implementeren als een nieuwe agent of implementatie-instellingen wilt wijzigen, selecteert u in plaats daarvan Aangepaste implementatie .

De optimalisatie uitvoeren met de Microsoft Foundry Skill

Gebruik dit pad in elke host van een coderingsagent die ondersteuning biedt voor de Microsoft Foundry Skill, zoals GitHub Copilot in Visual Studio Code, Copilot CLI of Claude Code. De vaardigheid haalt de agentcontext op van azure.yaml, laadt de Agent Optimizer-workflow en houdt kandidaatapplicaties en implementatie achter beoordelingspoorten.

Stap 1: De werkruimte van de agent openen

Open een lege map in de host van de coderingsagent. Controleer of de microsoft-foundry vaardigheid beschikbaar is. Als de vaardigheid niet beschikbaar is, volg De Microsoft Foundry Skill gebruiken in codeeragents.

Stap 2: Vraag de vaardigheid om Agent Optimizer uit te voeren

Stuur deze prompt naar uw codeeragent:

Use the Microsoft Foundry Skill to run the Agent Optimizer workflow for a
Python hosted agent. If this workspace doesn't contain an agent, initialize the
customer support optimization sample from this template:
https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/bring-your-own/responses/optimization-customer-support/azure.yaml
Resolve the AZD environment and hosted-agent service, verify that the agent is
optimizer-ready, and deploy and invoke the baseline. Generate and show me the
evaluation dataset, evaluators, and eval.yaml before running optimization.
Verify that the project has a supported optimization model deployment, then run
Agent Optimizer with two candidates. Stop after reporting the operation ID,
portal URL, candidate IDs, and scores. Don't apply or deploy a candidate yet.

De coderingsagent kan u vragen om een abonnement, regio, Foundry-project, agentservice, evaluatiemodel of optimalisatiemodel te selecteren wanneer deze waarden niet kunnen worden omgezet in de werkruimte. Controleer de gegenereerde bestanden en kostenveroorzakende resources voordat u wijzigingen of opdrachten goedkeurt.

Stap 3: Een goedgekeurde kandidaat toepassen en implementeren

Nadat u de optimalisatieresultaten hebt bekeken, dient u deze vervolgprompt in:

Recommend the best optimization candidate and explain the score improvement.
Summarize the candidate changes before applying anything. After I approve the
candidate, apply it locally, show the source diff, and stop again before
deployment. After I approve deployment, run azd deploy, invoke the agent with
"What is your return policy?", and rerun the evaluation to confirm the
improvement.

De vaardigheid gebruikt azd ai agent optimize apply --candidate <candidate-id> zodat u de geoptimaliseerde configuratie lokaal kunt bekijken. Deze wordt pas geïmplementeerd na uw goedkeuring en roept vervolgens de bijgewerkte gehoste agent aan en evalueert deze.