Een werkset maken en beheren in Foundry

Waarschuwing

Wanneer u verbinding maakt met niet-Foundry-hulpprogramma's, worden er mogelijk kosten in rekening gebracht en worden gegevens mogelijk buiten de nalevingsgrens van Foundry verzonden en verwerkt volgens de toepasselijke voorwaarden en beleidsregels voor gegevensverwerking. Zie de documentatie van het hulpprogramma voor meer informatie over het beheren van de toegang tot het hulpprogramma.

In dit artikel leest u hoe u een werkset maakt, hulpprogramma's toevoegt en configureert, controleert of deze worden geladen, hoe u de werkset integreert in een gehoste agent en hoe u werksetversies beheert. Voor een conceptuele inleiding tot toolboxen, zie Wat is Toolbox in Foundry?. Zie Hulpprogramma's configureren voor de syntaxis van hulpprogramma's en verificatieopties voor elk type hulpprogramma.

Voorwaarden

• Een actief Microsoft Foundry-project.

• RBAC: Verdeel de gebruikersrol Foundry in het Foundry-project aan elke identiteit die van toepassing is op uw scenario:

  • Ontwikkelaar (altijd vereist): de identiteit waarmee werksetversies worden gemaakt, bijgewerkt en beheerd.
  • Agentidentiteit (vereist als u een promptagent gebruikt) - de beheerde identiteit van de agent die hulpprogramma's tijdens runtime aanroept.
  • Eindgebruiker (alleen vereist voor OAuth-stromen): elke gebruiker van wie de identiteit is geproxied via OAuth- of UserEntraToken-verbindingen (bijvoorbeeld op OAuth gebaseerde MCP- of gebruikers-Entra-tokenstromen (passthrough voor beheerde gebruikersidentiteit).

  Zie Machtigingen toewijzen aan de agentidentiteit voor stapsgewijze instructies om de rol Foundry User toe te wijzen aan een agentidentiteit.

• Uw Foundry-project moet zich in een van de ondersteunde regio's bevinden. Afzonderlijke hulpprogrammatypen binnen een werkset worden verder beperkt door regio en model. Niet alle hulpprogrammatypen zijn beschikbaar in elke regio of bij elk model. Zie regio- en modelcompatibiliteit.

• Visual Studio Code (VS Code).

• Installeer de Microsoft Foundry Toolkit voor Visual Studio Code-extensie vanuit de Visual Studio Code Marketplace.

• Python SDK:pip install azure-ai-projects azure-identity

• .NET SDK: installeer de coherente preview-pakketset en Azure Identity:

  dotnet add package Azure.AI.Projects --version 2.1.0-beta.4
  dotnet add package Azure.AI.Projects.Agents --version 2.1.0-beta.4
  dotnet add package Azure.AI.Extensions.OpenAI --version 2.1.0-beta.4
  dotnet add package Azure.Identity
  

• JavaScript SDK: npm install @azure/ai-projects @azure/identity

• Azure Developer CLI: Install the Azure Developer CLI (azd, 1.25 of hoger) en de unified Foundry CLI-extensiebundel:

  # Install the unified bundle (provides azd ai agent, connection, inspector,
  # project, routine, skill, and toolbox).
  azd ext install microsoft.foundry
  

Belangrijk

• Een werkset ondersteunt maximaal één hulpprogramma zonder een name veld (Webzoekopdrachten, Azure AI Zoeken, Code Interpreter, File Search). Als u meer dan één exemplaar van hetzelfde hulpprogrammatype wilt opnemen, stelt u voor elk exemplaar een unieke instantie name in om deze te onderscheiden. Inbegrepen twee instanties van hetzelfde type zonder een name resulteert in een invalid_payload fout. Zie Meerdere hulpprogrammatypen voor meer informatie.
• Voeg een description aan elk hulpprogramma in uw werkset toe om het model te helpen bij het selecteren van het juiste hulpprogramma voor elke aanvraag.
• Raadpleeg de documentatie van elk hulpprogramma zorgvuldig voor meer informatie over het instellen, beperken en waarschuwingen van afzonderlijke hulpprogramma's.

Als u GitHub Copilot gebruikt voor Azure om een gehoste agent te maken die de werkset gebruikt, beschrijven de volgende vaardigheidsverwijzingen hetzelfde eindpuntcontract (env var, headers, MCP-protocol, bronvermeldingspatronen en probleemoplossing) die de agent moet implementeren:

• Naslaginformatie voor de Toolbox met richtlijnen voor eindpuntindeling, het MCP-protocol, de verwerking van OAuth-toestemming, citeringspatronen en probleemoplossing.
• Gebruik de werkset in een gehoste agent om richtlijnen voor eindpuntresolutie, env-var-contract, payloadshape, codeintegratiepatronen en tracering te vinden.

Snelle route

1. Aanmaken:Maak een toolboxversie met een of meer tools. Houd elk fragment gericht op één taak en binnen 30 regels; gebruik de gekoppelde onderhouden voorbeelden voor volledige toepassingen.
2. Een versie publiceren of selecteren: De eerste versie wordt automatisch de standaardwaarde. Voor latere versies kunt u een versie testen en promoveren wanneer u klaar bent om deze als standaardversie te maken.
3. Koppelen en gebruiken: Kopieer het consumenteneindpunt van de werkset en integreer het vervolgens in uw agent.
4. Controleer: Gebruik het versiespecifieke eindpunt om de beschikbare hulpprogramma's weer te geven en voer vervolgens één agentaanvraag uit die een verwacht hulpprogramma aanroept.

Functieondersteuning

SDK's en hulpprogramma's ondersteunen werksetbeheerbewerkingen, zoals wordt weergegeven in de volgende tabel.

Operatie	Python SDK	REST API	.NET SDK	JavaScript SDK	Azure Developer CLI (Command Line Interface voor ontwikkelaars in Azure)	Gieterijgereedschapset
Toolset bijwerken, lijst weergeven, ophalen en verwijderen	✔️	✔️	✔️	✔️	N/A	✔️
Werksetversie maken	✔️	✔️	✔️	✔️	✔️	✔️
Lijst met werksetversies, ophalen en verwijderen	✔️	✔️	✔️	✔️	N/A	Nee. In de gebruikersinterface wordt alleen de nieuwste versie weergegeven.
Waarborg (RAI-beleid)	✔️	✔️	✔️	✔️	✔️	✔️

U kunt toolboxes ook via gesprekken beheren met Foundry MCP Server. Zie Toolboxen beheren met Foundry MCP Server.

U kunt de volgende hulpprogramma's toevoegen aan een werkset. Deze tabel bevat SDK- en hulpprogramma-ondersteuning voor elk hulpprogramma en of het hulpprogramma ook rechtstreeks aan een agent kan worden gekoppeld (buiten een werkset). Zie Netwerkisolatie voor een toolbox voor informatie over hoe het verkeer voor elke tool verloopt wanneer uw project gebruikmaakt van netwerkisolatie.

Tool	In een gereedschapskist	Directe hulpprogramma-integratie	Python SDK	REST API	.NET SDK	JavaScript SDK	Azure Developer CLI (Command Line Interface voor ontwikkelaars in Azure)	Gieterijgereedschapset
Model Context Protocol (MCP)	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Zoeken op internet	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Azure AI Zoeken	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Code-interpreter	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Zoeken naar bestanden	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
OpenAPI	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	Nee
Agent-naar-agent (A2A)	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	Nee
Browserautomatisering	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	Nee
Fabric IQ	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Iq voor werk	✅ Ja	✅ Ja	✔️	✔️	✔️	✔️	✔️	✔️
Zoeken in hulpprogramma's	✅ Ja	❌ Nee	✔️	✔️	✔️	✔️	✔️	✔️
Vaardigheden	✅ Ja	❌ Nee	✔️	✔️	✔️	✔️	✔️	Nee

De beschikbaarheid van hulpprogramma's is ook afhankelijk van de regio en het model van uw project. Voordat u een werkset implementeert, controleert u of uw doelregio ondersteuning biedt voor de hulpprogrammatypen die u wilt gebruiken. Zie Hulpprogramma-ondersteuning per regio en model.

Een toolboxversie maken

Maak een werksetversie op basis van de hulpprogramma's die u nodig hebt.

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

Opmerking

Gebruik tokenbereik https://ai.azure.com/.default bij het ophalen van het bearer token.

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

Gebruik de Microsoft Foundry Toolkit voor Visual Studio Code extensie om een werkset te maken en te publiceren vanuit de weergave Tools.

1. Selecteer Foundry Toolkit in de activiteitenbalk.
2. Vouw onder Mijn resourcesUw projectnaam>Hulpmiddelen uit.
3. Selecteer het pictogram + Toolbox toevoegen.
4. Voer op het tabblad Een aangepaste werkset bouwen de naam en beschrijving van de werkset in en voeg de gewenste hulpprogramma's toe.
5. Als u op intentie gebaseerde hulpprogrammaroutering wilt inschakelen, selecteert u Zoeken in hulpprogramma's.
6. Selecteer Publiceren.

Het publiceren van een nieuwe toolbox creëert de eerste versie. Deze versie wordt automatisch de standaardversie.

Met de geïntegreerde microsoft.foundry uitbreidingsbundel (zie Vereisten) maakt u in twee stappen een werkset:

1. Gebruik azd ai connection create dit om elke projectverbinding te registreren waarnaar de werkset verwijst (één aanroep per referentierecord).
2. Gebruik azd ai toolbox create --from-file <toolbox.yaml> om de gereedschapskist te maken. De YAML verwijst naar verbindingen op naam en sluit nooit referenties in.

Het patroon is hetzelfde voor elk verbindingstype en verificatietype:

1. Stel het actieve project eenmaal per shell in:

   azd ai project set $PROJECT_ENDPOINT
   

2. Maak een verbinding met azd ai connection create. De vlaggen verschillen per authenticatietype, maar de opbouw van de opdracht is altijd:

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

   Gebruik azd ai connection list en azd ai connection show <name> inspecteer verbindingen en azd ai connection delete <name> --force verwijder ze.

3. Een werkset YAML maken die verwijst naar een of meer bestaande verbindingen op naam. De YAML sluit nooit referenties in:

   # 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
   

   Ten minste één van connections, skillsof tools moet niet leeg zijn. Verwijzingen naar vaardigheden moeten verwijzen naar vaardigheden die al bestaan in hetzelfde Foundry-project; zie Vaardigheden gebruiken in Foundry om ze te maken met azd ai skill create. Zie Hulpmiddelen zoeken gebruiken voor configuratiedetails voor end-to-end Tool Search.

4. Maak de werkset op basis van dat bestand:

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

   De eerste versie wordt automatisch de standaardwaarde. Gebruik azd ai toolbox list, azd ai toolbox show <name>, azd ai toolbox version list <name> en azd ai toolbox delete <name> --force om gereedschapskisten te beheren.

Voorbeeld: MCP-server met verificatie op basis van sleutels

# 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

Het MCP-eindpunt van de toolbox ophalen

Er bestaan twee eindpuntpatronen, afhankelijk van uw rol:

Rol	Eindpunt	Wanneer gebruikt u
Toolbox-ontwikkelaar	{project_endpoint}/toolboxes/{toolbox_name}/versions/{version}/mcp?api-version=v1	Test of valideer een specifieke versie voordat u deze standaard promoveert.
Toolbox-gebruiker	{project_endpoint}/toolboxes/{toolbox_name}/mcp?api-version=v1	Verbind agents met de werkset. Bedient altijd de default_version. De eerste versie die u maakt, wordt automatisch ingesteld als de standaardversie.

Vervang de tijdelijke aanduidingen door uw eigen waarden:

• {project_endpoint} is uw Foundry-projecteindpunt, in de vorm https://<your-foundry-account>.services.ai.azure.com/api/projects/<your-project>. Kopieer het vanaf de overzichtspagina van uw project in de Foundry-portal of vanuit de kolom Eindpunt-URL in de werksetweergave van de Microsoft Foundry Toolkit voor Visual Studio Code.
• {toolbox_name} en {version} zijn de naam en versie van de werkset die u hebt gemaakt in een werksetversie maken.

Tip

Verbind agents met het eindpunt van de toolbox consumer. Het levert altijd de default_version, zodat u nieuwe versies kunt uitrollen zonder de agentcode te wijzigen of opnieuw uit te rollen. Reserveer het toolbox-ontwikkelaar-eindpunt (versiespecifiek) om een versie te testen voordat u deze promoveert.

Opmerking

De eerste versie van een nieuwe werkset wordt automatisch gepromoveerd naar default_version (v1). Als u de standaardwaarde later wilt wijzigen, zie Een versie als standaard instellen.

Kopieer in de extensie Microsoft Foundry Toolkit voor Visual Studio Code het consumereindpunt van de toolbox uit de weergave Toolboxes.

1. Selecteer Foundry Toolkit in de activiteitenbalk.
2. Vouw onder Mijn resourcesUw projectnaam>Hulpmiddelen uit.
3. Zoek uw gereedschapskist op het tabblad Gereedschapskisten.
4. Kopieer het eindpunt in de kolom Eindpunt-URL .

De Endpoint URL-waarde is het eindpunt voor de gebruiker van de toolbox. Als u een versiespecifiek eindpunt wilt maken, gebruikt u het ontwikkelaarspatroon dat in de vorige tabel wordt weergegeven.

Beschikbaarheid van hulpprogramma's controleren

Voordat u de volledige agent uitvoert, controleert u of de werkset de verwachte hulpprogramma's laadt met behulp van een MCP-client-SDK voor het eindpunt. Gebruik het versiespecifieke eindpunt om een versie te valideren voordat u deze naar de standaardwaarde promoveert.

Installeer de MCP-client-SDK:

pip install mcp

Verbind met de gereedschapskist en som de hulpprogramma's op

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())

