Szybki start: jak utworzyć zestaw narzędzi i używać go z agentem hostowanym

Azure Developer CLI i workflow Visual Studio Code korzystają z przykładu przybornika Foundry. Deklaruje w nim azure.yaml źródła wyszukiwania w internecie, interpretera kodu i MCP dla specyfikacji interfejsu API REST Azure, GitHub, Azure Language i Microsoft Foundry. Trzy połączenia projektów zapewniają poświadczenia uwierzytelnionych źródeł i ustawienia tożsamości.

Przepływ pracy w zestawie SDK języka Python tworzy mniejszy przybornik z wyszukiwaniem w Internecie i publicznym serwerem Microsoft Learn MCP. Używa on kodu agenta przykładu bez wdrażania dodatkowych deklaracji połączenia i zestawu narzędzi przykładu.

Użyj azd wersji 1.34.2 lub nowszej i microsoft.foundry pakietu rozszerzeń zawierającego azure.ai.agents 1.0.0-beta.19 lub nowszą.

Zainstaluj Python 3.13 lub nowszą i przygotuj zależności zewnętrzne próbki przed zainicjowaniem:

Przykład nie tworzy zewnętrznych zasobów GitHub ani zasobów językowych. Podczas inicjalizacji pojawia się monit o nieuzupełnione wartości wejściowe zmiennych środowiskowych, w tym token i punkt końcowy języka, oraz przechowuje wartości w środowisku azd. Nie zatwierdzaj danych logowania, plików .env ani .azure.

Aby zapoznać się z konfiguracją uwierzytelniania, zobacz przewodnik dotyczący Microsoft Entra MCP z przykładu.

Jeśli korzystasz ze ścieżki SDK dla języka Python, użyj sekcji dotyczącej języka Python w dalszej części tego artykułu zamiast ścieżki Azure Developer CLI lub przepływu pracy w programie VS Code. To podejście tworzy toolbox za pomocą polecenia project_client.toolboxes.create_version(...), a następnie przesyła kod hostowanego agenta jako nową wersję i wskazuje ten toolbox po nazwie.

Zainstaluj pakiety Python używane w tej ścieżce:

pip install "azure-ai-projects>=2.3.0" python-dotenv

Potrzebujesz istniejącego projektu Foundry z wdrożonym modelem obsługującym czaty. Ścieżka Python SDK w tym przewodniku Szybki start tworzy zestaw narzędzi i wersję agenta hostowanego, ale nie generuje szkieletu nowego projektu Foundry ani nie tworzy wdrożenia modelu.

W przypadku zestawu SDK platformy .NET użyj sekcji dotyczącej języka C# w dalszej części tego artykułu zamiast interfejsu wiersza polecenia Azure Developer CLI lub przepływu pracy w programie VS Code. Ten sposób tworzy zestaw narzędzi za pomocą AgentToolboxes.CreateVersion(...), a następnie przesyła kod hostowanego agenta C# jako nową wersję i wskazuje na ten zestaw narzędzi po nazwie.

Potrzebujesz również zestawu .NET 10 SDK lub nowszego oraz istniejącego projektu Foundry z wdrożonym modelem obsługującym czat.

Potrzebujesz również programu Visual Studio Code z rozszerzeniem Microsoft Foundry Toolkit oraz zalogowania do platformy Azure.

Krok 1. Inicjowanie hostowanego agenta

W terminalu utwórz pusty katalog i zainicjuj w nim cały przykładowy projekt:

mkdir my-toolbox-agent && cd my-toolbox-agent
azd ai agent init --template "https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/04-foundry-toolbox/azure.yaml" --src .

Wybierz lub utwórz projekt Foundry i wprowadź zewnętrzne wartości wejściowe przygotowane w sekcji Wymagania wstępne. Aby ponownie użyć wdrożenia modelu w istniejącym projekcie, dodaj --model-deployment <existing-deployment-name> do polecenia inicjowania. Przejęcie szablonu nie zapewnia obecnie selektora istniejącego wdrożenia.

