Erstellen und Verwalten einer Toolbox in Foundry

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

# Create Foundry project client
endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
project = AIProjectClient(
    endpoint=endpoint,
    credential=DefaultAzureCredential(),
)

# Create toolbox version with web search and MCP tools
toolbox_version = project.toolboxes.create_version(
    name="my-toolbox",
    description="Toolbox with web search and an MCP server",
    tools=[
        WebSearchToolboxTool(),
        MCPToolboxTool(
            server_label="myserver",
            server_url="https://your-mcp-server.example.com",
            require_approval="never",
            project_connection_id="my-key-auth-connection",
        ),
        ToolSearchToolboxTool(),
    ],
)
print(f"Created toolbox: {toolbox_version.name}, version: {toolbox_version.version}")

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

// Create Foundry project client
var projectEndpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>";
AIProjectClient projectClient = new(new Uri(projectEndpoint), new DefaultAzureCredential());
AgentToolboxes toolboxClient = projectClient.AgentAdministrationClient.GetAgentToolboxes();

WebSearchToolboxTool webTool = new();
MCPToolboxTool mcpTool = new(serverLabel: "myserver")
{
  ServerUri = new Uri("https://your-mcp-server.example.com"),
  ToolCallApprovalPolicy = new McpToolCallApprovalPolicy(
    GlobalMcpToolCallApprovalPolicy.NeverRequireApproval),
};

ToolSearchToolboxTool searchTool = new() { Name = "ToolBoxSearch" };

ToolboxVersion toolboxVersion = await toolboxClient.CreateVersionAsync(
  name: "my-toolbox",
    tools: [webTool, mcpTool, searchTool],
    description: "Toolbox with web search, MCP, and tool search"
);
Console.WriteLine($"Created toolbox: {toolboxVersion.Name}, version: {toolboxVersion.Version}");

POST {project_endpoint}/toolboxes/my-toolbox/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{
  "description": "Toolbox with web search, MCP, and tool search",
  "tools": [
    {
      "type": "web_search",
      "description": "Search the web for current information"
    },
    {
      "type": "mcp",
      "server_label": "myserver",
      "server_url": "https://your-mcp-server.example.com",
      "require_approval": "never",
      "project_connection_id": "my-key-auth-connection"
    },
    {
      "type": "toolbox_search"
    }
  ]
}

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";

// Create Foundry project client
const projectEndpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>";

const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());

const toolboxVersion = await project.toolboxes.createVersion(
  "my-toolbox",
  [
    {
      type: "web_search",
      description: "Search the web for current information",
    },
    {
      type: "mcp",
      server_label: "myserver",
      server_url: "https://your-mcp-server.example.com",
      require_approval: "never",
      project_connection_id: "my-key-auth-connection",
    },
    { type: "toolbox_search" },
  ],
  {
    description: "Toolbox with web search, MCP, and tool search",
  },
);
console.log(`Created toolbox: ${toolboxVersion.name}, version: ${toolboxVersion.version}`);

Verwenden Sie das Microsoft Foundry Toolkit für Visual Studio Code Erweiterung, um eine Toolbox aus der Ansicht Tools zu erstellen und zu veröffentlichen.

1. Wählen Sie das Foundry Toolkit in der Aktivitätsleiste aus.
2. Erweitern Sie unter "Meine Ressourcen"Ihren Projektnamen>Tools.
3. Wählen Sie das Symbol "+Toolbox hinzufügen " aus.
4. Geben Sie auf der Registerkarte " Benutzerdefinierte Toolbox erstellen" den Namen und die Beschreibung der Toolbox ein, und fügen Sie die gewünschten Tools hinzu.
5. Wählen Sie zum Aktivieren der absichtsbasierten Toolrouting die Option "Toolsuche" aus.
6. Wählen Sie "Veröffentlichen" aus.

Beim Veröffentlichen einer neuen Toolbox wird die erste Version erstellt. Diese Version wird automatisch zur Standardversion.

Erstellen Sie mit dem einheitlichen microsoft.foundryErweiterungspaket (siehe Voraussetzungen) eine Toolbox in zwei Schritten:

1. Verwenden Sie azd ai connection create, um jede Projektverbindung zu registrieren, auf die die Toolbox verweist (ein Aufruf pro Anmeldeinformationssatz).
2. Verwenden Sie azd ai toolbox create --from-file <toolbox.yaml>, um die Toolbox zu erstellen. Die YAML verweist auf Verbindungen nach Namen und bettet niemals Anmeldeinformationen ein.

Das Muster ist für jede Verbindungsart und jeden Authentifizierungstyp identisch:

1. Legen Sie das aktive Projekt einmal pro Shell fest:

   azd ai project set $PROJECT_ENDPOINT
   