Opmerking

Gebruik het tabblad REST API om de beschikbaarheid van hulpprogramma's te controleren vanuit .NET of gebruik de Python MCP-client-SDK.

Gebruik het versiespecifieke eindpunt (/versions/{version}/mcp) om een versie te valideren voordat u deze promoveert.

1. Initialiseer de MCP-sessie:

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. De geïnitialiseerde melding verzenden:

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. Beschikbare hulpprogramma's weergeven:

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. Een hulpprogramma aanroepen:

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":{}}}

Installeer de MCP-client-SDK:

npm install @modelcontextprotocol/sdk

Verbind met de gereedschapskist en som de hulpprogramma's op

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();

Gebruik het MCP-eindpunt van de Toolbox met een gescaffold voorbeeld van een gehoste agent om het laden van de Toolbox in VS Code te verifiëren.

1. Zoek in Foundry Toolkit onder My Resources>Your project name>Tools de werkset die u wilt testen.
2. Selecteer Sjabloon voor scaffold-code.
3. Kies een projectmap wanneer u hierom wordt gevraagd.
4. Volg de gegenereerde README.md om afhankelijkheden te installeren, omgevingsvariabelen te configureren en het voorbeeld lokaal uit te voeren.
5. Gebruik Agent Inspector of voer python main.py uit om te bevestigen dat de tools van het gereedschap laden en reageren.