Opcja --src . wybiera katalog główny projektu, a nie podkatalog agent-source. Pozostań w my-toolbox-agent, który teraz zawiera azure.yaml, dla następnych poleceń azd. Źródło agenta pozostaje pod src/agent-framework-agent-with-foundry-toolbox-responses.

Przed aprowizowaniem przejrzyj deklarację modelu i ustawienia agenta w azure.yaml. Aby później zmienić zewnętrzne dane wejściowe, uruchom polecenie azd env set <name> <value> z poziomu tego katalogu głównego projektu; nie uruchamiaj innego azd init.

W przypadku agenta Python upewnij się, że jego usługa w azure.yaml zawierała PYTHONNOUSERSITE: "1" w istniejącej mapie env przed uruchomieniem i wdrożeniem. Nie polegaj na ładowaniu tego ustawienia wewnątrz aplikacji. Aby uzyskać wskazówki dotyczące zgodności zależności, zobacz Konfigurowanie uruchamiania Pythona.

Otwórz zainicjowany folder projektu w Visual Studio Code. Uruchom następujące polecenia w zintegrowanym terminalu. Ten przepływ pracy używa elementu przykładu azure.yaml do wdrażania połączeń, przybornika i agenta razem; nie twórz oddzielnego przybornika z tym samym celem w Przyborniku.

Krok 2: Utwórz przybornik

Przykład deklaruje agent-tools zestaw narzędzi jako azure.ai.toolbox usługę. Jego uses wpisy odwołują się do projektu i połączeń; usługa agenta odwołuje się do Toolbox. Edytuj te deklaracje w azure.yaml, aby zmienić narzędzia lub połączenia.

Nie potrzebujesz oddzielnego toolbox.yaml ani ręcznego azd ai toolbox create polecenia dla tego przepływu pracy. W następnym kroku są wdrażane deklaracje w kolejności zależności. Sama aprowizacja nie tworzy toolboxa, a uruchamianie agenta lokalnego nie tworzy żadnych zależności zdalnych.

Krok 3. Aprowizuj zasoby Azure

Istniejący projekt Foundry może nadal potrzebować zasobów zadeklarowanych przez szablon, takich jak wdrożenie modelu. Przejrzyj konfigurację, a następnie zaaprowizuj zasoby Azure projektu, tak aby została utworzona tożsamość zarządzana projektu:

azd provision

Przed wdrożeniem przyznaj tożsamości zarządzanej projektu rolę Cognitive Services Language Owner dla istniejącego zasobu Language zgodnie z opisem w wymaganiach wstępnych. Użyj tożsamości projektu, a nie tożsamości konta nadrzędnego usługi Foundry ani własnej tożsamości użytkownika. Odczekaj, aż przypisanie roli się propaguje.

Następnie wdróż połączenia, Toolbox i hostowanego agenta razem:

azd deploy --all

Wdrożenie przybornika powoduje utworzenie TOOLBOX_AGENT_TOOLS_MCP_ENDPOINT. Deklaracja agenta env mapuje tę wersję punktu końcowego na TOOLBOX_ENDPOINT. Sprawdź dane wyjściowe z katalogu głównego projektu:

azd env get-value TOOLBOX_AGENT_TOOLS_MCP_ENDPOINT

Nie zastępuj tego powiązania punktem końcowym dla oddzielnie utworzonego zestawu narzędzi.

Krok 4. Uruchamianie agenta lokalnie

Najpierw ukończ aprowizację, autoryzację tożsamości zarządzanej i wdrożenie w kroku 3. Agent lokalny nadal używa połączeń zdalnych i przybornika; azd ai agent run nie tworzy ich. Przykład obsługuje za Ciebie połączenie z Toolbox, nagłówki i uwierzytelnianie.

