Rychlý start: Sestavení sady nástrojů a jeho použití s hostovaným agentem

Důležité

Položky označené jako náhled v tomto článku jsou aktuálně ve verzi Preview. Tato verze Preview se poskytuje bez smlouvy o úrovni služeb a Microsoft ji nedoporučuje pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou mít omezené možnosti. Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

V tomto rychlém startu vytvoříte sadu nástrojů , která kombinuje dva nástroje za jedním spravovaným koncovým bodem:

  • Vyhledávání na webu, které zdůvodňuje odpovědi ve výsledcích veřejných webů v reálném čase.
  • Server Microsoft Learn MCP, který zdůvodňuje odpovědi v oficiální dokumentaci k Microsoft. Jedná se o veřejný koncový bod, který nevyžaduje žádné ověřování.

Sadu nástrojů pak budete využívat z hostovaného agenta napsaného v Python. Sada nástrojů zveřejňuje jeden koncový bod MCP, takže se agent připojí k jedné adrese URL a zjistí každý nástroj za běhu. Nástroje můžete později změnit bez změny kódu agenta.

Pokud používáte agenta kódování, jako je GitHub Copilot, může Microsoft Foundry Skill pomoct sestavit koncový bod sady nástrojů, připojit ho k hostovanému agentu a upravit ukázkové nástroje.

Předpoklady

Tento rychlý start vychází ze sady nástrojů hostovaného agenta. Nejprve dokončete předpoklady v rychlém startu pro hostovaného agenta, které zahrnují předplatné Azure, role projektu, Python, Azure Developer CLI (azd) a rozšíření microsoft.foundry.

Pokud používáte sadu Python SDK, použijte oddíl Python dále v tomto článku místo pracovního postupu Azure Developer CLI nebo VS Code. Tento postup vytvoří sadu nástrojů pomocí project_client.toolboxes.create_version(...), potom nahraje kód hostovaného agenta jako novou verzi a přiřadí ji k této sadě nástrojů podle názvu.

Nainstalujte balíčky Python použité v této cestě:

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

Potřebujete existující projekt Foundry s nasazeným modelem podporujícím chat. Cesta Python SDK v tomto rychlém startu vytvoří sadu nástrojů a verzi hostovaného agenta, ale nevygeneruje nový projekt Foundry ani pro vás nevytvoří nasazení modelu.

Pro cestu .NET SDK použijte část C# dále v tomto článku místo pracovního postupu rozhraní příkazového řádku pro vývojáře Azure nebo VS Code. Tento postup vytvoří sadu nástrojů pomocí AgentToolboxes.CreateVersion(...), potom nahraje kód hostovaného agenta v jazyce C# jako novou verzi a přiřadí ji k této sadě nástrojů podle názvu.

Budete také potřebovat sadu SDK .NET 10 nebo novější a existující projekt Foundry s nasazeným modelem podporujícím chat.

Potřebujete také Visual Studio Code s rozšířením Microsoft Foundry Toolkit přihlášeným k Azure.

Krok 1: Inicializace hostovaného agenta

Inicializujte hostovaného agenta z ukázky nástrojů Foundry, který se prostřednictvím MCP připojí k toolboxu a zpřístupní jeho nástroje modelu. V dalším kroku vytvoříte sadu nástrojů (my-toolbox) a nasměrujete agenta na jeho koncový bod. Spusťte tyto příkazy v prázdném adresáři.

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

Podle pokynů vyberte projekt a existující nasazení modelu. Až budete vyzváni k výběru alokace prostředků kontejneru, zvolte 1 jádro, 2Gi paměti. Image kontejneru agenta potřebuje více než výchozí úroveň. Příznak --src vytvoří základní strukturu agenta v adresáři src/toolbox-agent.

Note

Manifesty agentů (agent.manifest.yaml) a samostatné definice agenta (agent.yaml) jsou zastaralé. Od verze rozšíření Foundry azd (azure.ai.agents 1.0.0-beta.1) je veškerá konfigurace hostovaného agenta uložena v jednom azure.yaml. Viz Vytvoření souboru azure.yaml pro hostované agenty.

Krok 2: Vytvoření sady nástrojů

Vytvořte sadu nástrojů a potom zkopírujte koncový bod MCP, který se zobrazí. V pozdějších krocích nastavte tento koncový bod jako proměnnou prostředí.

