Microsoft Foundry-Modellanbieter

Microsoft Agent Framework unterstützt direkte Modelleinleitungen von Microsoft Foundry-Projektendpunkten, während Ihre Anwendung die Agentdefinition, Tools und Orchestrierung besitzt.

Informationen zu vom Dienst verwalteten Eingabeaufforderungen und gehosteten Agents finden Sie unter Microsoft Foundry Agent Service.

Getting Started

Fügen Sie dem Projekt die erforderlichen NuGet-Pakete hinzu.

dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.Foundry --prerelease

Zwei Integrationsmuster

Die Microsoft Foundry-Integration macht zwei verschiedene Verwendungsmuster verfügbar:

Pattern Herstellungstyp Description Verwenden Sie, wenn
Antwort-Agent ChatClientAgent Ihre App stellt programmgesteuert ein Modell, Anweisungen und Tools zur Laufzeit bereit, AIProjectClient.AsAIAgent(...). Es wird keine serverseitige Agentressource erstellt. Sie besitzen die Agentdefinition und möchten eine einfache, flexible Einrichtung. Dies ist das Muster, das in den meisten Beispielen verwendet wird.
Foundry Agent (Eingabeaufforderung oder gehostet) FoundryAgent Serververwaltet – Eingabeaufforderungs-Agents sind benannte und versionsbezogene Definitionen; Gehostete Agents werden bereitgestellte Anwendungen, die über einen agentspezifischen Endpunkt erreicht werden. Foundry besitzt die Agentdefinition oder die gehostete Laufzeit. Siehe Microsoft Foundry Agent Service.

Antwort-Agent (direkte Ableitung)

Verwenden Sie AsAIAgent auf AIProjectClient direkt mit einem Modell und Anweisungen. Dies ist der empfohlene Ausgangspunkt für die meisten Szenarien.

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

AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
        .AsAIAgent(
            model: "gpt-4o-mini",
            name: "Joker",
            instructions: "You are good at telling jokes.");

Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));

Warning

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

Dieser Pfad ist codezentriert und erstellt keine serververwaltete Agent-Ressource.

Verwendung des Agenten

Der Antwort-Agent ist ein Standard AIAgent und unterstützt Sitzungen, Tools, Middleware und Streaming.

AgentSession session = await agent.CreateSessionAsync();
Console.WriteLine(await agent.RunAsync("Tell me a joke.", session));
Console.WriteLine(await agent.RunAsync("Now make it funnier.", session));

Weitere Informationen zum Ausführen und Interagieren mit Agenten finden Sie in den Agenten-Einführungstutorials.

Tools

Foundry Responses Agents, die über AIProjectClient.AsAIAgent(...) die Standardmäßige Agent Framework-Tooloberfläche erstellt wurden. In der Tools-Übersicht finden Sie die vollständige Featurematrix.

Werkzeug Hinweise
Funktionswerkzeuge Unterstützt.
Toolgenehmigung Unterstützt. Bereitgestellt vom Chatclient des Frameworks zum Funktionsaufruf.
Codedolmetscher Unterstützt.
Dateisuche Unterstützt.
Gehostete MCP-Tools Unterstützt.
Lokale MCP-Tools Unterstützt.
Microsoft Foundry Toolbox Unterstützt.

Gießerei in Python

In Python leben jetzt alle Foundry-spezifischen Clients unter agent_framework.foundry.

  • agent-framework-foundry stellt die Cloud Foundry Connectors bereit: FoundryChatClient, FoundryAgent, , FoundryEmbeddingClientund FoundryMemoryProvider.
  • agent-framework-foundry-local ermöglicht die lokale FoundryLocalClient-Ausführung des Modells.

Important