1. Po wdrożeniu zależności zdalnych uruchom agenta z poziomu katalogu głównego projektu:

   azd ai agent run
   

   To polecenie tworzy środowisko wirtualne, instaluje zależności i obsługuje agenta na platformie http://localhost:8088. Konfiguracja usługi dostarcza FOUNDRY_PROJECT_ENDPOINT, AZURE_AI_MODEL_DEPLOYMENT_NAMEi TOOLBOX_ENDPOINT. Nie zastąp tych wartościami zastępczymi w pliku źródłowym .env .

2. W osobnym terminalu z poziomu tego samego katalogu głównego projektu sprawdź dostępne narzędzia i przećwicz wyszukiwanie w Internecie:

   azd ai agent invoke --local "List the tools you can use."
   azd ai agent invoke --local "Find the latest release notes for the Azure CLI on the web."
   

W przypadku debugowania w programie VS Code otwórz zainicjowany projekt i postępuj zgodnie z instrukcjami programu VS Code z przykładu. W przypadku przebiegów F5 lub samodzielnych uruchomień Pythona ustaw TOOLBOX_ENDPOINT w pliku .env folderu źródłowego agenta na dane wyjściowe:

azd env get-value TOOLBOX_AGENT_TOOLS_MCP_ENDPOINT

Ustaw również FOUNDRY_PROJECT_ENDPOINT punkt końcowy projektu i AZURE_AI_MODEL_DEPLOYMENT_NAME nazwę wdrożenia modelu. Nie przechowuj .env w kontroli wersji.

Krok 5. Wdrażanie w usłudze agenta programu Foundry

Krok 3 już udostępnia hostowanego agenta. Po zmianie narzędzi, połączeń lub kodu agenta wdróż wszystkie usługi razem:

azd deploy --all

To polecenie aktualizuje toolbox i wdraża agenta z użyciem wynikowego wersjonowanego punktu końcowego. Przepływ pracy wdrażania tylko agenta programu VS Code nie aktualizuje przybornika ani jego połączeń.

Po zakończeniu polecenia dane wyjściowe zawierają linki do placu zabaw agenta i punktu końcowego agenta. Wywołaj wdrożonego agenta:

azd ai agent invoke "List the tools you can use."

W przykładzie użyto wersjonowanego punktu końcowego wygenerowanego przez to wdrożenie. Nie wymaga to ustawienia wersji toolboxa jako domyślnej ani przekierowania innych agentów korzystających ze starszej wersji.

ścieżka zestawu SDK Python

Wykonaj poniższe kroki, jeśli chcesz utworzyć zestaw narzędzi i wdrożyć wersję z hostowanym agentem przy użyciu zestawu SDK języka Python zamiast korzystać z przepływu pracy Azure Developer CLI lub programu VS Code.

1. Tworzenie lub wybieranie projektu Foundry

1. Otwórz portal Foundry i utwórz projekt Foundry lub wybierz istniejący.
2. W projekcie wdróż model obsługujący czaty, taki jak gpt-5.4-mini.
3. Skopiuj punkt końcowy projektu z sekcji Przegląd oraz nazwę wdrożenia z Kompilacja>Wdrożenia.

2. Pobierz przykład hostowanego agenta z zestawu narzędzi

Sklonuj repozytorium przykładów Foundry:

git clone https://github.com/microsoft-foundry/foundry-samples.git

Utwórz folder roboczy dla skryptów wdrażania. W tym folderze utwórz plik .env z następującymi wartościami:

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
AZURE_AI_MODEL_DEPLOYMENT_NAME=<your-model-deployment-name>
FOUNDRY_HOSTED_AGENT_NAME=toolbox-agent
TOOLBOX_NAME=my-toolbox
FOUNDRY_SAMPLE_PATH=<full-path-to-foundry-samples/samples/python/hosted-agents/agent-framework/responses/04-foundry-toolbox/src/agent-framework-agent-with-foundry-toolbox-responses>