2. Erstellen Sie eine Verbindung mit azd ai connection create. Die Flags unterscheiden sich je nach Authentifizierungstyp, aber die Befehlsstruktur ist immer:

   azd ai connection create <name> \
     --kind <remote-tool|remote-a2a|cognitive-search|GroundingWithCustomSearch> \
     --target <endpoint-url> \
     --auth-type <none|custom-keys|api-key|oauth2|user-entra-token|project-managed-identity|agentic-identity> \
     [--custom-key "Header=Value" | --key <key> | --client-id ... --client-secret ... --authorization-url ... --token-url ... | --audience <aad-resource-uri>]
   

   Verwenden Sie azd ai connection list und azd ai connection show <name>, um Verbindungen zu prüfen, und azd ai connection delete <name> --force, um sie zu entfernen.

3. Erstellen Sie eine Toolbox-YAML, die auf eine oder mehrere vorhandene Verbindungen anhand des Namens verweist. YaML bettet niemals Anmeldeinformationen ein:

   # my-toolbox.yaml
   description: <human-readable description>
   connections:
     - name: <project-connection-name>   # must already exist in the project
   # Optional: add connectionless built-in tools and policies.
   tools:
     - type: web_search
       name: web
     - type: code_interpreter
       container: { type: auto }
       name: code
     # Tool search is connectionless.
     - type: toolbox_search
     # For Azure AI Search, set the index in the tool entry:
     # - type: azure_ai_search
     #   name: search
     #   azure_ai_search:
     #     indexes:
     #       - project_connection_id: <azure-ai-search-connection-name>
     #         index_name: <search-index-name>
     # For Bing Custom Search, set the instance in the tool entry:
     # - type: web_search
     #   name: bing
     #   custom_search_configuration:
     #     project_connection_id: <bing-connection-name>
     #     instance_name: <bing-instance-name>
   # Optional: attach existing project skills as MCP resources.
   skills:
     - name: <skill-name>          # uses the skill's default version
     - name: <other-skill>
       version: "2"               # pin to a specific skill version (string)
   policies:
     rai_config:
       rai_policy_name: <policy-name>    # must already exist on the project
   

   Mindestens einer von connections, skillsoder tools muss nicht leer sein. Verweise auf Fähigkeiten müssen auf Fähigkeiten verweisen, die bereits im selben Foundry-Projekt vorhanden sind; siehe Fähigkeiten in Foundry verwenden, um sie mit azd ai skill create zu erstellen. Einzelheiten zur Einrichtung der End-to-End-Toolsuche finden Sie unter Toolsuche verwenden.

4. Erstellen Sie die Toolbox aus dieser Datei:

   azd ai toolbox create <toolbox-name> --from-file ./my-toolbox.yaml
   

   Die erste Version wird automatisch zum Standard. Verwenden Sie azd ai toolbox list, azd ai toolbox show <name>, azd ai toolbox version list <name> und azd ai toolbox delete <name> --force zum Verwalten von Toolboxen.

Beispiel: MCP-Server mit schlüsselbasierter Authentifizierung

# 1. Create the connection
azd ai connection create my-gh-conn \
  --kind remote-tool \
  --target https://api.githubcopilot.com/mcp/ \
  --auth-type custom-keys \
  --custom-key "Authorization=Bearer $GITHUB_PAT"

# 2. Create the toolbox
azd ai toolbox create my-toolbox \
  --from-file ./my-toolbox.yaml \
  --no-prompt

# my-toolbox.yaml
description: GitHub MCP toolbox
connections:
  - name: my-gh-conn

Kopieren Sie in der Erweiterung Microsoft Foundry Toolkit for Visual Studio Code den Verbraucher-Endpunkt der Toolbox aus der Ansicht Toolboxes.

1. Wählen Sie das Foundry Toolkit in der Aktivitätsleiste aus.
2. Erweitern Sie unter "Meine Ressourcen"Ihren Projektnamen>Tools.
3. Suchen Sie auf der Registerkarte "Toolboxes " Ihre Toolbox.
4. Kopieren Sie den Endpunkt in der Spalte "Endpunkt-URL ".

Der Endpunkt-URL-Wert ist der Toolbox-Verbraucherendpunkt. Verwenden Sie das in der vorherigen Tabelle gezeigte Entwicklermuster, um einen versionsspezifischen Endpunkt zu erstellen.

Installieren Sie das MCP-Client-SDK:

pip install mcp

Verbinden Sie sich mit der Toolbox und listen Sie die Werkzeuge auf.

import asyncio
from azure.identity import DefaultAzureCredential
from mcp.client.streamable_http import streamablehttp_client
from mcp import ClientSession

url = "https://<account>.services.ai.azure.com/api/projects/<proj>/toolboxes/<name>/versions/<version>/mcp?api-version=v1"

token = DefaultAzureCredential().get_token("https://ai.azure.com/.default").token
headers = {
    "Authorization": f"Bearer {token}",
}

async def verify_toolbox():
    async with streamablehttp_client(url, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools_result = await session.list_tools()
            print(f"Tools found: {len(tools_result.tools)}")
            for tool in tools_result.tools:
                print(f"  - {tool.name}: {(tool.description or '')[:80]}")

            # Call a tool (replace with actual tool name and arguments)
            result = await session.call_tool("<tool_name>", arguments={})
            print(result)

asyncio.run(verify_toolbox())

Verwenden Sie den versionsspezifischen Endpunkt (/versions/{version}/mcp), um eine Version zu überprüfen, bevor Sie sie bewerben.

1. Initialisieren der MCP-Sitzung:

POST {project_endpoint}/toolboxes/{toolbox_name}/versions/{version}/mcp?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}