Ukázka v azure.yaml definuje sadu nástrojů jako službu azure.ai.toolbox a propojuje ji se službou hostovaného agenta pomocí uses:. Pokud změníte konfiguraci panelu nástrojů, upravte službu panelu nástrojů v azure.yaml, ne src/toolbox-agent/agent.yaml.

Nejprve nasměrujte příkazy sady nástrojů na projekt Foundry, který jste vybrali během inicializace. Použijte znovu koncový bod, který se už během inicializace uložil v prostředí azd:

azd env set FOUNDRY_PROJECT_ENDPOINT "$(azd env get-value FOUNDRY_PROJECT_ENDPOINT)"

Ukázka obsahuje toolbox.yaml v src/toolbox-agent, které definuje oba nástroje pod jedním koncovým bodem. Vytvořte sadu nástrojů z daného souboru:

azd ai toolbox create my-toolbox --from-file ./src/toolbox-agent/toolbox.yaml

První verze se automaticky změní na výchozí verzi. Příkaz vypíše verzovaný koncový bod MCP sady nástrojů. Endpoint Zkopírujte hodnotu z výstupu. Nastavte ji jako proměnnou TOOLBOX_ENDPOINT prostředí v dalších krocích. Vypadá takto:

https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/my-toolbox/versions/1/mcp?api-version=v1

  1. Otevřete Visual Studio Code a na panelu aktivit vyberte Foundry Toolkit.

  2. Pokud se zobrazí výzva, přihlaste se ke svému účtu Azure.

  3. V části Moje zdroje rozbalte projekt a potom rozbalte Položku Nástroje.

  4. V zobrazení Nástroje vyberte ikonu + Přidat sadu nástrojů .

  5. Zadejte název panelu nástrojů (my-toolbox) a popis.

  6. Vyberte vyhledávání na webu.

  7. Vyberte + Přidat nástroj, zvolte přidat vzdálený server MCP a zadejte adresu URL https://learn.microsoft.com/api/mcpserveru . Server je veřejný, takže se nevyžaduje žádné ověřování.

  8. Vyberte Publikovat. Publikování vytvoří první verzi sady nástrojů.

  9. Zkopírujte koncový bod MCP sady nástrojů. Spusťte následující příkaz a zkopírujte endpoint hodnotu z výstupu. Nastavte ji jako proměnnou TOOLBOX_ENDPOINT prostředí v dalších krocích:

    azd ai toolbox show my-toolbox --output json

Krok 3: Zřízení prostředků Azure

Agent načte endpoint MCP sady nástrojů z proměnné prostředí TOOLBOX_ENDPOINT, která se azure.yaml vyhodnotí z vašeho prostředí azd. Tuto hodnotu nastavíte v dalších krocích. Zřiďte prostředky Azure pro agenta:

azd provision

Krok 4: Místní spuštění agenta

V případě agenta Python se ujistěte, že jeho služba v azure.yaml před spuštěním a nasazením zahrnuje PYTHONNOUSERSITE: "1" ve stávající mapě env. Nespoléhejte na to, že se toto nastavení načte ve vaší aplikaci. Pokyny ke kompatibilitě závislostí najdete v tématu Konfigurace spouštění Pythonu.

  1. Nasměrujte místního agenta na svou sadu nástrojů nastavením těchto hodnot v souboru .env v src/toolbox-agent. Vložte koncový bod, který jste zkopírovali v kroku 2:

    FOUNDRY_MODEL_NAME=<your-model-deployment-name>
TOOLBOX_ENDPOINT=<versioned-endpoint-from-step-2>

    azd ai agent run FOUNDRY_PROJECT_ENDPOINT vkládá a čte .env soubor při místním spuštění. Ukázka zpracovává připojení, hlavičky a ověřování sady nástrojů za vás.

  2. Spusťte agenta:

    azd ai agent run

    Tento příkaz vytvoří virtuální prostředí, nainstaluje závislosti a obsluhuje agenta na http://localhost:8088. Balíčky ve verzi Preview můžou během instalace vytvářet upozornění pip. Tato upozornění nejsou blokující.

  3. V samostatném terminálu odešlete prompty, které otestují nástroje:

    azd ai agent invoke --local "Find the latest release notes for the Azure CLI on the web."
azd ai agent invoke --local "How do I create a hosted agent in Microsoft Foundry? Use the Microsoft Learn documentation."

Krok 5: Nasazení do služby agenta Foundry

Uložte endpoint, který jste zkopírovali ve 2. kroku, do svého azd prostředí, které se azure.yaml vyhodnotí při nasazení. Pak sestavte a nasaďte kontejner agenta:

azd env set TOOLBOX_ENDPOINT "<versioned-endpoint-from-step-2>"
azd deploy

Po dokončení příkazu se ve výstupu zobrazí odkazy na dětské hřiště agenta a koncový bod agenta. Vyvolání nasazeného agenta:

azd ai agent invoke "What's new in Microsoft Foundry? Use the Microsoft Learn documentation."

cesta sady Python SDK

Pokud chcete vytvořit sadu nástrojů a nasadit verzi hostovaného agenta pomocí sady Python SDK místo toku Azure Developer CLI nebo VS Code, použijte následující postup.

1. Vytvoření nebo volba projektu Foundry

  1. Otevřete portál Foundry a vytvořte projekt Foundry nebo vyberte existující.
  2. V projektu nasaďte model podporující chat, například gpt-5.4-mini.
  3. Zkopírujte koncový bod projektu z Přehled a název nasazení z Sestavení>Nasazení.

2. Stáhněte si ukázku hostovaného agenta sady nástrojů.

Naklonujte úložiště ukázek Foundry:

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

Vytvořte pracovní složku pro skripty nasazení. V této složce vytvořte .env soubor s těmito hodnotami:

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>

Krok 3: Vytvoření sady nástrojů pomocí Python

Vytvořte soubor s názvem create_toolbox.py ve stejné pracovní složce jako .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}")

Spusťte skript:

python create_toolbox.py

Ukázkový hostovaný agent dokáže najít sadu nástrojů buď z TOOLBOX_ENDPOINT, nebo z FOUNDRY_PROJECT_ENDPOINT spolu s TOOLBOX_NAME. Tato cesta používá TOOLBOX_NAME, takže nemusíte ukládat koncový bod verze do .env.

4. Nasazení hostovaného agenta s Python

Vytvořte soubor s názvem deploy_toolbox_agent.py ve stejné pracovní složce jako .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,
            )

Spusťte skript:

python deploy_toolbox_agent.py

Tento skript nahraje ukázku sady nástrojů jako novou verzi hostovaného agenta, dočasně odkazuje hostovaného agenta na tuto verzi, vyvolá ji pomocí otázky Microsoft Learn a po dokončení obnoví předchozí konfiguraci koncového bodu.

5. Ověřte odpověď generovanou pomocí sady nástrojů

Pokud sadu nástrojů nakonfigurujete správně, odpověď ukazuje, že hostovaný agent zjistil nástroje panelu nástrojů a odpověděl na ně pomocí dokumentace Microsoft Learn.

Cesta k sadě SDK jazyka C#

Pomocí této cesty můžete vytvořit sadu nástrojů a nasadit ukázku hostovaného agenta jazyka C# pomocí sady .NET SDK místo pracovního postupu Azure Developer CLI nebo VS Code.

1. Vytvoření nebo volba projektu Foundry

  1. Otevřete portál Foundry a vytvořte projekt Foundry nebo vyberte existující.
  2. V projektu nasaďte model podporující chat, například gpt-4o.
  3. Zkopírujte koncový bod projektu z Přehled a název nasazení z Sestavení>Nasazení.

2. Stáhněte si ukázku hostovaného agenta sady nástrojů.

Naklonujte úložiště ukázek Foundry:

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

Ukázku hostovaného agenta pro C# najdete v samples/csharp/hosted-agents/agent-framework/foundry-toolbox-server-side/src/foundry-toolbox-server-side-dotnet-agent-framework. Kód nasazení v dalších krocích nastaví tyto proměnné prostředí v kontejneru:

Proměnné Description
FOUNDRY_PROJECT_ENDPOINT Koncový bod projektu Foundry
AZURE_AI_MODEL_DEPLOYMENT_NAME Název nasazení modelu chatu
TOOLBOX_NAME Název sady nástrojů, ke které se agent připojuje.

3. Vytvoření sady nástrojů pomocí jazyka C#

Vytvořte konzolovou aplikaci .NET a nainstalujte balíčky. Rozhraní API sady nástrojů jsou zatím ve verzi Preview, proto si nainstalujte balíček předběžné verze Azure.AI.Projects:

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

Nahraďte Program.cs následujícím kódem a nastavte endpoint ho na koncový bod 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}");

Spuštění aplikace:

dotnet run

Ukázkový hostovaný agent určí sadu nástrojů z kombinace FOUNDRY_PROJECT_ENDPOINT a TOOLBOX_NAME, takže nemusíte ukládat koncový bod s uvedenou verzí.