Voor versiespecifieke validatie voordat u een nieuwe werksetversie promovt, gebruikt u het tabblad Python of REST API in deze stap.

Opmerking

Gebruik het tabblad REST API om de beschikbaarheid van hulpprogramma's te controleren of gebruik de Python MCP-client-SDK.

Controleren — initialiseren: HTTP 200. Als u de initialisatiestap overslaat, mislukken volgende aanroepen.

Controle — : tools/list

• len(tools) > 0 — leeg betekent dat de toolbox-versie niet correct is geconfigureerd.

• Elk hulpmiddel heeft name, descriptionen inputSchema. Zie de MCP-specificatie voor naamconventies voor hulpprogramma's.

• inputSchema heeft een properties veld (sommige MCP-servers laten dit veld weg, waardoor OpenAI wordt verbroken).

• Namen van hulpprogramma's zijn voorzien van een naamruimte op basis van het type hulpprogramma:

  Type gereedschap	Indeling van hulpprogrammanaam	Example
  MCP	{server_label}.{tool_name}	myserver.some_tool
  OpenAPI	{openapi_name}.{operationId}	weatherapi.getForecast
  A2A	De name van de tool (agentnaam), of de verbindingsnaam als name ontbreekt	myagent
  Alle andere typen hulpmiddelen	De name veldwaarde of de standaardnaam van het hulpprogramma	web_search

• MCP-hulpprogramma's bevatten een _meta.tool_configuration blok met runtime-instellingen, zoals require_approval. Zie Goedkeuring van tools afdwingen.

• Noteer de exacte parameternamen voor de aanroepstap (bijvoorbeeld query vs queries).

Controle - tools/call:

• Geen veld op het hoogste niveau error . Indien aanwezig, inspecteert u error.code. Zie de MCP-specificatie voor standaard MCP-foutcodes:
  • -32006 → OAuth-toestemming vereist (URL extraheren uit error.message).
  • Andere codes → fout aan de serverzijde.
• result.content[] bevat vermeldingen met "type": "text" - dit is de uitvoer van het hulpprogramma.
• Voor AI Search, controleer result.structuredContent.documents[] voor chunk-metadata (title, url, id, score).
• Voor Bestand Zoeken, controleer result.content[].resource._meta op segmentmetagegevens (title, file_id, document_chunk_id, score).
• Voor webzoekopdrachten controleer result.content[].resource._meta.annotations[] voor URL-bronvermeldingen (type, url, title, start_index, end_index).
• Voor Fabric IQ controleert u result.structuredContent.documents[] voor citatiesegmenten. Elk document bevat title en url velden die terug wijzen naar het Fabric item (Ontology, data agent of Power BI semantisch model) dat wordt gebruikt om het antwoord te gronden.
• Let op "ServerError" in tekstinhoud: het hulpprogramma is uitgevoerd, maar er is een interne fout opgetreden.

Voorbeelden van hulpprogrammaspecifieke tools/call argumenten:

Type gereedschap	Argumenten
AI Zoeken	{"query": "search text"}
Zoeken naar bestanden	{"queries": ["search text"]} — of {"queries": ["search text"], "vector_store_ids": ["<VECTOR_STORE_ID>"]} wanneer vectoropslag dynamisch wordt doorgegeven
Code-interpreter	{"code": "print(2 ** 100)"}
Zoeken op internet	{"search_query": "weather in seattle"}
A2A	{"message": {"parts": [{"type": "text", "text": "Hello"}]}}
Fabric IQ	Verschilt per beschikbaar gesteld hulpprogramma — meestal {"query": "..."} voor querytools
Iq voor werk	{"message": {"parts": [{"type": "text", "text": "Hello"}]}}
MCP	{"query": "what is agent service"}