2. Senden Sie die initialisierte Benachrichtigung:

POST {project_endpoint}/toolboxes/{toolbox_name}/versions/{version}/mcp?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{"jsonrpc":"2.0","method":"notifications/initialized"}

3. Verfügbare Tools auflisten:

POST {project_endpoint}/toolboxes/{toolbox_name}/versions/{version}/mcp?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}

4. Aufrufen eines Tools:

POST {project_endpoint}/toolboxes/{toolbox_name}/versions/{version}/mcp?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"<TOOL_NAME>","arguments":{}}}

Installieren Sie das MCP-Client-SDK:

npm install @modelcontextprotocol/sdk

Verbinden Sie sich mit der Toolbox und listen Sie die Werkzeuge auf.

import { DefaultAzureCredential } from "@azure/identity";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";

const url = "https://<account>.services.ai.azure.com/api/projects/<proj>/toolboxes/<name>/versions/<version>/mcp?api-version=v1";

const credential = new DefaultAzureCredential();
const token = await credential.getToken("https://ai.azure.com/.default");

const transport = new StreamableHTTPClientTransport(
  new URL(url),
  {
    requestInit: {
      headers: {
        Authorization: `Bearer ${token.token}`,
      },
    },
  },
);

const client = new Client({ name: "test", version: "1.0" });
await client.connect(transport);

// List available tools
const toolsResult = await client.listTools();
console.log(`Tools found: ${toolsResult.tools.length}`);
for (const tool of toolsResult.tools) {
  console.log(`  - ${tool.name}: ${(tool.description || "").slice(0, 80)}`);
}

// Call a tool (replace with actual tool name and arguments)
const result = await client.callTool({ name: "<tool_name>", arguments: {} });
console.log(result);

await client.close();

Verwenden Sie den MCP-Endpunkt der Toolbox mit einem Beispiel für einen gehosteten Agent mit Gerüstvorlage, um das Laden der Toolbox in VS Code zu überprüfen.

1. Suchen Sie im Foundry Toolkit unter Meine Ressourcen>dein Projektname>Tools die Toolbox, die Sie testen möchten.
2. Wählen Sie "Scaffold Code-Template" aus.
3. Wählen Sie einen Projektordner aus, wenn Sie dazu aufgefordert werden.
4. Folgen Sie der generierten README.md, um Abhängigkeiten zu installieren, Umgebungsvariablen zu konfigurieren und das Beispiel lokal auszuführen.
5. Verwenden Sie Agent Inspector oder führen Sie python main.py aus, um zu bestätigen, dass die Werkzeuge der Toolbox geladen werden und reagieren.

Verwenden Sie für die versionsspezifische Überprüfung in diesem Schritt die Python- oder REST-API-Registerkarte, bevor Sie eine neue Toolbox-Version veröffentlichen.

LangGraph

Anforderungen für gehostete Integrationsfragmente: Installieren .langchain-azure-ai[tools]>1.2.3 Das Fragment verwendet AzureAIProjectToolbox; verwenden Sie das gepflegte LangGraph-Beispiel für den vollständigen Agenten, den Paketsatz und die Bereitstellungsdateien.

.env Datei:

FOUNDRY_PROJECT_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>
TOOLBOX_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/<toolbox-name>/versions/<version>/mcp?api-version=v1
TOOLBOX_NAME=agent-tools
AZURE_AI_MODEL_DEPLOYMENT_NAME=gpt-4o

main.py (Schlüsselmuster):

from langchain_azure_ai.tools import AzureAIProjectToolbox

toolbox = AzureAIProjectToolbox(toolbox_name=TOOLBOX_NAME)
tools = await toolbox.get_tools()

Microsoft Agent Framework

Installieren Sie agent-framework-foundry zusätzlich zum erforderlichen Azure Identity-Paket. Die vollständige Implementierung finden Sie im verwalteten Agent Framework-Beispiel.

Verwenden Sie FoundryToolbox aus dem Agent Framework SDK, um eine Verbindung mit dem Toolbox-Endpunkt herzustellen. Die Klasse verarbeitet die Toolboxauthentifizierung und leitet den Kontext des Anrufs des gehosteten Agents weiter.

.env Datei:

FOUNDRY_PROJECT_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>
TOOLBOX_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/<toolbox-name>/versions/<version>/mcp?api-version=v1
AZURE_AI_MODEL_DEPLOYMENT_NAME=gpt-4o

main.py (Schlüsselmuster):

from agent_framework.foundry import FoundryToolbox
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

# Toolbox MCP endpoint (platform-injected at runtime via TOOLBOX_ENDPOINT)
TOOLBOX_ENDPOINT = "https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/<toolbox-name>/versions/<version>/mcp?api-version=v1"

toolbox = FoundryToolbox(
    credential,
    url=TOOLBOX_ENDPOINT,
)

