Szybki start: optymalizowanie hostowanego agenta (wersja zapoznawcza)

• azd CLI (interfejs wiersza polecenia dla deweloperów platformy Azure).

• Azure CLI na potrzeby uwierzytelniania.

• Rozszerzenie microsoft.foundry do azd (wersja 0.1.40-preview lub nowsza zależności azure.ai.agents):

  azd ext install microsoft.foundry
  

  Jeśli już zainstalowano, uaktualnij:

  azd ext upgrade microsoft.foundry
  

• Azure CLI na potrzeby uwierzytelniania.

• Python 3.10 lub nowszy.

• Pakiety Python używane w tej ścieżce:

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

• Istniejący projekt foundry, który zawiera już hostowanego agenta, zarejestrowany zestaw danych i ewaluatora, którego chcesz użyć do optymalizacji.

• Azure CLI na potrzeby uwierzytelniania.

• zestaw SDK platformy .NET 10 lub nowszy.

• Pakiety .NET używane w tej ścieżce.

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

• Istniejący projekt foundry, który zawiera już hostowanego agenta, zarejestrowany zestaw danych i ewaluatora, którego chcesz użyć do optymalizacji.

• Visual Studio Code.

• Microsoft Foundry Toolkit for Visual Studio Code w wersji 1.6.4 lub nowszej, z zalogowanym kontem w usłudze Azure. Narzędzie Foundry Toolkit instaluje i aktualizuje umiejętności Microsoft Foundry używane przez ten przepływ pracy.

• GitHub Copilot w Visual Studio Code z dostępem do trybu agenta. Zestaw narzędzi Foundry wysyła żądanie optymalizatora agentów do GitHub Copilot po wybraniu obszaru roboczego agenta.

• Azure CLI i Azure Developer CLI (AZD) zainstalowane i uwierzytelnione:

  az login
  azd auth login
  

• Host dla agenta kodującego z zainstalowaną funkcją Microsoft Foundry Skill.

• Azure CLI i Azure Developer CLI (AZD) zainstalowane i uwierzytelnione:

  az login
  azd auth login
  

• microsoft.foundry Rozszerzenie AZD. Zainstaluj go przed uruchomieniem przepływu pracy:

  azd ext install microsoft.foundry
  

  Jeśli jest już zainstalowany, uaktualnij go:

  azd ext upgrade microsoft.foundry
  

Krok 1. Tworzenie projektu

Zainicjuj nowy projekt na podstawie przykładowego szablonu optymalizacji:

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

Ten szablon importuje przykład „Optimization Customer Support” — hostowanego agenta Python gotowego do optymalizacji, który korzysta z podejścia „bring your own” oraz protokołu Responses. Reprezentuje on agenta pomocy technicznej dla elektroniki konsumenckiej, który obsługuje zapytania dotyczące zamówień, zwrotów, oświadczeń gwarancji, rozwiązywania problemów, skarg, zaleceń i eskalacji. Celowo minimalna instrukcja odniesienia sprawia, że ulepszenia optymalizacji instrukcji i odnajdywania umiejętności są łatwe do porównania.

Przykład używa load_config(), aby załadować konfigurację bazową lub konfigurację kandydata, i zawiera .agent_configs/baseline/, eval.yaml, zestawy danych do pełnej i szybkiej oceny, konfigurację kontenera oraz manifest wdrożenia Foundry. Interaktywny przepływ importuje te pliki i prosi o podanie subskrypcji platformy Azure, regionu oraz ustawień wdrożenia modelu.

Krok 2. Aprowizuj i wdróż

Uwierzytelnij i aprowizuj zasoby platformy Azure:

az login
azd auth login
azd provision

Proces aprowizacji trwa około dwóch minut i tworzy konto Foundry, projekt, usługę Azure Container Registry oraz wdrożenia modeli.

Wdróż agenta:

azd deploy

Przetestuj wdrożenie:

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

Krok 3. Generowanie pakietu ewaluacyjnego i optymalizowanie

Wygeneruj zestaw danych do oceny i moduły oceniające dla swojego agenta:

azd ai agent eval generate

Ten krok umożliwia utworzenie eval.yamlzestawu danych testowych i ocenianie ewaluatorów na podstawie instrukcji agenta. Optymalizator używa tych plików do mierzenia poprawy.