Integreer de toolbox in je agent

LangGraph

Vereisten voor gehoste integratiefragmenten: Installeren langchain-azure-ai[tools]>1.2.3. Het fragment gebruikt AzureAIProjectToolbox; gebruik het onderhouden LangGraph-voorbeeld voor de volledige agent, set pakketten en implementatiebestanden.

.env bestand:

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 (sleutelpatroon):

from langchain_azure_ai.tools import AzureAIProjectToolbox

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

Belangrijk

Voor klasse langchain_azure_ai.tools.AzureAIProjectToolbox is vereist langchain-azure-ai[tools]>1.2.3.

Microsoft Agent Framework

Vereisten voor gehoste integratiefragmenten: Installeer agent-framework-foundry en httpx naast het vereiste Azure Identity-pakket. Het fragment is afhankelijk van een _ToolboxAuth helper en omringende client en hostinstallatie. Gebruik het onderhouden Agent Framework-voorbeeld, dat de volledige set pakketten en de onderhouden toolbox-authenticatiewrapper bevat.

Gebruik MCPStreamableHTTPTool van de Agent Framework SDK om rechtstreeks verbinding te maken met het MCP-eindpunt van de toolbox.

.env bestand:

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 (sleutelpatroon):

# Auth: wrap token provider in an httpx.Auth subclass
credential = DefaultAzureCredential()
token_provider = get_bearer_token_provider(credential, "https://ai.azure.com/.default")
http_client = httpx.AsyncClient(
    auth=_ToolboxAuth(token_provider),
    timeout=120.0,
)

# 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"

# Connect MCPStreamableHTTPTool to the toolbox endpoint
mcp_tool = MCPStreamableHTTPTool(
    name="toolbox",
    url=TOOLBOX_ENDPOINT,
    http_client=http_client,
    load_prompts=False,
)

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

Copilot SDK

Vereisten voor gehoste integratiefragmenten: Installeer de GitHub Copilot SDK voor uw runtime. De opzet is afhankelijk van hulpfuncties McpBridge en _get_toolbox_token die eigendom zijn van de toepassing en hier niet zijn geïmplementeerd. Volg het bestaande toolbox-eindpunt en authenticatiecontract en de integratiepatronen voor gehoste agents. Een onderhouden volledig voorbeeld is nog niet beschikbaar.

Gebruik de GitHub Copilot SDK om een door toolbox aangedreven agent te bouwen die het aanroepen van de tools van Copilot overbrugt naar het MCP-eindpunt van de Foundry-toolbox.

Opmerking

De Copilot SDK weigert namen van hulpprogramma's die puntjes bevatten. De brug vervangt automatisch . door _ in de namen van hulpprogramma's. Bijvoorbeeld, myserver.get_info wordt myserver_get_info.

.env bestand:

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 (sleutelpatroon — MCP-brug):

# 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

Vereisten voor gehoste integratiefragmenten: In dit fragment worden typen uit de Azure.AI.AgentServer.Responsespakketten , Azure.AI.OpenAI, Azure.IdentityMicrosoft.Extensions.DependencyInjectionen OpenAI pakketten gebruikt. ToolboxMcpClient, ToolboxHandleren AgentConfig zijn aangepaste helpers die hier niet zijn gedefinieerd. Gebruik voor een onderhouden integratie, inclusief pakketverwijzingen en een volledige hostconfiguratie, het openbare voorbeeld Agent Framework hosted-toolbox.

Gebruik ResponsesServer vanuit de Agent Framework SDK met een aangepaste ToolboxMcpClient om toolbox-tools te ontdekken en aan te roepen via het MCP-eindpunt.

Omgevingsvariabelen:

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

Program.cs (sleutelpatroon):

using Azure.AI.AgentServer.Responses;
using Azure.AI.AgentServer.Responses.Models;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.DependencyInjection;
using OpenAI.Chat;

// Azure OpenAI endpoint and model deployment
var openAiEndpoint = "https://<account>.services.ai.azure.com";
var deployment = "gpt-4o";  // supports all toolbox tool types

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

// Azure OpenAI client
var credential = new DefaultAzureCredential();
var openAIClient = new AzureOpenAIClient(new Uri(openAiEndpoint), credential);
var chatClient = openAIClient.GetChatClient(deployment);

// Toolbox MCP client — discovers tools via tools/list, calls them via tools/call
var toolboxClient = new ToolboxMcpClient(toolboxEndpoint, credential);

ResponsesServer.Run<ToolboxHandler>(configure: builder =>
{
    builder.Services.AddSingleton(new AgentConfig(chatClient, toolboxClient));
});

ToolboxMcpClient verpakt directe JSON-RPC aanroepen naar het MCP-eindpunt. ToolboxHandler verbindt LLM-hulpprogramma-aanroepen terug naar de MCP-client met behulp van een standaardlus voor het aanroepen van hulpprogramma's.

Opmerking

Integratievoorbeelden voor deze stap zijn alleen beschikbaar voor Python en .NET.

Opmerking

Integratievoorbeelden voor deze stap zijn alleen beschikbaar voor Python en .NET.

Gebruik de Microsoft Foundry Toolkit-extensie voor Visual Studio Code om een voorbeeld van een gehoste agent te genereren dat al is gekoppeld aan uw toolbox.

1. Selecteer Foundry Toolkit in de activiteitenbalk.
2. Vouw onder Mijn resourcesUw projectnaam>Hulpmiddelen uit.
3. Zoek op het tabblad Toolboxes de toolbox die u wilt gebruiken en selecteer vervolgens sjabloon voor scaffold-code.
4. Kies in het opdrachtpalet een projectmap wanneer hierom wordt gevraagd.
5. Open de gegenereerde README.md en volg de installatie-, lokale uitvoerings- en implementatiestappen voor het framework.

Het gegenereerde project bevat het toegangspunt van de gehoste agent, implementatiebestanden en een README.md met de exacte installatie-, uitvoerings- en implementatiestappen.