Diese Seite behandelt Microsoft Foundry-Projekt- und Modellendpunkte. Informationen zum Foundry Agent Service finden Sie unter Microsoft Foundry Agent Service. Wenn Sie über einen eigenständigen Azure OpenAI-Ressourcenendpunkt verfügen (https://<your-resource>.openai.azure.com), verwenden Sie die Python-Anleitungen auf der OpenAI-Anbieterseite. Wenn Sie unterstützte Modelle lokal ausführen möchten, lesen Sie die Seite "Foundry Local-Provider".

Foundry-Chat- und Agentenmuster in Python

Szenario Python-Form Verwenden Sie, wenn
Einfache Ableitung mit dem Endpunkt "Foundry Responses" Agent(client=FoundryChatClient(...)) Ihre App besitzt die Definition des Agenten, die Werkzeuge und die Konversationsschleife, und Sie möchten ein Modell in einem Foundry-Projekt bereitstellen.
Vom Dienst verwaltete Agents im Foundry Agent Service FoundryAgent(...) Sie möchten eine Verbindung mit einem PromptAgent oder HostedAgent herstellen, der im Foundry-Portal oder über die Dienst-APIs erstellt und konfiguriert wird.

Installation

pip install agent-framework-foundry

Das gleiche agent-framework-foundry Paket umfasst FoundryEmbeddingClient auch für Foundry Models-Endpunkt-Einbettungen.

Configuration

FoundryChatClient

FOUNDRY_PROJECT_ENDPOINT="https://<your-project>.services.ai.azure.com"
FOUNDRY_MODEL="gpt-4o-mini"

FoundryEmbeddingClient

FOUNDRY_MODELS_ENDPOINT="https://<apim-instance>.azure-api.net/<foundry-instance>/models"
FOUNDRY_MODELS_API_KEY="<api-key>"
FOUNDRY_EMBEDDING_MODEL="text-embedding-3-small"
FOUNDRY_IMAGE_EMBEDDING_MODEL="Cohere-embed-v3-english"  # optional

FoundryChatClient verwendet den Projektendpunkt. FoundryEmbeddingClient verwendet den Endpunkt separater Modelle.

Wählen Sie den richtigen Python Client aus.

Szenario Bevorzugter Client Hinweise
Azure OpenAI-Ressource OpenAIChatCompletionClient / OpenAIChatClient Verwenden Sie die OpenAI-Anbieterseite.
Microsoft Foundry-Projekt-Ableitung Agent(client=FoundryChatClient(...)) Verwendet den Endpunkt "Foundry Responses".
Vom Microsoft Foundry-Dienst verwalteter Agent FoundryAgent Empfohlen für Prompt Agents und HostedAgents.
Microsoft Foundry Models-Endpunkteinbettungen FoundryEmbeddingClient Verwendet FOUNDRY_MODELS_ENDPOINT plus FOUNDRY_EMBEDDING_MODEL / FOUNDRY_IMAGE_EMBEDDING_MODEL.
Foundry Local Runtime Agent(client=FoundryLocalClient(...)) Siehe Foundry Local.

Erstellen eines Agents mit FoundryChatClient

FoundryChatClient stellt eine Verbindung mit einem bereitgestellten Modell in einem Foundry-Projekt her und verwendet den Endpunkt "Antworten". Verbinden Sie Ihre App mit einem Standard Agent, wenn sie Anweisungen, Tools und Sitzungssteuerung besitzen soll.

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

agent = Agent(
    client=FoundryChatClient(
        project_endpoint="https://your-project.services.ai.azure.com",
        model="gpt-4o-mini",
        credential=AzureCliCredential(),
    ),
    name="FoundryWeatherAgent",
    instructions="You are a helpful assistant.",
)

FoundryChatClient ist der Foundry-first Python-Pfad für direkte Inferenzen und unterstützt Tools, strukturierte Ausgaben und Streaming.

Tools

FoundryChatClient stellt für jedes gehostete Foundry-Tool statische Factory-Methoden bereit. Die Factory-Methoden geben SDK-Toolobjekte zurück, die Sie an tools= auf Agent oder direkt an client.get_response(..., tools=[...]) übergeben. Informationen zu Tools für vom Dienst verwaltete Agent finden Sie unter Microsoft Foundry Agent Service.

Die Factory-Methoden sind Klassenmethoden, daher benötigen Sie keine Instanz, um ein Werkzeug zu erstellen:

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

agent = Agent(
    client=FoundryChatClient(credential=AzureCliCredential()),
    instructions="You can search the web and run code.",
    tools=[
        FoundryChatClient.get_web_search_tool(),
        FoundryChatClient.get_code_interpreter_tool(),
    ],
)

Toolunterstützung

In der folgenden Tabelle sind alle Tools aufgeführt, die das Python FoundryChatClient heute verfügbar macht.

Werkzeug Werk ein FoundryChatClient Status Detail
Funktionswerkzeuge n/v — übergeben Sie ein beliebiges aufrufbares Python-Objekt oder @ai_function GA Lokal in Ihrem Python Prozess aufgerufen.
Toolgenehmigung n/a — umschließt vorhandene Tools GA Funktioniert mit gehosteten MCP- und Funktionstools.
Codedolmetscher get_code_interpreter_tool GA Codeausführung in einer Sandbox in Foundry.
Dateisuche get_file_search_tool GA Durchsuchen sie hochgeladene Dateien über Vektorspeicher von Foundry.
Websuche get_web_search_tool GA Bing-gestütztes Grounding im Web, verwaltet von Microsoft. Nur Azure OpenAI-Modelle.
Bilderzeugung get_image_generation_tool GA In Foundry gehostete Bildgenerierung.
Gehosteter MCP get_mcp_tool GA Remote-MCP-Server, der von Foundry aufgerufen wird.
Lokale MCP n/a — verwenden MCPStreamableHTTPTool / MCPStdioTool GA Wird in Ihrem Prozess ausgeführt; funktioniert mit jedem Client.
Microsoft Foundry Toolbox MCPStreamableHTTPTool oder FoundryToolbox Beta Verbraucht über MCP von FoundryChatClient; angefügt serverseitig auf FoundryAgent.
Bing Grounding get_bing_grounding_tool Experimental Eigene Grounding-Ressource mit Bing Search verwenden.
Benutzerdefinierte Bing-Suche get_bing_custom_search_tool Preview Bing Grounding auf eine kuratierte Liste von Domänen beschränkt.
Azure KI-Suche get_azure_ai_search_tool Experimental Suchen Sie einen Azure KI-Suche Index über eine Foundry-Verbindung.
SharePoint get_sharepoint_tool Preview Grundantworten in SharePoint Inhalten.
Microsoft Fabric get_fabric_tool Preview Einen Fabric-Daten-Agenten abfragen.
Speichersuche get_memory_search_tool Preview Durchsuchen Sie einen von Foundry verwalteten Speicher.
Computernutzung get_computer_use_tool Preview Lassen Sie den Agent eine Desktop- oder Browserumgebung steuern.
Browserautomatisierung get_browser_automation_tool Preview Steuern Sie einen Browser über eine Azure Playwright-Verbindung.
Agent–zu–Agent (A2A) get_a2a_tool Preview Rufen Sie einen anderen A2A-Agent als Tool auf.

Note

Experimentelle Fabriken kapseln GA Foundry SDK-Typen, aber die Wrapper selbst können sich vor GA noch ändern. Preview-Factorys kapseln Foundry SDK-Typen, deren zugrunde liegende Funktionalität sich noch in der Vorschauphase befindet und daher geändert oder entfernt werden kann. Beide geben bei ihrer ersten Verwendung in einem Prozess ein ExperimentalWarning aus.

Websuchvarianten

Foundry bietet drei Bing-gestützte Grounding-Optionen. Wählen Sie das Szenario aus, das Ihrem Szenario entspricht:

  • get_web_search_tool (GA) – standardmäßig ohne Einrichtung; von Microsoft verwaltete Bing-Ressource. Nur Azure OpenAI-Modelle. Beschränkt auf user_location und search_context_size.
  • get_bing_grounding_tool (experimentell) – mit Ihrer eigenen Azure-Bing-Suche-Ressource für Grounding. Unterstützt count, freshness, market, set_lang und Modelle, die nicht zu OpenAI Foundry gehören.
  • get_bing_custom_search_tool (Vorschau) – Bringen Sie Ihre eigene benutzerdefinierte Bing-Suchinstanz mit, um das Grounding auf eine kuratierte Gruppe von Domänen einzuschränken.

Alle drei senden Suchdaten außerhalb der Azure-Compliance-Grenze. Eine vollständige Gegenüberstellung finden Sie in der Übersicht zur Web-Grounding.

client = FoundryChatClient(credential=AzureCliCredential())

# Default (GA): minimal configuration
web_search = client.get_web_search_tool(
    user_location={"city": "Amsterdam", "country": "NL"},
    search_context_size="medium",
)

Bildgenerierung

get_image_generation_tool konfiguriert das Tool für die gehostete Bildgenerierung von Foundry. Das Modell erzeugt Bildinhalte in der Antwort – es gibt keine zusätzlichen Dateien, die verwaltet werden müssen.

image_gen = FoundryChatClient.get_image_generation_tool(
    model="gpt-image-1",
    size="1024x1024",
    output_format="png",
    quality="high",
)

Bing-Erdung

get_bing_grounding_tool ist ein Wrapper für das Bing Search Foundry-Tool Grounding. Sie erstellen die Grounding with Bing Search-Ressource selbst und fügen diese als Foundry-Projektverbindung hinzu und übergeben dann die Verbindungs-ID.

bing = FoundryChatClient.get_bing_grounding_tool(
    connection_id="/subscriptions/.../connections/my-bing",
    market="en-US",
    freshness="Day",
    count=10,
)

get_bing_custom_search_tool beschränkt das Grounding auf die Allowlist, die in einer Bing Custom Search-Ressource definiert ist.

bing_custom = FoundryChatClient.get_bing_custom_search_tool(
    connection_id="/subscriptions/.../connections/my-bing-custom",
    instance_name="docs-only",
    market="en-US",
)

mit get_azure_ai_search_tool kann der Agent einen Azure KI-Suche Index über eine Foundry-Projektverbindung abfragen.

ai_search = FoundryChatClient.get_azure_ai_search_tool(
    index_connection_id="/subscriptions/.../connections/my-search",
    index_name="product-docs",
    query_type="vector_semantic_hybrid",
    top_k=5,
)

SharePoint

get_sharepoint_tool basiert Antworten auf SharePoint-Inhalten, die über eine Foundry-SharePoint-Verbindung erreichbar sind.

sharepoint = FoundryChatClient.get_sharepoint_tool(
    connection_id="/subscriptions/.../connections/my-sharepoint",
)

Microsoft Fabric

get_fabric_tool verbindet den Agent mit einem Microsoft Fabric Daten-Agent über eine Foundry-Verbindung, damit der Agent Fragen zu Ihren Fabric Daten beantworten kann.

fabric = FoundryChatClient.get_fabric_tool(
    connection_id="/subscriptions/.../connections/my-fabric",
)

get_memory_search_tool ermöglicht dem Agenten, einen von Foundry verwalteten Speicher zu durchsuchen, der optional auf einen Benutzer oder Mandanten beschränkt ist.

memory = FoundryChatClient.get_memory_search_tool(
    memory_store_name="user-preferences",
    scope="{{$userId}}",
)

Computerverwendung

get_computer_use_tool konfiguriert die Vorschaufunktion „Computernutzung“ – das Modell kann eine Desktop- oder Browserumgebung steuern, indem es Mauszeiger- und Tastaturaktionen ausführt.

computer = FoundryChatClient.get_computer_use_tool(
    environment="browser",
    display_width=1280,
    display_height=800,
)

Browserautomatisierung

get_browser_automation_tool bindet den Agent über eine Foundry-Verbindung an eine Azure Playwright Testing-Ressource an. Der Agent kann einen echten Browser mithilfe von Playwright steuern.

browser = FoundryChatClient.get_browser_automation_tool(
    connection_id="/subscriptions/.../connections/my-playwright",
)

Agent-zu-Agent (A2A)

get_a2a_tool stellt einen A2A-Remote-Agenten als Tool zur Verfügung, damit ein Foundry-Agent ihn aufrufen kann. Geben Sie entweder eine base_url (und optional agent_card_path) oder eine project_connection_id für eine gespeicherte A2A-Verbindung an.

a2a = FoundryChatClient.get_a2a_tool(
    base_url="https://remote-agent.example.com",
    agent_card_path="/.well-known/agent-card.json",
)

Allgemeine A2A-Ermittlungs-, Sitzungs- und Streaminganleitungen finden Sie im A2A-Agentdienst.

Erstellen von Einbettungen mit FoundryEmbeddingClient

Verwenden Sie FoundryEmbeddingClient, wenn Sie Text- oder Bildeinbettungen von einem Foundry-Modelle-Endpunkt benötigen.

from agent_framework.foundry import FoundryEmbeddingClient

async with FoundryEmbeddingClient() as client:
    result = await client.get_embeddings(["hello from Agent Framework"])
    print(result[0].dimensions)

Verwendung des Agenten

FoundryChatClientintegriert in die standardmäßige Python Agent Erfahrung, einschließlich Toolanrufe, Sitzungen und Streamingantworten. Verwenden Sie für lokale Laufzeiten die separate Seite des lokalen Anbieters "Foundry Local".

Benannte versionsierte Bündel gehosteter Toolkonfigurationen finden Sie unter Microsoft Foundry Toolbox.

Gießerei in Go

Das Go SDK bietet Microsoft Foundry-Agenten über github.com/microsoft/agent-framework-go/provider/foundryprovider.

In den Foundry Go-Beispielen finden Sie direkte Rückschlüsse, Funktionstools, gehostete Tools, MCP- und Server-Agent-Beispiele.

Das Paket unterstützt zwei Agentziele:

Ziel Form wechseln Verwenden Sie, wenn
Projektgestützte Modellbereitstellung foundryprovider.ModelDeployment("gpt-4o-mini") Ihre App steuert Anweisungen, Werkzeuge und den Gesprächsverlauf.
Vorhandener serverseitiger Foundry-Agent foundryprovider.ServerAgent("my-agent") Die Agentdefinition ist bereits in Foundry konfiguriert.

Configuration

Legen Sie ihren Foundry-Projektendpunkt und die Modellbereitstellung fest:

FOUNDRY_PROJECT_ENDPOINT="https://<your-project>.services.ai.azure.com/api/projects/<project-id>"
FOUNDRY_MODEL="gpt-4o-mini"

Projektgestützter Foundry-Agent

Verwenden Sie ModelDeployment, wenn Sie programmgesteuert einen Agent-Framework-Agenten erstellen und Anweisungen, Tools, Middleware und Kontextanbieter aus Ihrer Go-Anwendung übergeben möchten.

import (
    "context"
    "os"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)

endpoint := os.Getenv("FOUNDRY_PROJECT_ENDPOINT")
model := os.Getenv("FOUNDRY_MODEL")

token, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    panic(err)
}

a := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You are good at telling jokes.",
        Config: agent.Config{
            Name: "Joker",
        },
    },
)

resp, err := a.RunText(context.Background(), "Tell me a joke about a pirate.").Collect()

Vorhandener serverseitiger Foundry-Agent

Verwenden Sie ServerAgent, wenn Sie einen Agenten aufrufen möchten, der bereits in Foundry konfiguriert ist. Der serverseitige Agent verfügt über eigene Anweisungen und Tools, daher wird AgentConfig.Instructions für dieses Ziel ignoriert.

a := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ServerAgent("my-agent"),
    foundryprovider.AgentConfig{
        Config: agent.Config{
            Name: "my-agent",
        },
    },
)

resp, err := a.RunText(ctx, "Summarize the current project status.").Collect()

Tools

Von Projekten unterstützte Foundry-Agents unterstützen die standardmäßige Toolschnittstelle des Go Agent Frameworks für lokale Tools und die Deklarationen unterstützter gehosteter Tools.

Werkzeug Status Hinweise
Funktionswerkzeuge Unterstützt Funktionen werden im Go-Prozess ausgeführt.
Toolgenehmigung Unterstützt Arbeitet mit lokalen Funktions-Tools über die automatische Tool-Aufrufschleife.
Codedolmetscher Unterstützt Verwenden Sie &hostedtool.CodeInterpreter{}.
Websuche Unterstützt Verwenden Sie &hostedtool.WebSearch{}.
Lokale MCP-Tools Unterstützt Verwenden Sie tool/mcptool, um eine Verbindung zu einem MCP-Server herzustellen und dessen Tools lokal bereitzustellen.
Gehostete MCP-Tools Derzeit nicht dokumentiert für Go Foundry Verwenden Sie lokale MCP-Tools, wenn Sie MCP-Server mit Go Foundry-Agents benötigen.
Microsoft Foundry Toolbox Derzeit nicht über ein Go-Hilfsprogramm verfügbar gemacht.

