Démarrage rapide : Optimiser un agent hébergé

• azd CLI (Azure Developer CLI).

• Azure CLI pour l’authentification.

• L’extension microsoft.foundry pour azd (version 0.1.40-preview ou ultérieure de la dépendance azure.ai.agents) :

  azd ext install microsoft.foundry
  

  Si elle est déjà installée, mettez à niveau :

  azd ext upgrade microsoft.foundry
  

• Azure CLI pour l’authentification.

• Python 3.10 ou version ultérieure.

• Packages Python utilisés dans ce chemin d’accès :

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

• Projet Foundry existant qui contient déjà l’agent hébergé, le jeu de données inscrit et l’évaluateur que vous souhaitez utiliser pour l’optimisation.

• Azure CLI pour l’authentification.

• .NET 10 SDK ou version ultérieure.

• Packages .NET utilisés dans ce chemin d’accès.

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

• Projet Foundry existant qui contient déjà l’agent hébergé, le jeu de données inscrit et l’évaluateur que vous souhaitez utiliser pour l’optimisation.

• Visual Studio Code.

• Microsoft Foundry Toolkit pour Visual Studio Code version 1.6.4 ou ultérieure, connecté à Azure. Foundry Toolkit installe et met à jour la compétence Microsoft Foundry utilisée dans ce flux de travail.

• GitHub Copilot en Visual Studio Code avec accès au mode agent. Foundry Toolkit envoie la demande d’optimiseur d’agent à GitHub Copilot après avoir sélectionné l’espace de travail de l’agent.

• Azure CLI et Azure Developer CLI (AZD) installés et authentifiés :

  az login
  azd auth login
  

• Hôte pour agent de codage sur lequel la Microsoft Foundry Skill est installée.

• Azure CLI et Azure Developer CLI (AZD) installés et authentifiés :

  az login
  azd auth login
  

• L’extension microsoft.foundry pour AZD. Installez-le avant de démarrer le flux de travail :

  azd ext install microsoft.foundry
  

  Si elle est déjà installée, mettez-la à niveau :

  azd ext upgrade microsoft.foundry
  

Étape 1 : Créer le projet

Initialisez un nouveau projet à partir de l’exemple de modèle d’optimisation :

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 .

Ce modèle importe l’exemple de support client d’optimisation, un assistant hébergé prêt à l’optimisation Python qui utilise l’approche bring-your-own et le protocole Réponses. Il représente un agent de support électronique grand public qui gère les demandes de commande, les retours, les réclamations de garantie, la résolution des problèmes, les plaintes, les recommandations et l’escalade. L’instruction de base minimale délibérément minimale facilite la comparaison des améliorations apportées à l’optimisation des instructions et à la découverte des compétences.

L’exemple appelle load_config() pour charger la configuration de base ou candidate et inclut .agent_configs/baseline/, eval.yaml, les jeux de données d’évaluation complète et rapide, la configuration du conteneur et le manifeste de déploiement Foundry. Le flux interactif importe ces fichiers et demande vos paramètres de déploiement de Azure abonnement, région et modèle.

Étape 2 : Provisionner et déployer

Authentifiez et approvisionnez les ressources Azure :

az login
azd auth login
azd provision

L’approvisionnement prend environ deux minutes et crée un compte Foundry, un projet, un Azure Container Registry et des déploiements de modèles.

Déployez l’agent :

azd deploy

Testez le déploiement :

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

Étape 3 : Générer une suite d’évaluation et optimiser

Générez un jeu de données d’évaluation et des évaluateurs pour votre agent :

azd ai agent eval generate

Cette étape crée eval.yaml, un jeu de données de test et des évaluateurs de notation en fonction des instructions de votre agent. L’optimiseur utilise ces fichiers pour mesurer l’amélioration.

Exécutez l’optimiseur :

azd ai agent optimize --max-candidates 2

L’interface CLI vous invite à sélectionner un modèle d’optimisation. Pour ignorer l’invite, transmettez-la directement :

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

L’interface en ligne de commande détecte votre agent à partir de azure.yaml et utilise automatiquement le eval.yaml généré. Avec deux candidats, l’optimisation se termine généralement en environ 8 minutes. La progression en temps réel s’affiche :

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>