Uruchom optymalizator:

azd ai agent optimize --max-candidates 2

Interfejs wiersza polecenia monituje o wybranie modelu optymalizacji. Aby pominąć monit, przekaż go bezpośrednio:

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

CLI wykrywa agenta na podstawie azure.yaml i automatycznie używa wygenerowanego eval.yaml. Dzięki dwóm kandydatom optymalizacja zwykle kończy się w ciągu około 8 minut. Wyświetlany jest postęp w czasie rzeczywistym:

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>

Użyj adresu URL portalu, aby monitorować swoje zadanie w portalu Foundry.

Model oceny ocenia każdą odpowiedź (działa dowolny model uzupełniania czatów). Model optymalizacji (--optimize-model) generuje ulepszonych kandydatów i musi pochodzić z listy obsługiwanych (rodzina gpt-5 lub DeepSeek). Można również ustawić optimization_model pod options: w eval.yaml, aby uniknąć przekazywania flagi za każdym razem.

Krok 4: Wdróż zwycięzcę

Gwiazdka (*) w danych wyjściowych wskazuje najlepszego kandydata. Zastosuj zoptymalizowaną konfigurację lokalnie, a następnie wdróż:

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

Polecenie apply pobiera zoptymalizowaną konfigurację do .agent_configs/<candidate_id>/ i aktualizuje plik azure.yaml, tak aby używał nowych instrukcji. Polecenie deploy wdraża zoptymalizowanego agenta na środowisko produkcyjne za pomocą usługi CodeDeploy.

Uruchom agenta, aby zweryfikować ulepszenie:

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

Możesz również uruchomić ocenę, aby potwierdzić poprawę oceny:

azd ai agent eval run

ścieżka zestawu SDK Python

Wykonaj poniższe kroki, jeśli chcesz uruchomić optymalizator z Python zamiast przepływu pracy interfejsu wiersza polecenia dewelopera Azure opisanego wcześniej.

Ta ścieżka zakłada, że masz już następujące zasoby w istniejącym projekcie Foundry:

• Hostowany agent służący do optymalizacji.
• Zarejestrowany zbiór danych treningowych.
• Zarejestrowany ewaluator.

W przeciwieństwie do opisanego wcześniej przepływu pracy Azure Developer CLI, ścieżka użycia zestawu SDK języka Python nie tworzy szkieletu projektu ani nie generuje za Ciebie elementu eval.yaml, zestawu danych ani modułów oceniających. Jeśli chcesz, aby przykład automatycznie utworzył te zasoby, użyj azd ai agent eval generate najpierw.

1. Tworzenie .env pliku

Utwórz folder roboczy, a następnie dodaj .env plik z następującymi wartościami:

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>

Uruchom skrypt z tego samego folderu roboczego, aby load_dotenv() automatycznie załadować .env plik. Jeśli wolisz uruchomić go z innego katalogu, najpierw ustaw te same wartości w środowisku powłoki.

Użyj dokładnego punktu końcowego projektu na stronie Przegląd projektu Foundry. Skrypt Python natychmiast wysyła swoje pierwsze żądanie. Jeśli FOUNDRY_PROJECT_ENDPOINT jest tylko symbolem zastępczym lub wskazuje na niewłaściwy projekt, uruchomienie kończy się błędem ResourceNotFound: The project does not exist.

Ustaw EVAL_MODEL i OPTIMIZATION_MODEL jako nazwy wdrożeń istniejących już w projekcie Foundry, a nie tylko nazwy rodzin modeli. Jeśli na przykład wdrożenie projektu ma nazwę gpt-4.1-mini lub DeepSeek-V3.2, użyj tej dokładnej nazwy wdrożenia w pliku .env.

2. Uruchamianie zadania optymalizacji

Utwórz plik o nazwie optimize_hosted_agent.py w tym samym folderze co .env:

import os
import time

from azure.ai.agentserver.optimization import load_config
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
  OptimizedAgentIdentifier,
  AgentOptimizationEvaluatorRef,
  AgentOptimizationJob,
  AgentOptimizationJobInputs,
  AgentOptimizationOptions,
  AgentOptimizationReferenceDatasetInput,
)
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"))

