Microsoft Foundry Toolbox

Een Microsoft Foundry Toolbox is een benoemde, versiegebonden bundel van gehoste hulpprogrammaconfiguraties, zoals code-interpreter, bestandszoekopdrachten, het genereren van installatiekopieën, MCP en zoeken op internet. Met werksets kunt u de configuratie van hulpprogramma's eenmaal beheren in Foundry en deze opnieuw gebruiken tussen agents.

Agent Framework omvat het verbruik van werksets. Werksetversies maken en bijwerken via de Foundry-portal of de azure-ai-projects SDK.

Important

FoundryToolbox wordt geleverd door het bètapakket agent-framework-foundry-hosting en kan worden gewijzigd vóór stabiele release.

Koppel de Werkset aan de agentdefinitie in Foundry voor een door de service beheerde FoundryAgentservice. Richtlijnen .NET voor het gebruik van werksets aan de clientzijde worden momenteel niet gedocumenteerd.

De pakketten installeren

pip install agent-framework-foundry-hosting agent-framework-foundry --pre

FoundryToolbox wordt geïmporteerd uit agent_framework.foundry en geleverd door agent-framework-foundry-hosting.

De werkset configureren

Stel een expliciet MCP-eindpunt voor de werkset in:

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

U kunt FoundryToolbox ook het eindpunt maken:

FOUNDRY_PROJECT_ENDPOINT="https://<account>.services.ai.azure.com/api/projects/<project>"
TOOLBOX_NAME="<toolbox-name>"

De voorbeelden van gehoste agents worden ook gebruikt AZURE_AI_MODEL_DEPLOYMENT_NAME voor FoundryChatClient.

Gebruiken FoundryToolbox met een gehoste agent

FoundryToolboxlost het eindpunt op, verifieert elke MCP-aanvraag met de opgegeven Azure-referentie, stuurt de aanroep-id van Foundry per aanvraag door en neemt deel aan de levenscyclus van de verbinding van de agent.

import asyncio
import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient, FoundryToolbox, ResponsesHostServer
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()


async def main():
    credential = DefaultAzureCredential()

    # FoundryToolbox resolves the toolbox endpoint from the environment
    # (TOOLBOX_ENDPOINT, or FOUNDRY_PROJECT_ENDPOINT + TOOLBOX_NAME), authenticates
    # every request with the credential, and transparently forwards the platform
    # per-request call-id to the toolbox. The hosting server enters the agent, which
    # connects the toolbox on first use and closes it at shutdown.
    toolbox = FoundryToolbox(credential)

    # Create the chat client
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        credential=credential,
    )

    agent = Agent(
        client=client,
        instructions="You are a friendly assistant. Keep your answers brief.",
        tools=toolbox,
        # History will be managed by the hosting infrastructure, thus there
        # is no need to store history by the service. Learn more at:
        # https://developers.openai.com/api/reference/resources/responses/methods/create
        default_options={"store": False},
    )

    server = ResponsesHostServer(agent)
    await server.run_async()

Werksetvaardigheden beschikbaar maken

Een werkset kan agentvaardigheden beschikbaar maken via MCP. Stel load_tools=False in wanneer alleen vaardigheden model zichtbaar moeten zijn en voeg vervolgens de Werkset toe als een hulpprogramma, zodat de MCP-sessie verbinding maakt en als contextprovider wordt gebruikt as_skills_provider() .

import asyncio
import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient, FoundryToolbox, ResponsesHostServer
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()


async def main() -> None:
    credential = DefaultAzureCredential()

    # FoundryToolbox resolves the toolbox endpoint from the environment
    # (TOOLBOX_ENDPOINT, or FOUNDRY_PROJECT_ENDPOINT + TOOLBOX_NAME), authenticates
    # every request with the credential, and forwards the platform per-request
    # call-id. ``load_tools=False`` keeps the toolbox's tools hidden so only its
    # Agent Skills (SEP-2640) are surfaced; passing it via ``tools=`` connects the
    # MCP session that ``as_skills_provider()`` reads from.
    toolbox = FoundryToolbox(credential, load_tools=False)

    # as_skills_provider() discovers skills from skill://index.json on the toolbox
    # MCP session and exposes them as an agent context provider; SKILL.md bodies are
    # fetched on demand via resources/read. disable_load_skill_approval=True registers
    # the load_skill tool with approval_mode="never_require" so this unattended agent
    # can load skills without an approval round-trip -- the Responses host runs the
    # agent without an AgentSession, which the default approval flow requires.
    skills_provider = toolbox.as_skills_provider(disable_load_skill_approval=True)

    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        credential=credential,
    )

    agent = Agent(
        client=client,
        name=os.environ.get("AGENT_NAME", "hosted-toolbox-mcp-skills"),
        instructions="You are a helpful assistant.",
        tools=toolbox,
        context_providers=[skills_provider],
        # History will be managed by the hosting infrastructure, thus there
        # is no need to store history by the service. Learn more at:
        # https://developers.openai.com/api/reference/resources/responses/methods/create
        default_options={"store": False},
    )

    server = ResponsesHostServer(agent)
    await server.run_async()