Utilisez l’URL du portail pour surveiller votre travail dans le portail Foundry.

Le modèle d’évaluation évalue chaque réponse (n’importe quel modèle de complétion de conversation convient). Le modèle d’optimisation (--optimize-model) génère des candidats améliorés et doit provenir de la liste prise en charge (famille gpt-5 ou DeepSeek). Vous pouvez également le définir optimization_model sous options:eval.yaml pour éviter de passer l’indicateur à chaque fois.

Étape 4 : Déployer le gagnant

L’étoile (*) dans le résultat indique le meilleur candidat. Appliquez la configuration optimisée localement, puis déployez :

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

La apply commande télécharge la configuration optimisée dans .agent_configs/<candidate_id>/ et met à jour vos azure.yaml instructions pour utiliser les nouvelles instructions. La commande deploy déploie l’agent optimisé en production via CodeDeploy.

Appelez votre agent pour vérifier l’amélioration :

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

Vous pouvez également exécuter l’évaluation pour confirmer l’amélioration du score :

azd ai agent eval run

chemin d’accès du KIT de développement logiciel (SDK) Python

Utilisez les étapes suivantes si vous souhaitez exécuter l’optimiseur à partir de Python au lieu du flux de travail CLI du développeur Azure décrit précédemment.

Ce chemin suppose que vous disposez déjà des ressources suivantes dans un projet Foundry existant :

• Optimisation d’un agent hébergé.
• Un jeu de données d’entraînement enregistré.
• Évaluateur inscrit.

Contrairement au flux de travail Azure Developer CLI décrit précédemment, l’approche avec le SDK Python ne crée pas la structure d’un projet et ne génère pas eval.yaml, de jeu de données ni d’évaluateurs pour vous. Si vous souhaitez que l’exemple crée automatiquement ces ressources, utilisez azd ai agent eval generate d’abord.

1. Créer un .env fichier

Créez un dossier de travail, puis ajoutez un .env fichier avec ces valeurs :

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>

Exécutez le script à partir de ce même dossier de travail afin de load_dotenv() pouvoir charger le .env fichier automatiquement. Si vous préférez l’exécuter à partir d’un autre répertoire, définissez d’abord les mêmes valeurs dans votre environnement shell.

Utilisez le point de terminaison de projet exact à partir de la page Vue d’ensemble de votre projet Foundry. Le script Python envoie immédiatement sa première requête. Si FOUNDRY_PROJECT_ENDPOINT est seulement un espace réservé ou pointe vers le mauvais projet, l’exécution échoue avec ResourceNotFound: The project does not exist.

Définissez EVAL_MODEL et OPTIMIZATION_MODEL sur des noms de déploiement qui existent déjà dans votre projet Foundry, et pas seulement sur des noms de famille de modèles. Par exemple, si votre déploiement de projet est nommé gpt-4.1-mini ou DeepSeek-V3.2, utilisez ce nom de déploiement exact dans .env.

2. Exécuter le travail d’optimisation

Créez un fichier nommé optimize_hosted_agent.py dans le même dossier que .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 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))

Exécutez le script :

python optimize_hosted_agent.py

L’ID de travail d’optimisation s’imprime immédiatement après l’envoi ; utilisez-la pour surveiller la progression dans le portail Foundry.

Lorsque la tâche réussit, le script affiche le candidat retenu et son candidate_id.

Contrairement à azd ai agent optimize, le processus du SDK Python ne crée pas de fichier local .agent_configs/baseline/metadata.yaml. Les métadonnées du travail d’optimisation restent dans l’objet retourné job et dans la réponse du service Foundry, y compris le candidat de référence, le meilleur candidat et la liste des candidats marqués.

3. Appliquer le candidat gagnant

Si vous travaillez également dans le projet local azd utilisé dans le flux CLI ci-dessus, appliquez le candidat retenu à l’aide de candidate_id, renvoyé par le script Python :

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

Si vous devez uniquement inspecter le résultat, utilisez les scores et identificateurs d’évaluation des candidats imprimés par le script pour passer en revue la configuration gagnante dans Foundry avant de la promouvoir.

Chemin du SDK C#

Utilisez les étapes suivantes si vous souhaitez exécuter l’optimiseur à partir de .NET au lieu d’utiliser le flux de travail CLI Azure développeur décrit précédemment.