3. Utwórz zestaw narzędzi za pomocą Pythona

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

import os

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import MCPToolboxTool, WebSearchToolboxTool
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"].rstrip("/")
toolbox_name = os.environ["TOOLBOX_NAME"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
    created = project_client.toolboxes.create_version(
        name=toolbox_name,
        description="Toolbox with web search and Microsoft Learn MCP.",
        tools=[
            WebSearchToolboxTool(
                name="web_search",
                search_context_size="medium",
            ),
            MCPToolboxTool(
                server_label="mslearn",
                server_url="https://learn.microsoft.com/api/mcp",
                require_approval="never",
            ),
        ],
    )
    print(f"Created toolbox version {created.version} for {created.name}")

    mcp_endpoint = (
        f"{endpoint}/toolboxes/{created.name}/versions/"
        f"{created.version}/mcp?api-version=v1"
    )
    print(f"Toolbox version: {created.version}")
    print(f"Toolbox MCP endpoint: {mcp_endpoint}")

Uruchom skrypt:

python create_toolbox.py

Przykładowy hostowany agent może odnaleźć zestaw narzędzi albo z TOOLBOX_ENDPOINT, albo z FOUNDRY_PROJECT_ENDPOINT w połączeniu z TOOLBOX_NAME. Ta ścieżka używa TOOLBOX_NAME, więc nie trzeba przechowywać endpointu z wersją w .env.

4. Wdrażanie hostowanego agenta przy użyciu Python

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

import os
import tempfile
import time
import zipfile
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    AgentEndpointConfig,
    CodeConfiguration,
    CodeDependencyResolution,
    FixedRatioVersionSelectionRule,
    HostedAgentDefinition,
    ProtocolConfiguration,
    ProtocolVersionRecord,
    ResponsesProtocolConfiguration,
    VersionSelector,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
model_name = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]
agent_name = os.environ.get("FOUNDRY_HOSTED_AGENT_NAME", "toolbox-agent")
toolbox_name = os.environ["TOOLBOX_NAME"]
sample_path = Path(os.environ["FOUNDRY_SAMPLE_PATH"]).resolve()


def create_code_zip(source_dir: Path) -> Path:
    zip_path = Path(tempfile.gettempdir()) / f"{agent_name}.zip"
    excluded = {".git", ".venv", "__pycache__", ".env"}

    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
        for path in source_dir.rglob("*"):
            if not path.is_file():
                continue
            if any(part in excluded for part in path.parts):
                continue
            zip_file.write(path, path.relative_to(source_dir))

    return zip_path


def wait_for_active_version(project_client: AIProjectClient, version: str) -> None:
    for attempt in range(60):
        time.sleep(10)
        details = project_client.agents.get_version(
            agent_name=agent_name,
            agent_version=version,
        )
        status = details["status"]
        print(f"Provisioning status: {status} (attempt {attempt + 1}/60)")

        if status == "active":
            return

        if status == "failed":
            raise RuntimeError(f"Hosted agent provisioning failed: {dict(details)}")

    raise RuntimeError("Timed out waiting for the hosted agent version to become active.")


code_zip_path = create_code_zip(sample_path)