Als u een werkset wilt integreren in een bestaand gehost agentproject in plaats van een nieuw voorbeeld te genereren, gebruikt u het MCP-eindpunt van de werkset met de Python of .NET patronen in deze sectie.

Geef het toolbox-eindpunt door aan uw agent

Nadat u de toolbox hebt gemaakt, haalt u het MCP-eindpunt op met azd ai toolbox show en geeft u dat eindpunt als omgevingsvariabele door aan de code van uw agent. De agent leest de variabele bij het opstarten en gebruikt deze om verbinding te maken met de werkset.

1. Haal het toolbox-eindpunt op:

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

   Het endpoint veld in het antwoord identificeert de geselecteerde versie. Gebruik deze om die versie te testen vóór promotie. Voor een agent die default_version moet volgen, stelt u het ongeversioneerde consumer-eindpunt samen dat wordt weergegeven in Het MCP-eindpunt van de toolbox ophalen.

2. Stel het eindpunt in als een omgevingsvariabele die uw agent leest bij het opstarten:

   # .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. Lees TOOLBOX_ENDPOINT en maak er verbinding mee met een MCP-client in uw agentcode. Gebruik de Python of .NET-integratiepatronen eerder in deze sectie als referentie voor de clientinstallatie en het Entra-token (https://ai.azure.com/.defaultbereik).

Omgaan met goedkeuringsvereisten voor tools

De gereedschapskist retourneert een _meta.tool_configuration object in elke gereedschapinschrijving die wordt geretourneerd door tools/list. Wanneer het hulpprogramma require_approval is ingesteld op "always", moet de agentruntime de hangende actie aan de gebruiker presenteren en wachten op bevestiging voordat het hulpprogramma wordt aangeroepen. Het MCP-eindpunt blokkeert tools/call niet. Het afdwingen hiervan is volledig de verantwoordelijkheid van de runtime van de agent.

Nadat uw toolbox is gemaakt en getest, koppelt u die vervolgens aan een agent. Het integratiepatroon is afhankelijk van het agenttype:

• Gehoste agent (uw eigen code die wordt uitgevoerd in Foundry Agent Service): zie Een werkset gebruiken met een gehoste agent voor Agent Framework, LangGraph, Visual Studio Code en Azure Integratiepatronen voor Ontwikkelaars-CLI en goedkeuringsvereisten voor runtime.

Configureer require_approval in een hulpprogramma

Wanneer u een toolsetversie maakt, stel require_approval in. De voorbeelden van het MCP-hulpprogramma in Een toolboxversie maken tonen zowel "always"- als "never"-waarden. Ga als volgende te werk om deze in te stellen via de SDK:

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",
  },
];

Gebruik het tabblad Python, .NET, JavaScript, REST API of Azure Developer CLI om te configureren require_approval in uw werksetdefinitie. De werkstroom van de extensie Microsoft Foundry Toolkit voor Visual Studio Code in dit artikel richt zich op het maken en gebruiken van de werkset 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

Versies van de gereedschapskist beheren

Opmerking

U kunt werksetversies alleen verwijderen via de Python SDK, .NET SDK, JavaScript SDK en REST API. De Azure Developer CLI ondersteunt bewerkingen voor weergeven, ophalen en publiceren (promotie van de standaardversie).

Toolbox-versies zijn onveranderbare momentopnamen van de configuratie van een toolbox's hulpprogramma's. Elke aanroep van het aanmaak-eindpunt produceert een nieuwe ToolboxVersionObject. Het bovenliggende ToolboxObject element heeft een default_version veld dat bepaalt welke versie door het MCP-eindpunt wordt aangeboden. Als u een nieuwe versie maakt, wordt deze niet automatisch gepromoot. U bepaalt wanneer u wilt bijwerken default_version. Met dit proces kunt u wijzigingen faseereren, een nieuwe versie onafhankelijk testen en deze volgens uw eigen planning naar productie promoveren.

Opmerking

Voor de Azure Developer CLI maakt elke mutatiebewerking die is gericht op de huidige standaardversie ( azd ai toolbox connection add/remove en azd ai toolbox skill add/remove) een nieuw werksetversie die alle eerder gekoppelde verbindingen en vaardigheden doorstuurt met de aangevraagde wijziging die is toegepast. Geen van deze opdrachten wijzigt automatisch default_version; voer azd ai toolbox publish <toolbox-name> <version> uit wanneer u klaar bent om de nieuwe versie actief te maken. Als u een in behandeling zijnde (niet-standaard) versie wilt controleren, gebruikt u azd ai toolbox show <name> --version <n>.

Object	Sleutelvelden	Beschrijving
ToolboxObject	id, name, default_version	De gereedschapsdoos-container. default_version verwijst naar de actieve versie.
ToolboxVersionObject	id, , nameversion, description, , created_at, , tools[]policies	Een onveranderbare momentopname van de lijst met hulpprogramma's van de werkset op een bepaald moment. policies.rai_config.rai_policy_name geeft de optionele guardrail aan die op deze versie wordt toegepast.

Een nieuwe versie maken

Elke aanroep om te creëren produceert een nieuwe versie. Als de werkset nog niet bestaat, maakt het proces deze automatisch aan. Wanneer u de eerste versie van een nieuwe werkset maakt, is v1 de standaardversie totdat u handmatig bijwerkt naar een andere versie.

# 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}`);

Gebruik het tabblad Python, .NET, JavaScript of REST API om een nieuwe werksetversie te maken. De werkstroom van de Microsoft Foundry Toolkit-extensie voor Visual Studio Code in dit artikel is gericht op het maken van een toolbox en het genereren van de basisstructuur voor een gehoste agent die hiervan gebruikmaakt.

Deze bewerking wordt niet ondersteund met de Azure Developer CLI. Als u een werksetversie wilt maken, gebruikt u het tabblad Python, .NET, REST-API of JavaScript.

Het antwoord bevat ToolboxVersionObject de nieuwe version id.

Versies weergeven

# 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}`);
}

Gebruik het tabblad Python, .NET, JavaScript of REST API om werksetversies weer te geven.

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

Een specifieke versie ophalen

# 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}`);

Gebruik het tabblad Python, .NET, JavaScript of REST API om een specifieke werksetversie op te halen.

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

Niveau van een versie naar standaard verhogen

Het MCP-eindpunt dient altijd het default_version. Als u wilt overschakelen welke versie actief is, werkt u de werkset bij:

# 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 mag niet leeg zijn. Vervang deze door een nieuwe versie.

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

Gebruik het tabblad Python, .NET, JavaScript of REST API om de standaardversie van een werkset te promoten.

Toolboxversies zijn niet wijzigbaar. Gebruik publish dit om een bestaande versie de nieuwe standaardversie te maken:

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

publish is de enige manier om default_version te wijzigen vanuit de CLI; muterende werkwoorden (connection add/remove, skill add/remove) maken altijd een nieuwe versie aan zonder deze te promoveren.

Een versie verwijderen

# 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>",
);

Gebruik het API-tabblad Python, .NET, JavaScript of REST om een toolboxversie te verwijderen.

Deze bewerking wordt niet ondersteund met de Azure Developer CLI. Als u een werksetversie wilt verwijderen, gebruikt u de Python, .NET, REST-API of JavaScript tabblad.

Toolboxen beheren met Foundry MCP Server

Foundry MCP Server (preview) maakt werksetbeheer beschikbaar als MCP-hulpprogramma's, zodat u werksets kunt ophalen, versie, bijwerken en verwijderen van een MCP-client, zoals GitHub Copilot in Visual Studio Code. Zie Aan de slag met Foundry MCP Server (preview) om de server in te stellen.

Tool	Toegang	Beschrijving
toolbox_get	read	Haal een toolbox en de momenteel ingestelde standaardversie op.
toolbox_version_get	read	Toolboxversies weergeven of een specifieke versie ophalen.
toolbox_version_create	write	Maak een onwijzigbare toolboxversie. Als de toolbox niet bestaat, maakt dit hulpprogramma deze ook aan.
toolbox_update	write	Een gereedschapsset maken of bijwerken, inclusief de standaardversie.
toolbox_delete	write	Een gereedschapskist verwijderen.
toolbox_version_delete	write	Verwijder een specifieke toolboxversie.

Dezelfde versiebeheerregels zijn van toepassing op de SDK's. Als u een versie voor een bestaande werkset maakt, wordt de standaardversie niet gewijzigd. Als u een versie wilt promoveren, roept u toolbox_update aan met defaultVersion ingesteld op de nieuwe versie. Voordat u de huidige standaardversie verwijdert, stelt u een andere versie in als de standaardversie.

Voorbeeldprompts:

• Laat me de customer-support-tools toolbox zien.
• 'Download versie 2 van customer-support-tools'.
• 'Maak een nieuwe versie van customer-support-tools'.
• 'Versie 2 van customer-support-tools instellen als de standaardwaarde'.
• 'Stel versie 1 van customer-support-tools als de standaardwaarde in en verwijder vervolgens versie 2.'
• Verwijder de old-support-tools gereedschapskist.

Zie Beschikbare hulpprogramma's en voorbeeldprompts voor Foundry MCP Server voor de volledige naslaginformatie over hulpprogramma's.

Hulpprogramma's configureren

Kies het hulpprogrammatype en het verificatiepatroon dat overeenkomt met uw scenario. Selecteer het tabblad voor de gewenste SDK of implementatiemethode.

Het azd-tabblad van elk hulpprogramma hieronder toont declaratieve werkset YAML. Als u zonder een agentproject op imperatieve wijze een toolbox wilt maken, gebruikt u de azd ai toolbox create --from-file workflow en past u de gegevens per hulpprogramma toe zoals weergegeven in de volgende secties. Als u een toolbox met een gehoste agent wilt implementeren, modelleert u deze als een azure.ai.toolbox-service in azure.yaml en verbindt u de agent ermee met uses: of toolboxes:.

Meerdere hulpprogrammatypen

Eén werkset kan verschillende hulpprogrammatypen bundelen. In het volgende voorbeeld worden webzoekopdrachten, Azure AI Zoeken en een MCP-server in één werkset gecombineerd:

{
  "description": "Web search, knowledge base search, and custom MCP server",
  "tools": [
    {
      "type": "web_search",
      "description": "Search the web for current information"
    },
    {
      "type": "azure_ai_search",
      "name": "my_aisearch",
      "description": "Search internal product documentation",
      "azure_ai_search": {
        "indexes": [
          {
            "index_name": "<INDEX_NAME>",
            "project_connection_id": "<CONNECTION_NAME>"
          }
        ]
      }
    },
    {
      "type": "mcp",
      "server_label": "myserver",
      "server_url": "https://your-mcp-server.example.com",
      "require_approval": "never",
      "project_connection_id": "my-key-auth-connection"
    }
  ]
}

Opmerking

Elk type hulpprogramma (web_search, azure_ai_search, code_interpreter, file_search) kan maximaal één keer worden weergegeven zonder een name veld. Als u meerdere exemplaren van hetzelfde type wilt opnemen, stelt u een unieke name op elk exemplaar in. Zie het volgende voorbeeld.

Beperkingen voor meerdere hulpprogramma's

U kunt maximaal één exemplaar van elk ingebouwd hulpprogrammatype opnemen zonder een name veld in een werkset. Als u twee exemplaren van hetzelfde type zonder een nameopneemt, retourneert de API:

400 invalid_payload: Multiple tools without identifiers found...

Twee exemplaren van hetzelfde hulpprogrammatype

Gebruik het name veld om meerdere exemplaren van hetzelfde hulpprogrammatype in één werkset op te nemen. Elk benoemd exemplaar wordt behandeld als een afzonderlijke tool en moet een unieke naam hebben.

{
  "description": "Two Azure AI Search indexes in a single toolbox",
  "tools": [
    {
      "type": "azure_ai_search",
      "name": "product-search",
      "description": "Search product catalog and specifications",
      "azure_ai_search": {
        "indexes": [
          {
            "index_name": "<PRODUCT_INDEX_NAME>",
            "project_connection_id": "<PRODUCT_CONNECTION_NAME>"
          }
        ]
      }
    },
    {
      "type": "azure_ai_search",
      "name": "support-search",
      "description": "Search support tickets and troubleshooting guides",
      "azure_ai_search": {
        "indexes": [
          {
            "index_name": "<SUPPORT_INDEX_NAME>",
            "project_connection_id": "<SUPPORT_CONNECTION_NAME>"
          }
        ]
      }
    }
  ]
}