Ce chemin suppose que vous disposez déjà des ressources suivantes dans un projet Foundry existant :

• Optimisation d’un agent hébergé.
• Un jeu de données d’entraînement enregistré.
• Évaluateur inscrit, tel que l’évaluateur intégré builtin.task_adherence .

Contrairement au flux de travail Azure Developer CLI décrit précédemment, l’approche du SDK .NET ne génère pas la structure d’un projet ni eval.yaml, un jeu de données ou des évaluateurs pour vous. Si vous souhaitez que l’exemple crée automatiquement ces ressources, utilisez azd ai agent eval generate d’abord.

1. Définir vos variables d’environnement

Créez une application console, puis définissez ces valeurs dans votre interpréteur de commandes avant de l’exécuter :

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>

Utilisez le point de terminaison de projet exact à partir de la page Vue d’ensemble de votre projet Foundry.

Définissez EVAL_MODEL et OPTIMIZATION_MODEL sur des noms de déploiement qui existent déjà dans votre projet Foundry, et pas seulement sur des noms de famille de modèles. Le modèle d’optimisation doit être un modèle de raisonnement pris en charge par l’optimiseur. Si vous choisissez un déploiement non pris en charge, le service retourne une erreur qui répertorie les modèles autorisés.

2. Exécuter le travail d’optimisation

Remplacez Program.cs par le code suivant.

L’optimisation de l’agent nécessite l’en-tête de fonctionnalité AgentsOptimization=V2Preview sur chaque requête. La FoundryFeaturesPolicy classe de cet exemple ajoute cet en-tête à chaque requête envoyée par le client :

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

Exécutez l’application :

dotnet run

Lorsque la tâche réussit, l’application affiche le candidat gagnant et son candidate_id:

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

Contrairement azd ai agent optimizeà ce qui est le cas, le flux du KIT de développement logiciel (SDK) .NET ne crée pas de fichier local.agent_configs/baseline/metadata.yaml. Les métadonnées de la tâche d’optimisation sont conservées dans l’objet de tâche renvoyé et dans la réponse du service Foundry, y compris le candidat de référence, le meilleur candidat et la liste des candidats évalués.

3. Appliquer le candidat gagnant

Si vous travaillez également depuis le projet local azd utilisé dans le flux CLI, appliquez le candidat retenu en utilisant le candidate_id renvoyé par l’application :

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

Si vous devez uniquement inspecter le résultat, utilisez les scores et identificateurs d’évaluation des candidats imprimés par l’application pour passer en revue la configuration gagnante dans Foundry avant de la promouvoir.

Exécuter l’optimisation dans VS Code

Foundry Toolkit inclut une expérience d’optimisation de l’agent native pour les agents hébergés déployés. À partir du terrain de jeu de l’agent, vous pouvez démarrer une exécution d’optimisation, comparer les candidats à la base de référence, inspecter les modifications de configuration et déployer le meilleur candidat.

Étape 1 : Sélectionner un agent hébergé déployé

1. Sélectionnez Foundry Toolkit dans la barre d’activité.
2. Sous Mes ressources, sélectionnez Agents.
3. Si vous avez déployé un agent hébergé, sélectionnez-le pour ouvrir le terrain de jeu de l’agent hébergé.
4. Si vous n’avez pas d’agent hébergé déployé, suivez le chemin d’accès VS Code dans le guide de démarrage rapide : Déployez votre premier agent hébergé. Une fois le déploiement terminé, revenez aux agents et sélectionnez le nouvel agent hébergé.

Étape 2 : Démarrer une exécution d’optimisation

1. Sélectionnez l’onglet Optimiser .

1. Sélectionnez Nouvelle optimisation.

2. Dans Sélectionner un espace de travail, choisissez l’espace de travail qui contient le code de l’agent hébergé sélectionné :

   • Sélectionnez Espace de travail actif si l’espace de travail actuel contient le code de l’agent et son azure.yaml fichier.
   • Sélectionnez Parcourir... pour ouvrir l’espace de travail qui contient le code de l’agent.

   Foundry Toolkit utilise les fichiers d’espace de travail pour préparer l’optimisation et appliquer un candidat au service correspondant azure.ai.agent .