optimization_config = load_config() # Reads agent optimization config from .agent_configs/baseline/metadata.yaml

with (
  DefaultAzureCredential() as credential,
  AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
  job = AgentOptimizationJob(
    inputs=AgentOptimizationJobInputs(
      agent=OptimizedAgentIdentifier(agent_name=agent_name),
      train_dataset=AgentOptimizationReferenceDatasetInput(
        name=dataset_name,
        version=dataset_version,
      ),
      evaluators=[AgentOptimizationEvaluatorRef(name=evaluator_name)],
      options=AgentOptimizationOptions(
        max_candidates=2,
        eval_model=eval_model,
        optimization_model=optimization_model,
        optimization_config={
          "system_prompt": optimization_config.instructions,
          **({"tools": optimization_config.tool_definitions} if optimization_config.tool_definitions else {}),
          **({"skills": optimization_config.skills} if optimization_config.has_skills else {}),
        }
      ),
    )
  )
  poller = project_client.beta.agents.begin_create_optimization_job(job=job)
  print(f"Optimization job ID: {poller.details.job_id}")

  print(f"Optimization job started, waiting for completion...")
  while not poller.done():
    print(f"\tstatus=`{poller.status()}`")
    time.sleep(poll_interval_seconds)

  result = poller.result()

  if result:
    print(f"Baseline candidate: {result.baseline}")
    print(f"Best candidate: {result.best}")

    for candidate in result.candidates or []:
      print(
        f"{candidate.name}: candidate_id={candidate.candidate_id}, "
        f"avg_score={candidate.avg_score:.4f}, "
        f"avg_tokens={candidate.avg_tokens:.0f}"
      )

Uruchom skrypt:

python optimize_hosted_agent.py

Identyfikator zadania optymalizacji jest drukowany natychmiast po przesłaniu; służy do monitorowania postępu w portalu Foundry.

Gdy zadanie zakończy się pomyślnie, skrypt wyświetli zwycięskiego kandydata i jego candidate_id.

W przeciwieństwie do azd ai agent optimize, przepływ w zestawie SDK języka Python nie tworzy lokalnego pliku .agent_configs/baseline/metadata.yaml. Metadane zadania optymalizacji pozostają dostępne w zwróconym obiekcie job oraz w odpowiedzi usługi Foundry, w tym: kandydat bazowy, najlepszy kandydat oraz lista ocenionych kandydatów.

3. Zastosuj zwycięskiego kandydata

Jeśli pracujesz również w lokalnym projekcie azd, używanym w opisanym powyżej przepływie CLI, zastosuj wybranego kandydata, używając elementu candidate_id zwróconego przez skrypt w Pythonie:

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

Jeśli chcesz tylko sprawdzić wynik, użyj ocen kandydatów i identyfikatorów oceny wypisanych przez skrypt, aby przejrzeć zwycięską konfigurację w Foundry przed jej wdrożeniem.

Ścieżka zestawu SDK języka C#

Wykonaj poniższe kroki, jeśli chcesz uruchomić optymalizator z .NET zamiast korzystać z przepływu pracy interfejsu wiersza polecenia dewelopera Azure opisanego wcześniej.

Ta ścieżka zakłada, że masz już następujące zasoby w istniejącym projekcie Foundry:

• Hostowany agent służący do optymalizacji.
• Zarejestrowany zbiór danych treningowych.
• Zarejestrowany moduł oceniający, taki jak wbudowany moduł oceniający builtin.task_adherence.

W przeciwieństwie do opisanego wcześniej przepływu pracy w Azure Developer CLI ścieżka zestawu SDK platformy .NET nie tworzy szkieletu projektu ani nie generuje dla Ciebie elementu eval.yaml, zestawu danych ani ewaluatorów. Jeśli chcesz, aby przykład automatycznie utworzył te zasoby, użyj azd ai agent eval generate najpierw.

1. Ustawianie zmiennych środowiskowych

Utwórz aplikację konsolową, a następnie ustaw te wartości w powłoce przed jej uruchomieniem:

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>

Użyj dokładnego punktu końcowego projektu na stronie Przegląd projektu Foundry.

Ustaw EVAL_MODEL i OPTIMIZATION_MODEL jako nazwy wdrożeń istniejących już w projekcie Foundry, a nie tylko nazwy rodzin modeli. Model optymalizacji musi być modelem rozumowania, który obsługuje optymalizator. Jeśli wybierzesz nieobsługiwane wdrożenie, usługa zwróci błąd, który zawiera listę dozwolonych modeli.

2. Uruchamianie zadania optymalizacji

Zastąp element Program.cs poniższym kodem.

Optymalizacja agenta jest funkcją w wersji zapoznawczej, więc żądanie wymaga nagłówka funkcji AgentsOptimization=V2Preview. Klasa FoundryFeaturesPolicy w tym przykładzie dodaje ten nagłówek do każdego żądania wysyłanego przez klienta:

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

#pragma warning disable AAIP001

// Adds the preview 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}");
            }
        }
    }
}