Elk hulpprogrammatype heeft een eigen werksetconfiguratie: verbindingsverificatietypen, SDK-fragmenten per taal en elk werksetspecifiek gedrag. Deze details bevinden zich in het naslagartikel van elk hulpprogramma. Zie de ondersteuningstabel voor functies voor een koppeling naar elk hulpprogramma.

Voor gedrag dat specifiek is voor een hulpprogramma, zoals de dynamische vectorstore van File Search (parameteroverschrijving) of bestandsuploads op resourceniveau voor Code Interpreter en File Search, raadpleegt u het gekoppelde artikel voor elk hulpprogramma.

Beveiligingen configureren

Pas een benoemd kaderbeleid toe op een werksetversie om verantwoorde AI-inhoudsfiltering af te dwingen op invoer en uitvoer van hulpprogramma's. De beveiligingsmaatregel werkt op de toolboxlaag, onafhankelijk van enig inhoudsfilter op modelniveau.

Verwijs naar een guardrail aan de hand van de beleidsnaam, die u in de Foundry-portal onder Guardrails configureert. Stel policies.rai_config.rai_policy_name in op de naam van het beleid bij het maken van een toolboxversie.

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

Guardrail-configuratie is nog niet beschikbaar in de VS Code-extensie. Gebruik de REST API, SDK of Azure Developer CLI om kaders te configureren.

Vaardigheden koppelen aan een werkset

Koppel vaardigheden aan een werksetversie om deze beschikbaar te maken voor agents via het MCP-eindpunt van de werkset. Elke vaardigheidsreferentie geeft de naam van de vaardigheid en een optionele versie aan. Laat version weg om de default_version van de vaardigheid te gebruiken; zet een version-tekenreeks vast om een onveranderlijke momentopname te gebruiken.

Een werksetversie kan hulpprogramma's, vaardigheden of beide bevatten. In de volgende voorbeelden wordt een werksetversie gemaakt die één referentie voor vaardigheden bevat. Als u vaardigheden wilt toevoegen aan een werkset die al hulpprogramma's bevat, neemt u hetzelfde tools op als u hebt gebruikt in een werksetversie maken , samen met de skills matrix.

Belangrijk

Vaardigheden die aan een werkset zijn gekoppeld, moeten aanwezig zijn in hetzelfde Foundry-project. Verwijzingen tussen projecten worden niet ondersteund.

Wanneer een agent of MCP-client verbinding maakt met het werkseteindpunt, worden vaardigheden weergegeven als MCP-resources. Het MCP-client- of agentframework moet het MCP-resourcesprotocol ondersteunen voor het automatisch detecteren en laden van vaardigheden. Als u wilt controleren of vaardigheden detecteerbaar zijn, roept resources/list u het MCP-eindpunt van de werkset aan en bevestigt u dat uw vaardigheidsnamen worden weergegeven in het antwoord.

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

Een specifieke versie vastzetten:

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

De Azure Developer CLI ondersteunt verwijzingen naar vaardigheden op twee plaatsen: declaratief als een skills: blok op het hoogste niveau in de azd ai toolbox create --from-file YAML, en imperatief met de azd ai toolbox skill add/list/remove werkwoorden. Elke verwijzing heeft een name (vereist) en een optionele version (tekenreeks). Laat version weg om de default_version van de vaardigheid te volgen; zet een versie vast om de toolbox te vergrendelen op een onwijzigbare snapshot.

Vaardigheden declareren wanneer u de werkset maakt

# 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

Vaardigheden toevoegen, weergeven en verwijderen in een bestaande werkset

# 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 geeft alleen de standaardversie weer. Vastgezette vaardigheden tonen hun versie; niet-vastgezette vaardigheden tonen (default). Als u vaardigheden in een versie die nog in behandeling is wilt inspecteren, voert u azd ai toolbox show <toolbox> --version <n> --output json uit en leest u de array skills.

Belangrijk

skill add en skill remove maken elk een nieuwe toolboxversie waarin alle eerder gekoppelde verbindingen en vaardigheden behouden blijven, met toepassing van de gevraagde wijziging. Ze maken de nieuwe versie niet de standaardversie, dus wijzigingen zijn niet zichtbaar voor MCP-clients totdat u azd ai toolbox publish <toolbox> <version> uitvoert. Als u de vastgemaakte versie van een vaardigheid wilt wijzigen die al is gekoppeld( bijvoorbeeld een upgrade greeting van v1 naar v2), voert u drie opdrachten uit in volgorde: skill remove, publish de nieuwe versie en vervolgens skill add <name>@<new-version> (skill add blokkeert duplicaten wanneer deze worden gecontroleerd op basis van de huidige standaardversie).

Namen van vaardigheden moeten overeenkomen ^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$ (kleine letters, cijfers en afbreekstreepjes; maximaal 64 tekens; geen voorloop- of volgafbreekstreepje). Een afsluitende @ in <name>@<version> (een lege versie) wordt afgewezen.

Vaardigheidsverwijzingen kunnen momenteel niet worden geconfigureerd via de VS Code-extensie. Gebruik de REST API of SDK om vaardigheden te configureren.

Vaardigheidsdetectie valideren

Nadat u vaardigheden hebt gekoppeld aan een werksetversie, controleert u of u deze kunt detecteren via het MCP-eindpunt van de werkset met behulp van de MCP Python SDK:

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())

Vaardigheden worden weergegeven als MCP-resources met URI's in de indeling skill://{name}.

Skills van een agent gebruiken (Microsoft Agent Framework, .NET)

Gebruik in .NET AgentSkillsProviderBuilder().UseMcpSkills(mcpClient) van de Microsoft Agent Framework SDK om op MCP gebaseerde vaardigheden te detecteren vanuit een werkseteindpunt en deze in te voeren als AIContextProviders op de agent. De agent laadt vervolgens de instructies van elke vaardigheid tijdens runtime wanneer het model besluit dat deze relevant is. De volgende Program.cs fungeert als host voor de agent met de hostinglaag voor Responses (AddFoundryResponses en MapFoundryResponses).

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

Zie het voorbeeld vaardigheden in werkset voor het volledige voorbeeld, inclusief projectbestanden en implementatiestappen.

Herinnering