with (
    code_zip_path.open("rb") as code_stream,
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
    original_agent_endpoint = None
    created = None

    try:
        created = project_client.agents.create_version_from_code(
            agent_name=agent_name,
            description="Hosted agent with Foundry Toolbox integration.",
            definition=HostedAgentDefinition(
                cpu="1",
                memory="2Gi",
                code_configuration=CodeConfiguration(
                    runtime="python_3_13",
                    entry_point=["python", "main.py"],
                    dependency_resolution=CodeDependencyResolution.REMOTE_BUILD,
                ),
                environment_variables={
                    "FOUNDRY_PROJECT_ENDPOINT": endpoint,
                    "AZURE_AI_MODEL_DEPLOYMENT_NAME": model_name,
                    "TOOLBOX_NAME": toolbox_name,
                    "PYTHONNOUSERSITE": "1",
                },
                protocol_versions=[
                    ProtocolVersionRecord(protocol="responses", version="2.0.0")
                ],
            ),
            code=code_stream,
        )

        print(f"Created hosted agent version {created.version}")
        wait_for_active_version(project_client, created.version)

        original_agent_endpoint = project_client.agents.get(
            agent_name=agent_name
        ).agent_endpoint

        project_client.agents.update_details(
            agent_name=agent_name,
            agent_endpoint=AgentEndpointConfig(
                version_selector=VersionSelector(
                    version_selection_rules=[
                        FixedRatioVersionSelectionRule(
                            agent_version=created.version,
                            traffic_percentage=100,
                        ),
                    ]
                ),
                protocol_configuration=ProtocolConfiguration(
                    responses=ResponsesProtocolConfiguration()
                ),
            ),
        )

        with project_client.get_openai_client(agent_name=agent_name) as openai_client:
            response = openai_client.responses.create(
                input=(
                    "How do I create a hosted agent in Microsoft Foundry? "
                    "Use the Microsoft Learn documentation."
                ),
            )
            if response.status != "completed":
                raise RuntimeError(f"Agent invocation failed: {response.error}")
            print(response.output_text)
    finally:
        if original_agent_endpoint is not None:
            project_client.agents.update_details(
                agent_name=agent_name,
                agent_endpoint=original_agent_endpoint,
            )

        if created is not None:
            project_client.agents.delete_version(
                agent_name=agent_name,
                agent_version=created.version,
                force=True,
            )

Uruchom skrypt:

python deploy_toolbox_agent.py

Ten skrypt przesyła przykład zestawu narzędzi jako nową wersję hostowanego agenta, tymczasowo kieruje hostowanego agenta do tej wersji, wywołuje go przy użyciu pytania z Microsoft Learn, a po zakończeniu przywraca poprzednią konfigurację punktu końcowego.

5. Zweryfikuj odpowiedź wspomaganą przez zestaw narzędzi

Jeśli poprawnie skonfigurujesz zestaw narzędzi, odpowiedź pokaże, że hostowany agent wykrył narzędzia zestawu i udzielił odpowiedzi na podstawie dokumentacji Microsoft Learn.

Ścieżka zestawu SDK języka C#

Użyj tej ścieżki, aby utworzyć przybornik i wdrożyć przykład hostowanego agenta języka C# przy użyciu zestawu SDK .NET zamiast interfejsu wiersza polecenia dewelopera Azure lub przepływu pracy programu VS Code.

1. Tworzenie lub wybieranie projektu Foundry

1. Otwórz portal Foundry i utwórz projekt Foundry lub wybierz istniejący.
2. W projekcie wdróż model obsługujący czaty, taki jak gpt-4o.
3. Skopiuj punkt końcowy projektu z sekcji Przegląd oraz nazwę wdrożenia z Kompilacja>Wdrożenia.

2. Pobierz przykład hostowanego agenta z zestawu narzędzi

Sklonuj repozytorium przykładów Foundry:

git clone https://github.com/microsoft-foundry/foundry-samples.git

Przykład hostowanego agenta C# znajduje się w samples/csharp/hosted-agents/agent-framework/foundry-toolbox-server-side/src/foundry-toolbox-server-side-dotnet-agent-framework. Kod wdrożenia w następnych krokach ustawia następujące zmienne środowiskowe w kontenerze:

3. Utwórz przybornik za pomocą języka C#

Utwórz aplikację konsolową .NET i zainstaluj pakiety. Interfejsy API zestawu narzędzi są dostępne w wersji zapoznawczej, dlatego zainstaluj pakiet w wersji wstępnej Azure.AI.Projects:

dotnet new console --name create-toolbox
cd create-toolbox
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.Identity

Zastąp Program.cs następującym kodem i ustaw endpoint jako punkt końcowy projektu:

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI;
using OpenAI.Responses;

#pragma warning disable AAIP001, OPENAI001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var toolboxName = "my-toolbox";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
AgentToolboxes toolboxes = projectClient.AgentAdministrationClient.GetAgentToolboxes();

ToolboxVersion created = toolboxes.CreateVersion(
    name: toolboxName,
    tools:
    [
        new WebSearchToolboxTool { Name = "web_search", SearchContextSize = WebSearchToolSearchContextSize.Medium },
        new MCPToolboxTool(serverLabel: "mslearn")
        {
            ServerUri = new Uri("https://learn.microsoft.com/api/mcp"),
            ToolCallApprovalPolicy = new McpToolCallApprovalPolicy(GlobalMcpToolCallApprovalPolicy.NeverRequireApproval),
        },
    ],
    description: "Toolbox with web search and Microsoft Learn MCP.");
Console.WriteLine($"Created toolbox version {created.Version} for {created.Name}");

Uruchom aplikację:

dotnet run

Przykładowy hostowany agent ustala zestaw narzędzi na podstawie FOUNDRY_PROJECT_ENDPOINT i TOOLBOX_NAME, więc nie trzeba przechowywać punktu końcowego z numerem wersji.

4. Wdrażanie hostowanego agenta za pomocą języka C#

Utwórz drugą aplikację konsolową dla kodu wdrożenia:

dotnet new console --name deploy-toolbox-agent
cd deploy-toolbox-agent
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.AI.Extensions.OpenAI
dotnet add package Azure.Identity

Zastąp element Program.cs poniższym kodem. Ustaw endpoint, chatModel i samplePath na własne wartości. samplePath to pełna ścieżka do folderu źródłowego foundry-toolbox-server-side-dotnet-agent-framework sklonowanego w kroku 2:

using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI.Responses;

#pragma warning disable AAIP001, OPENAI001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var chatModel = "gpt-4o";
var toolboxName = "my-toolbox";
var agentName = "toolbox-agent";
var samplePath =
    @"<path-to-foundry-samples>\samples\csharp\hosted-agents\agent-framework\foundry-toolbox-server-side\src\foundry-toolbox-server-side-dotnet-agent-framework";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
var agentsClient = projectClient.AgentAdministrationClient;

HostedAgentDefinition definition = new(cpu: "1", memory: "2Gi")
{
    Versions = { new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "2.0.0") },
    CodeConfiguration = new(
        runtime: "dotnet_10",
        entryPoint: ["dotnet", "foundry-toolbox-server-side.dll"],
        dependencyResolution: CodeDependencyResolution.RemoteBuild),
};
definition.EnvironmentVariables.Add("FOUNDRY_PROJECT_ENDPOINT", endpoint);
definition.EnvironmentVariables.Add("AZURE_AI_MODEL_DEPLOYMENT_NAME", chatModel);
definition.EnvironmentVariables.Add("TOOLBOX_NAME", toolboxName);