Uruchom aplikację:

dotnet run

Gdy zadanie zakończy się pomyślnie, aplikacja wyświetli zwycięskiego kandydata oraz jego 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

W przeciwieństwie do azd ai agent optimize, proces SDK platformy .NET nie tworzy lokalnego pliku .agent_configs/baseline/metadata.yaml. Metadane zadania optymalizacji są zachowywane w zwracanym obiekcie zadania oraz w odpowiedzi usługi Foundry, w tym kandydat bazowy, najlepszy kandydat i lista ocenionych kandydatów.

3. Zastosuj zwycięskiego kandydata

Jeśli pracujesz również na lokalnym projekcie azd używanym w przepływie CLI, zastosuj wybranego kandydata za pomocą wartości candidate_id zwróconej przez aplikację:

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

Jeśli chcesz tylko zweryfikować wynik, użyj ocen kandydatów i identyfikatorów oceny wyświetlanych przez aplikację, aby przejrzeć zwycięską konfigurację w Foundry przed jej promowaniem.

Uruchamianie optymalizacji w programie VS Code

Zestaw narzędzi Foundry Toolkit zawiera natywne środowisko optymalizacji agenta dla wdrożonych hostowanych agentów. Na placu zabaw agenta możesz rozpocząć przebieg optymalizacji, porównać kandydatów z punktem odniesienia, sprawdzić zmiany konfiguracji i wdrożyć najlepszego kandydata.

Krok 1. Wybieranie wdrożonego hostowanego agenta

1. Wybierz pozycję Foundry Toolkit na pasku działań.
2. W obszarze Moje zasoby wybierz pozycję Agenci.
3. Jeśli masz wdrożonego hostowanego agenta, wybierz go, aby otworzyć środowisko testowe hostowanego agenta.
4. Jeśli nie masz wdrożonego agenta hostowanego, ukończ ścieżkę programu VS Code w przewodniku Szybki start: wdrażanie pierwszego hostowanego agenta. Po zakończeniu wdrażania wróć do pozycji Agenci i wybierz nowego hostowanego agenta.

Krok 2. Uruchamianie przebiegu optymalizacji

1. Wybierz kartę Optymalizacja , która jest oznaczona jako Wersja zapoznawcza.

1. Wybierz pozycję Nowa optymalizacja.

2. W Wybierz obszar roboczy wybierz obszar roboczy zawierający kod wybranego agenta hostowanego:

   • Wybierz Bieżący obszar roboczy, jeśli bieżący obszar roboczy zawiera kod agenta i plik azure.yaml.
   • Wybierz pozycję Przeglądaj..., aby otworzyć obszar roboczy zawierający kod agenta.

   Zestaw narzędzi Foundry używa plików obszaru roboczego do przygotowania optymalizacji i zastosowania kandydata do pasującej azure.ai.agent usługi.

1. Foundry Toolkit otwiera czat GitHub Copilot i wysyła żądanie do funkcji Agent Optimizer, uzupełnione o rodzaj i nazwę wybranego agenta oraz punkt końcowy projektu Foundry.