Met het hulpprogramma reminder_preview kan een gehoste agent plannen om zichzelf op een later moment opnieuw te laten uitvoeren. Wanneer de agent dit hulpprogramma aanroept, wordt een vertraging in minuten opgegeven. Na die vertraging roept Foundry dezelfde agent opnieuw aan in hetzelfde gesprek.

Problemen oplossen

Symptoom	Waarschijnlijke oorzaak	Fix
tools/list retourneert nul hulpprogramma's voor MCP- en A2A-processen	Ongeldige of ontbrekende verbindingsreferenties voor de externe MCP-server of A2A-agent. De werkset kan geen hulpprogrammamanifesten ophalen van het externe eindpunt zonder geldige verificatie.	Controleer of het project_connection_id bestaat in uw Foundry-project en of de referenties juist zijn. Probeer rechtstreeks verbinding te maken met de MCP-server om de verificatie-instelling te testen. Als u beheerde identiteit (PMI, agentidentiteit of MI) gebruikt, controleert u de juiste RBAC-roltoewijzingen voor de aanroeper op de doelresource.
tools/list retourneert nul hulpprogramma's voor OpenAPI-hulpprogramma's	Ongeldige OpenAPI-specificatie. De werkset maakt het hulpprogrammamanifest op basis van de specificatie, wat mislukt als de specificatie ongeldig is.	Valideer de inhoud van de OpenAPI-specificatie. Controleer of deze voldoet aan OpenAPI 3.0 of 3.1 en bevat geldige paths, operationId waarden en parameterschema's. Als u verificatie van beheerde identiteiten gebruikt, controleert u ook RBAC-roltoewijzingen op de doelservice.
tools/list retourneert minder hulpprogramma's dan verwacht	Het allowed_tools filter bevat onjuiste of verkeerd gespelde namen van hulpprogramma's. Namen van hulpprogramma's zijn hoofdlettergevoelig en moeten de MCP-specificatie voor hulpprogrammanamen (geen spaties of speciale tekens) volgen.	Verwijder allowed_tools tijdelijk en roep tools/list aan om de volledige lijst met hulpprogramma's op te halen. Gebruik de exacte namen uit het antwoord om waarden in te stellen voor allowed_tools.
tools/list retourneert geen tools (andere gereedschappen)	De gereedschapskist is niet volledig ingericht of het hulptype wordt niet ondersteund in deze regio. Voor ingebouwde hulpprogramma's (Webzoekopdrachten, AI Search, Code Interpreter, File Search), worden hulpprogrammamanifesten gemaakt aan de serverzijde en zijn geen verificatie vereist. Als ze leeg zijn, is de versie van de werkset mogelijk nog niet ingericht.	Wacht 10 seconden en probeer het opnieuw.
400 Multiple tools without identifiers	Twee typen hulpprogramma's zonder naam in één werkset	Houd maximaal één naamloos type; toevoegen server_label aan alle MCP-hulpprogramma's.
CONSENT_REQUIRED (code -32006)	OAuth-verbinding vereist toestemming van de gebruiker	Open de toestemmings-URL in een browser en voltooi de OAuth-stroom en probeer het opnieuw.
401 bij MCP-aanroepen	Verlopen token of verkeerd bereik	Gebruik het bereik https://ai.azure.com/.default en vernieuw het token.
Namen van hulpprogramma's komen niet overeen	Namen van MCP-hulpprogramma's worden voorafgegaan door server_label	Gebruik {server_label}.{tool_name} de notatie (bijvoorbeeld myserver.get_info).
500 Op send_ping()	De MCP-server van de werkset implementeert de MCP-methode ping niet.	Bel niet send_ping(). Als uw framework dit automatisch aanroept (bijvoorbeeld Microsoft Agent Framework MCPStreamableHTTPTool._ensure_connected()), schakelt u de pingcontrole uit of overschrijft u de methode met een no-op.
500 Op prompts/list	De Foundry MCP-server implementeert niet prompts/list.	Geef load_prompts=False (of gelijkwaardig) door aan uw MCP-clientconstructor.
500 met niet-streamend tools/call	Niet-streamingmodus (stream=False) wordt niet ondersteund voor MCP-eindpunten van de werkset.	Gebruik altijd stream=True bij het aanroepen van MCP-toolboxhulpprogramma's.
500 Op tools/list	Tijdelijke serverfout	Probeer het na een paar seconden opnieuw.
Omgevingsvariabelen die tijdens de uitvoertijd worden overschreven	Het platform reserveert alle omgevingsvariabelen die voorafgegaan zijn door FOUNDRY_ en overschrijft mogelijk op de achtergrond door de gebruiker gedefinieerde waarden.	Wijzig de naam van aangepaste omgevingsvariabelen om het FOUNDRY_ voorvoegsel te voorkomen (gebruik bijvoorbeeld TOOLBOX_MCP_ENDPOINT in plaats van FOUNDRY_TOOLBOX_ENDPOINT).

Het herinneringsprogramma is alleen beschikbaar voor gehoste agents. U kunt het herinneringshulpmiddel niet gebruiken met prompt-agenten.

Zie het hulpprogramma Herinnering voor zelfplanningsagenten voor volledige installatie-instructies, gebruiksvoorbeelden en beperkingen.

Regio- en modelcompatibiliteit

Beschikbaarheid van werksets is afhankelijk van twee factoren buiten de projectregio:

• Regio: Sommige hulpprogrammatypen zijn niet beschikbaar in elke regio die ondersteuning biedt voor de agentservice. Een regio die het werkseteindpunt ondersteunt, ondersteunt bijvoorbeeld mogelijk niet alle ingebouwde hulpprogrammatypen.

Controleer voordat u een werkset implementeert of uw doelregio ondersteuning biedt voor de hulpprogrammatypen die u wilt gebruiken. Zie Hulpprogramma-ondersteuning per regio en model voor de volledige compatibiliteitstabellen.

Verwante inhoud

• Agents verbinden met Model Context Protocol-servers
• Beschikbare hulpprogramma's en voorbeeldprompts voor Foundry MCP Server
• MCP-serververificatie toevoegen
• Webzoekprogramma
• Azure AI Zoeken-tool
• Overzicht van beveiligingsmaatregelen
• Vaardigheden beheren
• Een gehoste agent implementeren
• Een verbinding met uw project toevoegen
• Netwerkisolatie configureren voor Microsoft Foundry