Goedkeuring blijft standaard ingeschakeld voor vaardigheidsbewerkingen. Schakel afzonderlijke goedkeuringen alleen uit voor vertrouwde, onbeheerde scenario's.

Een werkset gebruiken met FoundryAgent

Koppel de werkset aan de definitie prompt of hosted agent in Foundry. FoundryAgent maakt gebruik van die opgeslagen hulpprogrammaconfiguratie; als u een Werkset aan de clientzijde doorgeeft, wordt deze niet toegevoegd aan de beheerde agent.

Verbinding maken via onbewerkte MCP

Rechtstreeks gebruiken MCPStreamableHTTPTool wanneer de toepassing de hosting-wrapper niet gebruikt FoundryToolbox . Geef het werkseteindpunt en een Entra ID bearer-token viaheader_provider.

import asyncio
import os
from collections.abc import Callable
from typing import Any, cast

from agent_framework import Agent, MCPStreamableHTTPTool
from agent_framework.foundry import FoundryChatClient
from azure.core.credentials import TokenCredential
from azure.identity import AzureCliCredential, DefaultAzureCredential, get_bearer_token_provider
from dotenv import load_dotenv
def make_toolbox_header_provider(credential: TokenCredential) -> Callable[[dict[str, Any]], dict[str, str]]:
    """Build a header_provider that injects a fresh Azure AI bearer token on every MCP request."""
    get_token = get_bearer_token_provider(credential, "https://ai.azure.com/.default")

    def provide(_kwargs: dict[str, Any]) -> dict[str, str]:
        return {
            "Authorization": f"Bearer {get_token()}",
        }

    return provide


async def main() -> None:
    credential = DefaultAzureCredential()

    toolbox_tool = MCPStreamableHTTPTool(
        name="foundry_toolbox",
        description="Tools exposed by the configured Foundry toolbox",
        url=os.environ["FOUNDRY_TOOLBOX_ENDPOINT"],
        header_provider=make_toolbox_header_provider(credential),
        load_prompts=False,
    )

    async with Agent(
        client=FoundryChatClient(
            project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
            model=os.environ["FOUNDRY_MODEL"],
            credential=credential,
        ),
        instructions="You are a helpful assistant. Use the available toolbox tools to answer the user.",
        tools=toolbox_tool,
    ) as agent:
        query = "What tools do you have access to?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"Assistant: {result}")

In het voorbeeld op lager niveau wordt gebruikgemaakt van FOUNDRY_TOOLBOX_ENDPOINT. Het voorbeeld van werksetvaardigheden gebruikt FOUNDRY_TOOLBOX_MCP_SERVER_URL; deze namen behoren tot die voorbeelden en staan los van de FoundryToolbox klassen TOOLBOX_ENDPOINT en TOOLBOX_NAME instellingen.

Limitations

• MCP-hulpprogramma's in een werkset maken gebruik van verificatie aan de serverzijde via een Foundry project_connection_id. De Agent Framework-client bevat het upstream MCP Bearer-token niet.
• Voor het gebruik van een Werkset als EEN MCP-server is Entra ID verificatie aan de clientzijde vereist voor het werkseteindpunt.
• Antwoorden voor toestemmingsstromen, zoals CONSENT_REQUIRED worden verwerkt terwijl de agent wordt uitgevoerd, niet terwijl de werksetverbinding wordt gemaakt.

Samples

Sample	Description
foundry_toolbox/main.py	FoundryToolbox met een gehoste antwoordenagent
foundry_toolbox_mcp_skills/main.py	Door werkset ondersteunde agentvaardigheden
foundry_chat_client_with_toolbox.py	McP-verbruik van werkset met MCPStreamableHTTPTool
foundry_chat_client_with_toolbox_skills.py	Op toolbox gebaseerde vaardighedenconfiguratie
invoke_foundry_toolbox_mcp	MCP-verbruik aan de werkstroomzijde

Go maakt momenteel geen Foundry Toolbox-helper beschikbaar. Configureer werksets via Foundry en gebruik ondersteunde declaraties van lokale of gehoste hulpprogramma's voor Go-agents.

Verwante informatie

• Microsoft Foundry-modelprovider
• Microsoft Foundry Agent Service
• Lokale MCP-hulpprogramma's