Fügen Sie bei lokalen Funktionstools Werte über tool.Tool hinzu:

a := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You are a helpful assistant.",
        Config: agent.Config{
            Tools: []tool.Tool{weatherTool},
        },
    },
)

Übergeben Sie für die Ausführung von gehosteten Code die Deklaration des gehosteten Tools:

a := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You solve problems with code.",
        Config: agent.Config{
            Tools: []tool.Tool{&hostedtool.CodeInterpreter{}},
        },
    },
)

Client-Header und bereitgestelltes Modell

Foundry akzeptiert x-client-* Kopfzeilen pro Ausführung. Fügen Sie sie mit foundryprovider.WithClientHeader oder foundryprovider.WithClientHeaders:

resp, err := a.RunText(
    ctx,
    "Hello!",
    foundryprovider.WithClientHeader("x-client-scenario", "docs"),
).Collect()

Wenn Foundry den Response-Header x-ms-served-model zurückgibt, fügt der Go-Anbieter ihn den zusätzlichen Eigenschaften von response/update als ServedModel hinzu.

if servedModel, ok := resp.AdditionalProperties["ServedModel"].(string); ok {
    fmt.Println(servedModel)
}

Gießereispeicheranbieter

Verwenden Sie foundryprovider.NewMemoryProvider, wenn ein Agent des Agent Frameworks bei jeder Ausführung Daten aus einem Foundry-verwalteten Speicher abrufen und diesen aktualisieren soll.