agent = chat_client.as_agent(
    name="my-toolbox-agent",
    instructions="You are a helpful assistant with access to Foundry toolbox tools.",
    tools=[toolbox],
)
ResponsesAgentServerHost().run()

Copilot SDK

Anforderungen für gehostete Integrationsfragmente: Installieren Sie das GitHub Copilot SDK für Ihre Laufzeit. Die Gliederung hängt von anwendungseigenen McpBridge und _get_toolbox_token Hilfsern ab, die hier nicht implementiert sind. Folgen Sie den vorhandenen Toolbox-Endpunkt- und Authentifizierungsvertrag und den Integrationsmustern des gehosteten Agents. Ein gepflegtes vollständiges Beispiel ist noch nicht verfügbar.

Verwenden Sie das GitHub Copilot SDK, um einen auf Toolbox basierenden Agenten zu erstellen, der die Werkzeugaufrufe von Copilot mit dem MCP-Endpunkt der Foundry-Toolbox verbindet.

.env Datei:

GITHUB_TOKEN=<your-github-token>
TOOLBOX_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/<toolbox-name>/versions/<version>/mcp?api-version=v1

agent.py (Schlüsselmuster — MCP-Brücke):

# 1. Open an MCP session to the toolbox endpoint
bridge = McpBridge(endpoint=TOOLBOX_ENDPOINT, token=_get_toolbox_token())
await bridge.initialize()
mcp_tools = await bridge.list_tools()

# 2. Map MCP tool list to Copilot SDK tool definitions
#    Dots in tool names are replaced with underscores (Copilot SDK requirement)
copilot_tools = [
    {
        "name": t["name"].replace(".", "_"),
        "description": t.get("description", ""),
        "parameters": t.get("inputSchema", {}),
    }
    for t in mcp_tools
]

# 3. Wire tool calls back to the MCP session
async def tool_handler(name: str, arguments: dict) -> str:
    return await bridge.call_tool(name.replace("_", ".", 1), arguments)

# 4. Run the Copilot SDK agent
agent = Agent(
    tools=copilot_tools,
    tool_handler=tool_handler,
    token=os.environ["GITHUB_TOKEN"],
)

Microsoft Agent Framework

Installieren Microsoft.Agents.AI.Foundry.Hosting und Azure.Identity. Ein vollständiges Projekt finden Sie im Beispiel für die gehostete Toolbox des öffentlichen Agent-Frameworks.

Verwenden Sie AddFoundryToolboxes, um eine oder mehrere Toolboxen beim gehosteten Agenten zu registrieren. Die Integration ermittelt den verwalteten MCP-Endpunkt, authentifiziert Anfragen und berücksichtigt den Integritätsstatus der Toolbox in der Readiness-Probe.

Umgebungsvariablen:

AZURE_AI_PROJECT_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>
AZURE_AI_MODEL_DEPLOYMENT_NAME=gpt-4o
TOOLBOX_NAME=<toolbox-name>

Program.cs (Schlüsselmuster):

using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry.Hosting;

string projectEndpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable(
    "AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-4o";
string toolboxName = Environment.GetEnvironmentVariable("TOOLBOX_NAME")
    ?? throw new InvalidOperationException("TOOLBOX_NAME is not set.");

var credential = new DefaultAzureCredential();
AIAgent agent = new AIProjectClient(new Uri(projectEndpoint), credential)
    .AsAIAgent(
        model: deploymentName,
        instructions: "You are a helpful assistant with access to toolbox tools.",
        name: "hosted-toolbox-agent");

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddFoundryResponses(agent);
builder.Services.AddFoundryToolboxes(credential, toolboxName);

var app = builder.Build();
app.MapFoundryResponses();
app.Run();

Verwenden Sie die Microsoft Foundry Toolkit-Erweiterung für Visual Studio Code, um das Grundgerüst für eine Beispielanwendung für einen gehosteten Agenten zu erstellen, die bereits mit Ihrer Toolbox verbunden ist.

1. Wählen Sie das Foundry Toolkit in der Aktivitätsleiste aus.
2. Erweitern Sie unter "Meine Ressourcen"Ihren Projektnamen>Tools.
3. Suchen Sie auf der Registerkarte Toolboxes die Toolbox, die Sie verwenden möchten, und wählen Sie dann die Gerüstcodevorlage aus.
4. Wählen Sie in der Befehlspalette einen Projektordner aus, wenn Sie dazu aufgefordert werden.
5. Öffnen Sie das generierte README.md Element, und folgen Sie den Setup-, lokalen Ausführungs- und Bereitstellungsschritten für das Gerüst.

Das generierte Projekt beinhaltet den Einstiegspunkt des Hosted Agents, Bereitstellungsdateien und eine README.md-Datei mit den genauen Schritten für Einrichtung, Ausführung und Bereitstellung.

Wenn Sie eine Toolbox in ein bestehendes gehostetes Agent-Projekt integrieren möchten, anstatt ein neues Beispiel zu generieren, verwenden Sie den MCP-Endpunkt der Toolbox mit den Python- oder .NET-Mustern in diesem Abschnitt.

Übergeben Sie den Toolbox-Endpunkt an Ihren Agenten

Nachdem Sie die Toolbox erstellt haben, rufen Sie den MCP-Endpunkt mit azd ai toolbox show ab und übergeben Sie ihn als Umgebungsvariable an Ihren Agent-Code. Der Agent liest die Variable beim Start und verwendet sie zum Herstellen einer Verbindung mit der Toolbox.

1. Rufen Sie den Toolbox-Endpunkt ab:

   azd ai toolbox show <toolbox-name> --output json
   

   Das endpoint Feld in der Antwort identifiziert die ausgewählte Version. Verwenden Sie sie, um die Version vor der Freigabe zu testen. Erstellen Sie für einen Agenten, der default_version folgen soll, den nicht versionierten Consumer-Endpunkt, der unter Toolbox-MCP-Endpunkt abrufen angegeben ist.

2. Legen Sie den Endpunkt als Umgebungsvariable fest, die Ihr Agent beim Start liest:

   # .env (or however your runtime loads environment variables)
   TOOLBOX_ENDPOINT=https://<account>.services.ai.azure.com/api/projects/<project>/toolboxes/<toolbox-name>/mcp?api-version=v1
   

3. Lesen Sie in Ihrem Agentcode TOOLBOX_ENDPOINT und verbinden Sie sich mit ihm über einen MCP-Client. Verwenden Sie die Python- oder .NET-Integrationsmuster weiter oben in diesem Abschnitt als Referenz für das Clientsetup und das Entra-Token (Bereich https://ai.azure.com/.default).

from azure.ai.projects.models import MCPToolboxTool

# Set require_approval on an MCP tool
toolbox_version = project.toolboxes.create_version(
    name="my-toolbox",
    tools=[
        MCPToolboxTool(
            server_label="myserver",
            server_url="https://your-mcp-server.example.com",
            require_approval="always",  # "always" | "never"
            project_connection_id="my-connection",
        )
    ],
)

{
  "tools": [
    {
      "type": "mcp",
      "server_label": "myserver",
      "server_url": "https://your-mcp-server.example.com",
      "require_approval": "always",
      "project_connection_id": "my-connection"
    }
  ]
}

MCPToolboxTool mcpTool = new(serverLabel: "myserver")
{
  ServerUri = new Uri("https://your-mcp-server.example.com"),
  ToolCallApprovalPolicy = new McpToolCallApprovalPolicy(
    GlobalMcpToolCallApprovalPolicy.AlwaysRequireApproval),
};

const tools = [
  {
    type: "mcp",
    server_label: "myserver",
    server_url: "https://your-mcp-server.example.com",
    require_approval: "always",
    project_connection_id: "my-connection",
  },
];

Verwenden Sie die Registerkarte Python, .NET, JavaScript, REST API oder Azure Developer CLI, um require_approval in Ihrer Toolboxdefinition zu konfigurieren. Der Workflow der Erweiterung „Microsoft Foundry Toolkit für Visual Studio Code“ in diesem Artikel konzentriert sich auf das Erstellen und Verwenden der Toolbox in Visual Studio Code.

resources:
  - kind: toolbox
    name: my-toolbox
    tools:
      - type: mcp
        server_label: myserver
        server_url: https://your-mcp-server.example.com
        require_approval: always
        project_connection_id: my-connection

# Create a new toolbox version
toolbox_version = project.toolboxes.create_version(
    name="my-toolbox",
    description="Updated tools v2",
    tools=[...],
)
print(f"Created version: {toolbox_version.version}")

ToolboxVersion toolboxVersion = await toolboxClient.CreateVersionAsync(
  name: "<toolbox-name>",
    tools: [tool],
    description: "Updated tools v2"
);
Console.WriteLine($"Created version: {toolboxVersion.Version}");

POST {project_endpoint}/toolboxes/<toolbox-name>/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{
  "description": "Updated tools v2",
  "tools": [...]
}

const toolboxVersion = await project.toolboxes.createVersion(
  "<toolbox-name>",
  [/* tools array */],
  { description: "Updated tools v2" },
);
console.log(`Created version: ${toolboxVersion.version}`);

Verwenden Sie die Registerkarte Python, .NET, JavaScript oder REST-API, um eine neue Toolboxversion zu erstellen. Der Workflow der Erweiterung Microsoft Foundry Toolkit für Visual Studio Code, der in diesem Artikel beschrieben wird, konzentriert sich auf das Erstellen einer Toolbox und das Generieren des Grundgerüsts für einen gehosteten Agenten, der sie verwendet.

Dieser Vorgang wird mit der Azure Developer CLI nicht unterstützt. Verwenden Sie zum Erstellen einer Toolboxversion die Registerkarte Python, .NET, REST-API oder JavaScript.

# List all toolbox versions
versions = list(project.toolboxes.list_toolbox_versions(name="<toolbox-name>"))
for v in versions:
    print(f"{v.version} — created {v.created_at}")

List<ToolboxVersion> versions = await toolboxClient
    .GetToolboxVersionsAsync("<toolbox-name>")
    .ToListAsync();
Console.WriteLine($"Found {versions.Count} toolbox version(s).");
foreach (ToolboxVersion v in versions)
{
    Console.WriteLine($"  - {v.Name} ({v.Version})");
}

GET {project_endpoint}/toolboxes/<toolbox-name>/versions?api-version=v1
Authorization: Bearer {token}

const versions = project.toolboxes.listVersions("<toolbox-name>");
for await (const v of versions) {
  console.log(`${v.version} — created ${v.created_at}`);
}

Verwenden Sie die Registerkarte Python, .NET, JavaScript oder REST-API, um Toolboxversionen aufzulisten.

# The current default version is marked with *
azd ai toolbox version list <toolbox-name>

# Get a specific toolbox version
version_obj = project.toolboxes.get_toolbox_version(
    toolbox_name="<toolbox-name>",
    version="<version_id>",
)

ToolboxVersion versionObj = await toolboxClient.GetToolboxVersionAsync(
    "<toolbox-name>",
    "<version_id>"
);
Console.WriteLine($"Retrieved toolbox: {versionObj.Name} ({versionObj.Id})");

GET {project_endpoint}/toolboxes/<toolbox-name>/versions/{version}?api-version=v1
Authorization: Bearer {token}

const versionObj = await project.toolboxes.getVersion(
  "<toolbox-name>",
  "<version_id>",
);
console.log(`Retrieved version: ${versionObj.version}`);

Verwenden Sie die Registerkarte Python, .NET, JavaScript oder REST-API, um eine bestimmte Toolboxversion abzurufen.

azd ai toolbox version get <toolbox-name> <version_id>

# Promote a version to default
toolbox = project.toolboxes.update(
    toolbox_name="<toolbox-name>",
    default_version="<version_id>",
)
print(f"Active version: {toolbox.default_version}")

ToolboxRecord record = await toolboxClient.UpdateToolboxAsync(
    "<toolbox-name>",
    "<version_id>"
);
Console.WriteLine($"Active version: {record.DefaultVersion}");

PATCH {project_endpoint}/toolboxes/<toolbox-name>?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{
  "default_version": "<version_id>"
}

default_version darf nicht leer sein. Ersetzen Sie sie durch eine neue Version.

const toolbox = await project.toolboxes.update(
  "<toolbox-name>",
  "<version_id>",
);
console.log(`Active version: ${toolbox.default_version}`);

Verwenden Sie die Registerkarte Python, .NET, JavaScript oder REST-API, um eine Toolboxversion als Standard festzulegen.

Toolboxversionen sind unveränderlich. Verwenden Sie publish, um eine vorhandene Version zur neuen Standardversion zu machen:

# Roll back or forward to a specific version
azd ai toolbox publish <toolbox-name> <version_id> --no-prompt

publish ist der einzige Weg, mit dem default_version über die CLI geändert wird; mutierende Verben (connection add/remove, skill add/remove) erstellen immer eine neue Version, ohne sie heraufzustufen.

# Delete a toolbox version
project.toolboxes.delete_toolbox_version(
    toolbox_name="<toolbox-name>",
    version="<version_id>",
)

await toolboxClient.DeleteToolboxVersionAsync(
    "<toolbox-name>",
    "<version_id>"
);

DELETE {project_endpoint}/toolboxes/<toolbox-name>/versions/{version}?api-version=v1
Authorization: Bearer {token}

await project.toolboxes.deleteVersion(
  "<toolbox-name>",
  "<version_id>",
);

Verwenden Sie die Registerkarte Python, .NET, JavaScript oder REST-API, um eine Toolboxversion zu löschen.

Dieser Vorgang wird mit der Azure Developer CLI nicht unterstützt. Verwenden Sie zum Löschen einer Toolboxversion die Registerkarte Python, .NET, REST-API oder JavaScript.

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import WebSearchToolboxTool

endpoint = "https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>"
project = AIProjectClient(endpoint=endpoint, credential=DefaultAzureCredential())

toolbox_version = project.toolboxes.create_version(
    name="my-toolbox",
    description="Toolbox with guardrail",
    tools=[WebSearchToolboxTool()],
    policies={
        "rai_config": {
            "rai_policy_name": "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<account-name>/raiPolicies/<policy-name>"
        }
    },
)
print(f"Created version: {toolbox_version.version}")

POST {endpoint}/toolboxes/{toolbox_name}/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{
  "description": "Toolbox with guardrail",
  "tools": [{ "type": "web_search" }],
  "policies": {
    "rai_config": {
      "rai_policy_name": "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<account-name>/raiPolicies/<policy-name>"
    }
  }
}

#pragma warning disable AAIP001
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;

var projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");
DefaultAzureCredential credential = new();
AIProjectClient projectClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: credential);
AgentToolboxes toolboxClient = projectClient.AgentAdministrationClient.GetAgentToolboxes();

var toolboxVersion = toolboxClient.CreateVersion(
  name: "my-toolbox",
    description: "Toolbox with guardrail",
    tools: [new WebSearchToolboxTool()],
    policies: new ToolboxPolicies
    {
        RaiConfig = new RaiConfig { RaiPolicyName = "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<account-name>/raiPolicies/<policy-name>" }
    });
Console.WriteLine($"Created version: {toolboxVersion.Version}");

const toolboxVersion = await project.toolboxes.createVersion(
  "my-toolbox",
  [{ type: "web_search" }],
  {
    description: "Toolbox with guardrail",
    policies: {
      rai_config: {
        rai_policy_name: "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<account-name>/raiPolicies/<policy-name>",
      },
    },
  },
);
console.log(`Created version: ${toolboxVersion.version}`);

name: my-toolbox
description: Toolbox with guardrail
policies:
  rai_config:
    rai_policy_name: /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<account-name>/raiPolicies/<policy-name>
tools:
  - type: web_search

Die Guardrail-Konfiguration ist in der VS Code-Erweiterung noch nicht verfügbar. Verwenden Sie die REST-API, das SDK oder die Azure Developer CLI, um Leitplanken zu konfigurieren.

POST {endpoint}/toolboxes/{toolbox_name}/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json
Accept: application/json
Foundry-Features: Skills=V1Preview

{
  "description": "Toolbox with a skill reference",
  "tools": [],
  "skills": [
    {
      "type": "skill_reference",
      "name": "greeting"
    }
  ]
}

So heften Sie eine bestimmte Version an:

{
  "skills": [
    {
      "type": "skill_reference",
      "name": "greeting",
      "version": "v1"
    }
  ]
}

from azure.ai.projects.models import ToolboxSkillReference

toolbox_version = project.toolboxes.create_version(
    name="my-toolbox",
    description="Toolbox with a skill reference",
    tools=[],
    skills=[
        ToolboxSkillReference(name="greeting"),              # use default version
        # ToolboxSkillReference(name="greeting", version="1"),  # pin to version 1
    ],
)
print(f"Created toolbox version: {toolbox_version.id}")

#pragma warning disable AAIP001
// Reuse the AgentToolboxes client (toolboxClient) from Step 1.
ToolboxSkillReference skillRef = new("greeting");
// To pin a version: new ToolboxSkillReference("greeting") { Version = "1" }

ToolboxVersion toolboxVersion = toolboxClient.CreateVersion(
    name: "my-toolbox",
    tools: [],
    skills: [skillRef],
    description: "Toolbox with a skill reference"
);
Console.WriteLine($"Created toolbox version: {toolboxVersion.Id}");

const toolboxVersion = await project.toolboxes.createVersion(
  "my-toolbox",
  [],
  {
    description: "Toolbox with a skill reference",
    skills: [
      { type: "skill_reference", name: "greeting" },
      // { type: "skill_reference", name: "greeting", version: "v1" },  // pin to v1
    ],
  },
);
console.log(`Created toolbox version: ${toolboxVersion.id}`);

Die Azure Developer CLI unterstützt Skillverweise an zwei Stellen: deklarativ als skills:-Block auf oberster Ebene in der azd ai toolbox create --from-file-YAML-Datei und imperativ mit den azd ai toolbox skill add/list/remove-Verben. Jeder Verweis erfordert ein name (erforderlich) und ein optionales version (Zeichenfolge). Lassen Sie version aus, um der default_version des Skills zu folgen. Geben Sie eine Versionszeichenfolge an, um die Toolbox auf einen unveränderlichen Snapshot festzulegen.

Deklarieren von Fähigkeiten beim Erstellen der Toolbox

# my-toolbox.yaml
description: Toolbox with skill references
connections:
  - name: my-gh-conn
skills:
  - name: greeting              # follows the skill's default version
  - name: review-checklist
    version: "2"               # pin to skill version 2

azd ai toolbox create my-toolbox --from-file ./my-toolbox.yaml --no-prompt

Hinzufügen, Auflisten und Entfernen von Fähigkeiten in einer vorhandenen Toolbox

# Add a skill (follows default version)
azd ai toolbox skill add my-toolbox greeting

# Add a skill pinned to a specific version
azd ai toolbox skill add my-toolbox review-checklist@2

# Add multiple skills from a file (same shape as the create YAML's skills block)
azd ai toolbox skill add my-toolbox --from-file ./skills.yaml

# List skill references on the current default version
azd ai toolbox skill list my-toolbox --output table

# Remove a skill (--force skips the confirmation prompt; multiple names allowed)
azd ai toolbox skill remove my-toolbox greeting --force

skill list zeigt nur die Standardversion an. Angeheftete Skills zeigen ihre Version, nicht angeheftete Skills hingegen zeigen (default). Um Skills in einer ausstehenden Version zu überprüfen, führen Sie azd ai toolbox show <toolbox> --version <n> --output json aus, und lesen Sie das Array skills.

Qualifikationsnamen müssen übereinstimmen ^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$ (Kleinbuchstaben, Ziffern und Bindestriche; max. 64 Zeichen; kein führendes oder nachfolgendes Bindestrich). Eine nachfolgende @ in <name>@<version> (eine leere Version) wird abgelehnt.

Qualifikationsverweise können derzeit nicht über die VS Code-Erweiterung konfiguriert werden. Verwenden Sie die REST-API oder das SDK, um Fähigkeiten zu konfigurieren.

Überprüfen der Fähigkeitserkennung

Überprüfen Sie nach dem Anfügen von Fähigkeiten an eine Toolboxversion, ob Sie sie über den MCP-Endpunkt der Toolbox mithilfe des MCP-Python SDK ermitteln können:

import asyncio
from azure.identity import DefaultAzureCredential
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def list_skills():
    credential = DefaultAzureCredential()
    token = credential.get_token("https://ai.azure.com/.default").token
    toolbox_url = "{endpoint}/toolboxes/my-toolbox/mcp?api-version=v1"
    headers = {
        "Authorization": f"Bearer {token}",
    }
    async with streamablehttp_client(toolbox_url, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            resources = await session.list_resources()
            for resource in resources.resources:
                print(f"Skill: {resource.uri} - {resource.name}")

asyncio.run(list_skills())

Fähigkeiten werden als MCP-Ressourcen mit URIs im Format skill://{name}angezeigt.

Fähigkeiten aus einem Agent nutzen (Microsoft Agent Framework, .NET)

Verwenden Sie in .NET AgentSkillsProviderBuilder().UseMcpSkills(mcpClient) aus dem Microsoft Agent Framework SDK, um MCP-basierte Fähigkeiten von einem Toolboxendpunkt zu ermitteln und sie als AIContextProviders auf dem Agent einzubringen. Der Agent lädt dann zur Laufzeit die Anweisungen der einzelnen Skills, wenn das Modell entscheidet, dass sie relevant sind. Im folgenden Program.cs wird der Agent mit der Hostebene „Antworten“ (AddFoundryResponses und MapFoundryResponses) gehostet.

using System.Net.Http.Headers;
using Azure.AI.Projects;
using Azure.Core;
using Azure.Identity;
using DotNetEnv;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry.Hosting;
using Microsoft.Extensions.AI;
using ModelContextProtocol.Client;

// Load .env file if present (for local development).
Env.TraversePath().Load();

string projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT environment variable is not set.");

string deployment = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME")
    ?? throw new InvalidOperationException("AZURE_AI_MODEL_DEPLOYMENT_NAME environment variable is not set.");

string toolboxName = Environment.GetEnvironmentVariable("TOOLBOX_NAME")
    ?? throw new InvalidOperationException("TOOLBOX_NAME environment variable is not set.");

// Build the Foundry Toolbox MCP URL from the project endpoint and toolbox name.
string toolboxMcpServerUrl = $"{projectEndpoint.TrimEnd('/')}/toolboxes/{toolboxName}/mcp?api-version=v1";

TokenCredential credential = new DefaultAzureCredential();

// HttpClient that attaches a fresh Foundry bearer token to every request.
// CheckCertificateRevocationList = true satisfies CA5399.
using var httpClient = new HttpClient(
    new BearerTokenHandler(credential, "https://ai.azure.com/.default")
    {
        CheckCertificateRevocationList = true,
    });

Console.WriteLine($"Connecting to Foundry Toolbox '{toolboxName}' MCP server...");

// Connect to the Foundry Toolbox MCP endpoint.
await using var mcpClient = await McpClient.CreateAsync(
    new HttpClientTransport(
        new HttpClientTransportOptions
        {
            Endpoint = new Uri(toolboxMcpServerUrl),
            Name = toolboxName,
            TransportMode = HttpTransportMode.StreamableHttp,
        },
        httpClient));

// AgentSkillsProvider implements progressive disclosure over the MCP-discovered skills:
// names and descriptions are advertised in the system prompt, and the full skill body
// (and any supplementary resources) is loaded on demand when the model decides it is
// relevant.
var skillsProvider = new AgentSkillsProviderBuilder()
    .UseMcpSkills(mcpClient)
    .Build();

AIAgent agent = new AIProjectClient(new Uri(projectEndpoint), credential)
    .AsAIAgent(new ChatClientAgentOptions
    {
        Name = "foundry-toolbox-mcp-skills",
        Description = "Agent that discovers MCP-based skills from a Foundry Toolbox and exposes them via AgentSkillsProvider.",
        ChatOptions = new ChatOptions
        {
            ModelId = deployment,
            Instructions = "You are a helpful assistant.",
        },
        AIContextProviders = [skillsProvider],
    });

var builder = AgentHost.CreateBuilder(args);
builder.Services.AddFoundryResponses(agent);
builder.RegisterProtocol("responses", endpoints => endpoints.MapFoundryResponses());

var app = builder.Build();
app.Run();

// HttpClientHandler that attaches a fresh Foundry bearer token to every outgoing request.
internal sealed class BearerTokenHandler(TokenCredential credential, string scope) : HttpClientHandler
{
    private readonly TokenRequestContext _tokenContext = new([scope]);

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        AccessToken token = await credential.GetTokenAsync(this._tokenContext, cancellationToken).ConfigureAwait(false);
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);
        return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
    }
}

Das vollständige Beispiel, einschließlich Projektdateien und Bereitstellungsschritte, finden Sie im Beispiel "Skills in Toolbox".