2. Odpowiedz na cztery pytania dotyczące optymalizacji w Copilot Chat:

   Dane wejściowe	Co należy podać
   Metryki oceny	Wprowadź metryki lub ewaluatory do użycia. Jeśli ich nie masz, wybierz, czy uruchamiać azd ai agent eval generate , czy używać wbudowanych wartości domyślnych optymalizatora.
   Dataset	Wybierz zestaw danych optymalizacji. Jeśli go nie masz, wybierz, czy uruchamiać azd ai agent eval generate , czy używać wbudowanych wartości domyślnych optymalizatora.
   Maksymalna liczba kandydatów	Wprowadź maksymalną liczbę kandydatów do wygenerowania, na przykład 2.
   Model optymalizacji	Wybierz istniejące wdrożenie z obsługiwanych modeli optymalizacji.

GitHub Copilot czeka na te dane wejściowe przed rozpoczęciem optymalizacji. Wygenerowane żądanie nakazuje Copilotowi korzystanie wyłącznie z przepływu pracy Optymalizatora agenta w Microsoft Foundry Skill oraz z poleceń narzędzia Azure Developer CLI. Nie korzysta z narzędzi McP firmy Foundry. Copilot:

• Sprawdza kod agenta w wybranym obszarze roboczym.
• Inicjuje środowisko AZD na podstawie istniejących wartości azure.yaml i .env, jeśli projekt jeszcze go nie posiada.
• Konfiguruje agenta pod kątem optymalizacji i wdraża zaktualizowanego agenta hostowanego.
• Tworzy eval.yaml w folderze usługi agenta.
• Uruchamia optymalizację po przejrzeniu i zatwierdzeniu proponowanych zmian plików i poleceń.

Po przesłaniu zadania przez aplikację Copilot wróć do karty Optymalizacja. Uruchomienie pojawi się w sekcji Uruchomienia optymalizacji. Tabela przedstawia identyfikator przebiegu, status, liczbę kandydatów, wynik bazowy, najlepszy wynik i czas utworzenia.

Krok 3. Porównanie i wdrażanie najlepszego kandydata

1. Gdy przebieg zakończy się pomyślnie, wybierz go w obszarze Przebiegi optymalizacji.
2. Porównaj wyniki bazowe i najlepsze. Przejrzyj szczegóły oceny dla każdego kandydata i wybierz pozycję Wyświetl zmiany , aby sprawdzić zmiany konfiguracji.
3. Jeśli najlepszy kandydat poprawi się w punkcie odniesienia, wybierz pozycję Wdróż najlepszego kandydata , aby zaktualizować bieżącego agenta. Aby wdrożyć go jako nowego agenta lub zmienić ustawienia wdrożenia, wybierz zamiast tego pozycję Wdrożenie niestandardowe.

Uruchamianie optymalizacji za pomocą umiejętności Microsoft Foundry

Użyj tej ścieżki w dowolnym hoście agenta kodującego, który obsługuje Microsoft Foundry Skill, takim jak GitHub Copilot w Visual Studio Code, Copilot CLI lub Claude Code. Funkcja ustala kontekst agenta na podstawie azure.yaml, ładuje jego przepływ pracy Agent Optimizer oraz utrzymuje kandydującą wersję aplikacji i wdrożenie na etapach weryfikacji.

Krok 1. Otwieranie obszaru roboczego agenta

Otwórz pusty folder na hoście agenta kodowania. Upewnij się, że umiejętność microsoft-foundry jest dostępna. Jeśli umiejętności nie są dostępne, wykonaj czynności opisane w temacie Use the Microsoft Foundry Skill in coding agents (Używanie umiejętności Microsoft Foundry w agentach kodowania).

Krok 2: Poproś funkcję o uruchomienie Agent Optimizer

Prześlij ten monit do agenta kodowania:

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.

Agent kodowania może poprosić o wybranie subskrypcji, regionu, projektu Foundry, usługi agenta, modelu oceny lub modelu optymalizacji, gdy nie może rozpoznać tych wartości z obszaru roboczego. Przed zatwierdzeniem jakichkolwiek zmian lub poleceń przejrzyj wygenerowane pliki i zasoby generujące koszty.

Krok 3. Stosowanie i wdrażanie zatwierdzonego kandydata

Po przejrzeniu wyników optymalizacji prześlij następujący monit:

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.

Umiejętność używa azd ai agent optimize apply --candidate <candidate-id>, aby można było lokalnie przejrzeć zoptymalizowaną konfigurację. System jest wdrażany dopiero po Twoim zatwierdzeniu, a następnie wywołuje i ocenia zaktualizowanego hostowanego agenta.