import (
    "log/slog"

    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)

memoryProvider := foundryprovider.NewMemoryProvider(
    endpoint,
    tokenCredential,
    "memory-store-sample",
    func(*agent.Session) string { return "user-123" },
    foundryprovider.MemoryProviderConfig{
        Logger: slog.Default(),
    },
)

a := foundryprovider.NewAgent(
    endpoint,
    tokenCredential,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "Use known memories about the user when responding.",
        Config: agent.Config{
            Name:             "FoundryMemoryAgent",
            ContextProviders: []agent.ContextProvider{memoryProvider},
        },
    },
)

Der Endpunkt muss ein projektbezogener Microsoft Foundry-Endpunkt sein, und der Speicherspeicher muss bereits in diesem Projekt vorhanden sein. Der Scope-Callback sollte einen stabilen Partitionsschlüssel für den Benutzer, den Mandanten oder die Unterhaltung zurückgeben.

Tip

Siehe das Foundry memory Go-Beispiel für ein vollständig ausführbares Beispiel.

Aktuelle Go-Lücken

Die Go-Unterstützung enthält derzeit keine gehosteten Bereitstellungs-/Lebenszyklus-/Administrator-APIs, Einbettungsclients oder go-spezifische Hilfsprogramme für Microsoft Foundry Toolbox. Verwenden Sie das Foundry-Portal oder Dienst-SDKs für diese Vorgänge.

Nächste Schritte

Foundry Local

  • Last updated on