4. Nasazení hostovaného agenta pomocí jazyka C#

Vytvořte druhou konzolovou aplikaci pro kód nasazení:

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

Nahraďte Program.cs následujícím kódem. Nastavte u endpoint, chatModel a samplePath své hodnoty. samplePath je úplná cesta ke foundry-toolbox-server-side-dotnet-agent-framework zdrojové složce, kterou jste naklonovali v 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);
}

Spuštění aplikace:

dotnet run

Tento kód nahraje ukázku sady nástrojů jako novou verzi hostovaného agenta, dočasně odkazuje hostovaného agenta na tuto verzi, vyvolá ji pomocí otázky Microsoft Learn a po dokončení obnoví konfiguraci předchozího koncového bodu.

5. Ověřte odpověď generovanou pomocí sady nástrojů

Pokud sadu nástrojů nakonfigurujete správně, odpověď ukazuje, že hostovaný agent zjistil nástroje panelu nástrojů a odpověděl na ně pomocí dokumentace Microsoft Learn.

Vyčistěte zdroje

Až skončíte, odstraňte prostředky, aby vám přestaly být účtovány poplatky.

Odstranit panel nástrojů:

azd ai toolbox delete my-toolbox --force

Po odstranění sady nástrojů přestane koncový bod fungovat. Odeberte to z src/toolbox-agent/.env a odstraňte to ze svého azd prostředí:

azd env set TOOLBOX_ENDPOINT ""

Odstraňte agenta a jeho prostředky Azure:

Warning

Pokud aktuální azd prostředí vytvořilo projekt Foundry, azd down trvale odstraní skupinu prostředků projektu a vše v ní. Pokud jste během inicializace vybrali existující projekt, azd down ponechá projekt, jeho skupinu prostředků, hostovaného agenta a další prostředky rychlého startu. Pokud chcete odstranit prostředky, které už nepotřebujete z existujícího projektu, odstraňte je samostatně.

azd down

Smažte panel nástrojů podle názvu:

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"])

Pokud jste pro tento rychlý start vytvořili vyhrazenou skupinu prostředků nebo projekt, odstraňte ji z portálu Azure poté, co už nepotřebujete sadu nástrojů, nasazení chatu nebo hostovaného agenta.

Kód nasazení už odstraní verzi hostovaného agenta a po dokončení obnoví předchozí konfiguraci koncového bodu. Pokud chcete panel nástrojů odstranit, přidejte tento kód do konzolové aplikace, která má Azure.AI.Projects nainstalované (předběžné verze) a Azure.Identity balíčky:

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

Pokud jste pro tento rychlý start vytvořili vyhrazenou skupinu prostředků nebo projekt, odstraňte ji z portálu Azure poté, co už nepotřebujete sadu nástrojů, nasazení chatu nebo hostovaného agenta.

Řešení problémů

Issue Solution
tools/list nevrátí žádné nástroje Microsoft Learn. mslearn Potvrďte, že nástroj v toolbox.yaml směřuje na https://learn.microsoft.com/api/mcp.
Agent se spustí, ale hlásí TOOLBOX_ENDPOINT is set but empty nebo nemá žádné nástroje. Nastavte TOOLBOX_ENDPOINT na verzovaný koncový bod z kroku 2 v .env pro místní spuštění a před nasazením spusťte azd env set TOOLBOX_ENDPOINT "<endpoint>".
Volání koncového bodu sady nástrojů selhávají s chybou autorizace Ověřte, že každý požadavek zahrnuje token Entra s vymezeným oborem https://ai.azure.com/.default. Ukázkový kód se o to postará za vás.
Connection refused při lokálním spuštění Ujistěte se, že žádný jiný proces nepoužívá port 8088.

Co jste se naučili

V tomto rychlém průvodci vám:

  • Vytvořili jsme sadu nástrojů, která kombinuje vyhledávání na webu a server Microsoft Learn MCP za jedním koncovým bodem.
  • Používejte sadu nástrojů z hostovaného agenta, který se připojuje přes protokol Model Context Protocol, pomocí Azure Developer CLI, sady Python SDK nebo sady .NET SDK.
  • Agenta jste spustili místně nebo ho ověřili vzdáleně a nasadili ho do služby Foundry Agent Service.

Další krok

Přidání znalostní báze Foundry IQ do hostovaného agenta

Související obsah

  • Poslední aktualizace v