1. Foundry Toolkit ouvre GitHub Copilot Chat et envoie une requête à l’Optimiseur d’agent contenant le type, le nom et le point de terminaison du projet Foundry de l’agent sélectionné.

2. Répondez aux quatre questions d’optimisation dans Copilot Chat :

   Input	Que fournir
   Mesures d’évaluation	Entrez les métriques ou évaluateurs à utiliser. Si vous ne les avez pas, choisissez d’exécuter azd ai agent eval generate ou d’utiliser les valeurs par défaut intégrées de l’optimiseur.
   Dataset	Sélectionnez le jeu de données d’optimisation. Si vous n’en avez pas, choisissez d’exécuter azd ai agent eval generate ou d’utiliser les valeurs par défaut intégrées de l’optimiseur.
   Nombre maximal de candidats	Entrez le nombre maximal de candidats à générer, comme 2.
   Modèle d’optimisation	Sélectionnez un déploiement existant à partir des modèles d’optimisation pris en charge.

GitHub Copilot attend ces entrées avant de commencer l’optimisation. La requête générée demande à Copilot d'utiliser exclusivement le flux de travail Agent Optimizer de Microsoft Foundry Skill et les commandes de l'interface Azure Developer CLI. Il n’utilise pas les outils Foundry MCP. Copilot :

• Inspecte le code de l’agent dans l’espace de travail sélectionné.
• Initialise un environnement AZD à partir des valeurs existantes azure.yaml et .env, si le projet n’en a pas déjà un.
• Configure l’assistant pour l’optimisation et déploie l’assistant hébergé mis à jour.
• Crée eval.yaml dans le dossier de service de l’agent.
• Démarre l’optimisation après avoir examiné et approuvé les modifications et commandes de fichier proposées.

Une fois que Copilot a envoyé la tâche, revenez à l’onglet Optimiser. L’exécution apparaît sous Exécutions d’optimisation. Le tableau affiche son ID d’exécution, son état, son nombre de candidats, son score de référence, son meilleur score et son heure de création.

Étape 3 : Comparer et déployer le meilleur candidat

1. Une fois l’exécution réussie, sélectionnez-la sous Optimisation.
2. Comparez les scores de référence et les meilleurs scores. Passez en revue les détails du score pour chaque candidat, puis sélectionnez Afficher les modifications pour inspecter ses modifications de configuration.
3. Si le meilleur candidat s’améliore sur la base de référence, sélectionnez Déployer le meilleur candidat pour mettre à jour l’agent actuel. Pour le déployer en tant que nouvel agent ou modifier les paramètres de déploiement, sélectionnez Déploiement personnalisé à la place.

Exécuter l’optimisation avec la compétence Microsoft Foundry

Utilisez ce chemin dans n’importe quel hôte d’agent de codage qui prend en charge la compétence Microsoft Foundry, telle que GitHub Copilot dans Visual Studio Code, Copilot CLI ou Claude Code. La compétence détermine le contexte de l’assistant à partir de azure.yaml, charge son workflow Agent Optimizer et maintient l’application candidate ainsi que son déploiement derrière des étapes de validation.

Étape 1 : Ouvrir l’espace de travail de l’agent

Ouvrez un dossier vide dans l’environnement hôte de votre agent de code. Vérifiez que la microsoft-foundry compétence est disponible. Si la compétence n'est pas disponible, suivez Utiliser la compétence Microsoft Foundry dans les agents de programmation.

Étape 2 : Demandez au skill d’exécuter Agent Optimizer

Envoyez cette invite à votre agent de codage :

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.

L’agent de codage peut vous demander de sélectionner un abonnement, une région, un projet Foundry, un service d’agent, un modèle d’évaluation ou un modèle d’optimisation lorsqu’il ne peut pas résoudre ces valeurs à partir de l’espace de travail. Passez en revue les fichiers générés et les ressources entraînant des coûts avant d’approuver toute modification ou commande.

Étape 3 : Appliquer et déployer un candidat approuvé

Après avoir examiné les résultats de l’optimisation, envoyez cette invite de suivi :

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.

La compétence utilise azd ai agent optimize apply --candidate <candidate-id> pour pouvoir passer en revue la configuration optimisée localement. Il ne se déploie qu’après votre approbation, puis appelle et évalue l’agent hébergé mis à jour.