ProjectsAgentVersion? created = null;
AgentEndpointConfiguration? originalEndpoint = null;
try
{
    created = agentsClient.CreateAgentVersionFromCode(
        agentName, samplePath, new AgentVersionFromCodeMetadata(definition));
    Console.WriteLine($"Created hosted agent version {created.Version}");

    for (var attempt = 1; attempt <= 60; attempt++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(10));
        created = agentsClient.GetAgentVersion(agentName, created.Version);
        Console.WriteLine($"Provisioning status: {created.Status} (attempt {attempt}/60)");
        if (created.Status == AgentVersionStatus.Active) break;
        if (created.Status == AgentVersionStatus.Failed)
            throw new InvalidOperationException("Hosted agent provisioning failed.");
    }

    ProjectsAgentRecord agent = agentsClient.GetAgent(agentName);
    originalEndpoint = agent.AgentEndpoint;
    agentsClient.PatchAgent(agentName, new PatchAgentOptions
    {
        AgentEndpoint = new AgentEndpointConfiguration
        {
            VersionSelector = new([new FixedRatioVersionSelectionRule(created.Version, 100)]),
            ProtocolConfiguration = new() { Responses = new ResponsesProtocolConfiguration() },
        },
    });

    ProjectResponsesClient responsesClient = projectClient.ProjectOpenAIClient
        .GetProjectResponsesClientForAgentEndpoint(agentName);
    ResponseResult response = responsesClient.CreateResponse(
        "How do I create a hosted agent in Microsoft Foundry? Use the Microsoft Learn documentation.");
    Console.WriteLine(response.GetOutputText());
}
finally
{
    if (originalEndpoint is not null)
        agentsClient.PatchAgent(agentName, new PatchAgentOptions { AgentEndpoint = originalEndpoint });
    if (created is not null)
        agentsClient.DeleteAgentVersion(agentName, created.Version, force: true);
}

Uruchom aplikację:

dotnet run

Ten kod przesyła przykład zestawu narzędzi jako nową wersję hostowanego agenta, tymczasowo kieruje hostowanego agenta do tej wersji, wywołuje go przy użyciu pytania z platformy Microsoft Learn i po zakończeniu przywraca poprzednią konfigurację punktu końcowego.

5. Zweryfikuj odpowiedź wspomaganą przez zestaw narzędzi

Jeśli poprawnie skonfigurujesz zestaw narzędzi, odpowiedź pokaże, że hostowany agent wykrył narzędzia zestawu i udzielił odpowiedzi na podstawie dokumentacji Microsoft Learn.

Usuń przybornik. Zastąp <deployed-toolbox-name> nazwą przybornika utworzonego na potrzeby tego przewodnika szybkiego startu:

azd ai toolbox list
azd ai toolbox delete <deployed-toolbox-name> --force

Po usunięciu zestawu narzędzi jego punkt końcowy przestanie działać. Zatrzymaj agenta lokalnego i usuń dowolny punkt końcowy dodany do src/agent-framework-agent-with-foundry-toolbox-responses/.env na potrzeby debugowania w VS Code.

Polecenie delete czyści wygenerowaną wartość punktu końcowego z Twojego środowiska azd. Ponowne wykonanie azd deploy --all ponownie utworzy przybornik zadeklarowany w pliku azure.yaml.

Usuń agenta i jego zasoby Azure:

azd down

Usuń skrzynkę narzędziową według nazwy:

import os

from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(
        endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        credential=credential,
    ) as project_client,
):
    project_client.toolboxes.delete(name=os.environ["TOOLBOX_NAME"])

Jeśli utworzysz dedykowaną grupę zasobów lub projekt na potrzeby tego przewodnika Szybki start, usuń tę grupę zasobów lub ten projekt z portalu Azure, gdy zestaw narzędzi, wdrożenie czatu lub hostowany agent nie będą już potrzebne.

Kod wdrożenia usuwa już wersję hostowanego agenta i przywraca poprzednią konfigurację punktu końcowego po zakończeniu. Aby usunąć zestaw narzędzi, dodaj ten kod do aplikacji konsolowej, w której zainstalowano pakiety Azure.AI.Projects (wersja wstępna) i Azure.Identity:

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;

#pragma warning disable AAIP001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var toolboxName = "my-toolbox";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
projectClient.AgentAdministrationClient.GetAgentToolboxes().Delete(toolboxName);
Console.WriteLine($"Deleted toolbox '{toolboxName}'.");

Jeśli utworzysz dedykowaną grupę zasobów lub projekt na potrzeby tego przewodnika Szybki start, usuń tę grupę zasobów lub ten projekt z portalu Azure, gdy zestaw narzędzi, wdrożenie czatu lub hostowany agent nie będą już potrzebne.