Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Una risorsa Foundry consente l'accesso unificato a modelli, agenti e strumenti. Questo articolo illustra l'SDK e l'endpoint da usare per lo scenario.
Foundry SDK è un SDK thin client che espone tutte le API del progetto Foundry tramite un singolo endpoint di progetto. Gli SDK di livello superiore si basano su di esso, ad esempio il pacchetto di Agent Framework foundry dipende da Foundry SDK per accedere ai modelli, agli strumenti e alla configurazione del progetto foundry.
| SDK | A cosa serve | Endpoint |
|---|---|---|
| Foundry SDK | Thin-client SDK su tutte le API del progetto Foundry. Accesso ai modelli foundry e agli strumenti della piattaforma (ricerca di file, interprete del codice, ricerca Web, memoria, SharePoint, WorkIQ, Fabric IQ, MCP). | https://<resource-name>.services.ai.azure.com/api/projects/<project-name> |
| Framework agente | Orchestrazione multi-agente unificata per agenti ospitati e sistemi multi-agente, disponibili in C#/.NET e Python. Il foundry pacchetto dipende dall'SDK Foundry per l'accesso al progetto. |
API delle risposte nell'endpoint del progetto, tramite FoundryChatClient. |
| OpenAI SDK | Intera gamma di API OpenAI, inclusi gli embedding e i modelli Foundry venduti da Azure tramite Chat Completions. Migliore latenza e massima compatibilità OpenAI. | https://<resource-name>.openai.azure.com/openai/v1 |
| ANTHROPIC SDK | Modelli Anthropic Claude implementati in Foundry. | https://<resource-name>.services.ai.azure.com/anthropic |
| SDK degli strumenti di fonderia | Soluzioni predefinite (Visione, Riconoscimento vocale, Sicurezza del contenuto e altro ancora). | Endpoint specifici per lo strumento. |
Scegliere l'SDK:
- Usare Foundry SDK per la creazione di app con agenti, valutazioni o funzionalità specifiche di Foundry
- Usare Agent Framework per agenti ospitati o sistemi multi-agente nel codice usando l'API Risposte in C#/.NET o Python
- Usare OpenAI SDK quando è necessaria la massima compatibilità OpenAI o la latenza minima, durante la generazione di incorporamenti o quando si usano modelli venduti da Azure tramite completamento chat
- Usare Anthropic SDK quando si usano modelli Anthropic Claude distribuiti in Foundry
- Usare gli SDK degli strumenti Foundry quando si usano servizi di intelligenza artificiale specifici (Visione, Riconoscimento vocale, Lingua e così via)
Nota
Tipi di risorsa: Una risorsa Foundry fornisce tutti gli endpoint elencati in precedenza. Una risorsa OpenAI Azure fornisce solo l'endpoint /openai/v1.
Autenticazione: esempi usano Microsoft Entra ID (DefaultAzureCredential). Le chiavi API funzionano in /openai/v1. Passa la chiave come api_key anziché un provider di token.
Prerequisiti
-
Un account Azure con una sottoscrizione attiva. Se non ne hai uno, crea un account Azure gratuito, che include un abbonamento di prova gratuito.
Disporre del ruolo RBAC di Azure necessario per l'attività nell'ambito più limitato possibile:
Foundry User nel progetto Foundry per lo sviluppo quotidiano.
Importante
I ruoli di Controllo degli accessi in base al ruolo di Foundry sono stati recentemente rinominati. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager erano precedentemente denominati Azure AI User, Azure AI Owner, Azure AI Account Owner e Azure AI Project Manager. È possibile che i nomi precedenti vengano visualizzati in alcune posizioni durante l'esecuzione della ridenominazione. Gli ID ruolo e le autorizzazioni di base sono invariati dalla ridenominazione.
Foundry Project Manager nel progetto Foundry per gestire un progetto esistente e le sue connessioni.
Proprietario dell'account Foundry sulla risorsa Foundry per creare progetti o gestire risorse a livello dell'account. Assegna questo ruolo solo nel gruppo di risorse di destinazione quando devi creare una risorsa di Foundry.
Attiva temporaneamente l'assegnazione al gruppo di risorse tramite Microsoft Entra Privileged Identity Management (PIM), quindi disattivala dopo il provisioning. Gli sviluppatori e gli utenti del runtime nell’uso quotidiano non hanno bisogno di questa assegnazione di privilegi elevati.
Per informazioni dettagliate sulle autorizzazioni di ogni ruolo, vedere Controllo degli accessi in base al ruolo per Microsoft Foundry.
Installare i runtime del linguaggio necessari, gli strumenti globali e le estensioni di VS Code, come descritto in Preparare l'ambiente di sviluppo.
Verificare i prerequisiti
Prima di procedere, verificare che ogni controllo restituisca il risultato indicato:
Verificare che l'interfaccia della riga di comando di Azure utilizzi la sottoscrizione e il tenant desiderati:
az account show --query "{subscription:name, tenant:tenantId}" --output tableIl comando termina correttamente e visualizza la sottoscrizione e il tenant attesi.
Verificare che le credenziali locali possano richiedere un token di accesso Foundry senza visualizzare il token:
az account get-access-token --resource https://ai.azure.com --query expiresOn --output tsvIl comando viene chiuso correttamente e visualizza l'ora di scadenza del token. Se non riesce, eseguire
az loginusando un'identità che dispone del ruolo Foundry richiesto.Verifica di disporre del ruolo RBAC richiesto nel portale di Azure in risorsa Foundry>Controllo di accesso (IAM).
- Eseguire
python --version. Il comando viene chiuso correttamente e segnala Python 3.9 o versione successiva.
- Eseguire
node --version. Il comando viene chiuso correttamente e segnala Node.js 22 o versione successiva.
- Eseguire
dotnet --version. Il comando viene chiuso correttamente e segnala .NET 8 o versione successiva.
- Eseguire
java --version. Il comando viene chiuso correttamente e segnala Java 17 o versione successiva.
Verificare che l'endpoint del progetto abbia questo formato:
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>.Verifica che la distribuzione
gpt-5-minisia pronta:az cognitiveservices account deployment show \ --name <resource-name> \ --resource-group <resource-group> \ --deployment-name gpt-5-mini \ --query properties.provisioningState \ --output tsvIl comando restituisce
Succeeded. Usare il nome distribuito negli esempi di codice se la distribuzione ha un nome diverso.
Foundry SDK
Foundry SDK è un SDK thin client che consente di accedere a tutte le API del progetto Foundry tramite un singolo endpoint di progetto:
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>
È la base di altri SDK basati su Foundry. Ad esempio, il pacchetto di Agent Framework foundry accetta una dipendenza da Foundry SDK e lo usa per accedere alla funzionalità Foundry. Non è necessario collegare manualmente l'endpoint del progetto o il client compatibile con OpenAI quando si usa FoundryChatClient.
Nota
Se l'organizzazione usa un sottodominio personalizzato, sostituire <resource-name> con <your-custom-subdomain> nell'URL dell'endpoint.
Questo approccio semplifica la configurazione dell'applicazione. Anziché gestire più endpoint, è necessario configurare uno.
Installa l'SDK di Foundry
| Versione dell'SDK | Versione del portale | Stato | Pacchetto Python |
|---|---|---|---|
| 2.x | Fonderia (nuovo) | Stabile | azure-ai-projects>=2.0.0 |
| 1.x | Foundry (classico) | Stabile | azure-ai-projects==1.0.0 |
La libreria client Azure ai projects per Python è una libreria unificata che consente di usare più librerie client insieme connettendosi a un singolo endpoint di progetto.
Eseguire questo comando per installare i pacchetti per i progetti Foundry.
pip install "azure-ai-projects>=2.0.0"
| Versione dell'SDK | Versione del portale | Stato | pacchetto Java |
|---|---|---|---|
| 2.0.0 | Fonderia (nuovo) | Stabile | azure-ai-projectsazure-ai-agents |
| Versione dell'SDK | Versione del portale | Stato | Pacchetto JavaScript |
|---|---|---|---|
| 2.4.0 | Fonderia (nuovo) | Stabile | @azure/ai-projects |
| 1.0.1 | Fonderia classica | Stabile | @azure/ai-projects |
Usa Node.js 22 o versione successiva con @azure/ai-projects 2.4.0.
| Versione dell'SDK | Versione del portale | Stato | pacchetto .NET |
|---|---|---|---|
| 2.0.0 (GA) | Fonderia (nuovo) | Stabile | Azure.AI.ProjectsAzure.AI.Projects.AgentsAzure.AI.Extensions.OpenAI |
| 1.1.0 (GA) | Fonderia classica | Stabile | Azure.AI.Projects |
Importante
Non installare Azure.AI.Projects.OpenAI (anteprima) insieme a Azure.AI.Extensions.OpenAI (GA). Entrambi i pacchetti definiscono gli stessi tipi in spazi dei nomi diversi, causando errori di riferimento ambigui. Usare solo Azure.AI.Extensions.OpenAI per gli scenari dell'agente.
La libreria client Azure ai projects per Java è una libreria unificata che consente di usare più librerie client insieme connettendosi a un singolo endpoint di progetto.
Aggiungi queste dipendenze al tuo Maven pom.xml per i progetti Foundry.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-projects</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-agents</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.4</version>
</dependency>
La libreria client Azure AI Projects per JavaScript è una libreria unificata che consente di usare più librerie client insieme connettendosi a un singolo endpoint di progetto.
Eseguire questo comando per installare i pacchetti JavaScript per i progetti Foundry.
npm install @azure/ai-projects @azure/identity
La libreria client Azure AI Projects per .NET è una libreria unificata che consente di usare più biblioteche client connettendosi insieme a un singolo endpoint di progetto.
Eseguire questi comandi per aggiungere i pacchetti necessari al progetto di .NET.
dotnet add package Azure.AI.Projects
dotnet add package Azure.AI.Projects.Agents
dotnet add package Azure.AI.Extensions.OpenAI
dotnet add package Azure.Identity
Effettuare la prima chiamata di Foundry SDK
L'SDK espone due tipi di client perché Foundry e OpenAI hanno forme API diverse:
- Project client: usare per le operazioni native di Foundry in cui OpenAI non ha equivalenti. Esempi: elencare le connessioni, recuperare le proprietà del progetto, abilitare la traccia.
-
Client compatibile con OpenAI : usare per la funzionalità Foundry basata sui concetti di OpenAI. L'API Risposte, gli agenti, le valutazioni e l'ottimizzazione usano tutti modelli di richiesta/risposta in stile OpenAI. Questo client è destinato all'API Risposte nell'endpoint del progetto, che consente di accedere ai modelli Foundry venduti da Azure, altri modelli dal catalogo e dagli strumenti della piattaforma. Questi strumenti includono ricerca di file, interprete del codice, ricerca Web, memoria, SharePoint, WorkIQ, Fabric IQ e server MCP. L'endpoint del progetto gestisce questo traffico sulla
/openairoute.
La maggior parte delle app usa entrambi i client. Usare il client di progetto per l'installazione e la configurazione, quindi usare il client compatibile con OpenAI per l'esecuzione di agenti, valutazioni e modelli di chiamata.
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project_endpoint = (
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>"
)
project = AIProjectClient(
endpoint=project_endpoint,
credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()
response = openai.responses.create(
model="gpt-5-mini",
input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")
Response output: <model response>
Riferimento: classe AIProjectClient
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.AgentsServiceVersion;
import com.azure.ai.agents.ResponsesClient;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
ResponsesClient responsesClient = new AgentsClientBuilder()
.credential(new DefaultAzureCredentialBuilder().build())
.endpoint(projectEndpoint)
.serviceVersion(AgentsServiceVersion.getLatest())
.buildResponsesClient();
Response response = responsesClient.getResponseService().create(
ResponseCreateParams.builder()
.model("gpt-5-mini")
.input("What is the size of France in square miles?")
.build());
response.output().forEach(item -> item.message().ifPresent(message ->
message.content().forEach(content -> content.outputText().ifPresent(text ->
System.out.println("Response output: " + text.text())))));
Response output: <model response>
Riferimento: CreateResponse.java
import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
const projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
const project = new AIProjectClient(
projectEndpoint,
new DefaultAzureCredential(),
);
const openai = project.getOpenAIClient();
const response = await openai.responses.create({
model: "gpt-5-mini",
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Response output: <model response>
Riferimento: classe AIProjectClient
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using Azure.Identity;
string projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
AIProjectClient projectClient = new(
endpoint: new Uri(projectEndpoint),
tokenProvider: new DefaultAzureCredential());
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient
.GetProjectResponsesClientForModel("gpt-5-mini");
ResponseResult response = responseClient.CreateResponse(
"What is the size of France in square miles?");
Console.WriteLine($"Response output: {response.GetOutputText()}");
Response output: <model response>
Riferimento: classe AIProjectClient
Esplorare le funzionalità di Foundry SDK
- Access Foundry Models, tra cui Azure OpenAI
- Usare il servizio Foundry Agent
- Eseguire valutazioni batch
- Abilitare la traccia delle app
- Ottimizzare un modello
- Ottenere endpoint e chiavi per Foundry Tools, l'orchestrazione locale e altro ancora
Risoluzione dei problemi
Errori di autenticazione
Se viene visualizzato DefaultAzureCredential failed to retrieve a token:
Verifica che interfaccia della riga di comando di Azure sia autenticato
az account show az login # if not logged inVerificare l'assegnazione del ruolo RBAC:
Assicurati di disporre almeno del ruolo Foundry User nel progetto Foundry
Importante
I ruoli di Controllo degli accessi in base al ruolo di Foundry sono stati recentemente rinominati. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager erano precedentemente denominati Azure AI User, Azure AI Owner, Azure AI Account Owner e Azure AI Project Manager. È possibile che i nomi precedenti vengano visualizzati in alcune posizioni durante l'esecuzione della ridenominazione. Gli ID ruolo e le autorizzazioni di base sono invariati dalla ridenominazione.
Vedere Assegnare ruoli di Azure
Per l'identità gestita nell'ambiente di produzione:
- Verificare che all'identità gestita sia assegnato il ruolo appropriato
- Vedere Configurare le identità gestite
Errori di configurazione degli endpoint
Se viene visualizzato Connection refused o 404 Not Found:
- Verificare che i nomi delle risorse e dei progetti corrispondano alla distribuzione effettiva
-
Controllare il formato dell'URL dell'endpoint: deve essere
https://<resource-name>.services.ai.azure.com/api/projects/<project-name> -
Per i sottodomini personalizzati: sostituire
<resource-name>con il sottodominio personalizzato
Incompatibilità di versione dell'SDK
Se gli esempi di codice hanno esito negativo con AttributeError o ModuleNotFoundError:
Controllare la versione dell'SDK:
pip show azure-ai-projects # Python npm list @azure/ai-projects # JavaScript dotnet list package # .NETReinstallare con i flag di versione corretti: vedere i comandi di installazione nella sezione della lingua sopra
OpenAI SDK
Usa l’SDK OpenAI quando vuoi il set completo di funzionalità dell’API OpenAI, la latenza migliore e la massima compatibilità con i client OpenAI esistenti. Questo endpoint espone direttamente l'API Risposte in Azure OpenAI e fornisce l'accesso ai modelli e ai modelli OpenAI Azure venduti da Azure, inclusi incorporamenti, completamenti delle chat e generazione di immagini. Non fornisce l'accesso a funzionalità specifiche di Foundry, ad esempio agenti, valutazioni o strumenti di piattaforma esclusivi di Foundry. Per queste funzionalità, usare l'API Risposte nell'endpoint del progetto tramite Foundry SDK.
Suggerimento
Usare l'endpoint OpenAI SDK per generare incorporamenti. L'endpoint del progetto usato da Foundry SDK attualmente non instrada le richieste di incorporamento.
Il frammento di codice seguente illustra come usare direttamente l'endpoint Azure OpenAI /openai/v1.
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
openai_endpoint = "https://<resource-name>.openai.azure.com/openai/v1/"
openai = OpenAI(
base_url=openai_endpoint,
api_key=token_provider,
)
response = openai.responses.create(
model="gpt-5-mini",
input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")
Response output: <model response>
Riferimento: Azure Linguaggi di programmazione supportati da OpenAI
Il frammento di codice seguente illustra come usare direttamente l'endpoint Azure OpenAI /openai/v1.
import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String openAIEndpoint = "https://<resource-name>.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(openAIEndpoint)
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
new DefaultAzureCredentialBuilder().build(),
"https://ai.azure.com/.default")))
.build();
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("gpt-5-mini")
.input("What is the size of France in square miles?")
.build());
response.output().forEach(item -> item.message().ifPresent(message ->
message.content().forEach(content -> content.outputText().ifPresent(text ->
System.out.println("Response output: " + text.text())))));
Response output: <model response>
Riferimento: Azure Linguaggi di programmazione supportati da OpenAI
import {
DefaultAzureCredential,
getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";
const openAIEndpoint = "https://<resource-name>.openai.azure.com/openai/v1";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: openAIEndpoint, apiKey: tokenProvider });
const response = await openai.responses.create({
model: "gpt-5-mini",
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Response output: <model response>
Riferimento: Azure Linguaggi di programmazione supportati da OpenAI
Eseguire questo comando per aggiungere la libreria client OpenAI al progetto .NET.
dotnet add package OpenAI
Quando ha esito positivo, l'interfaccia della riga di comando di .NET conferma che è stato installato il OpenAI pacchetto.
Questo frammento di codice configura DefaultAzureCredential, compila OpenAIClientOptionse crea un ResponsesClient per l'endpoint OpenAI v1 di Azure.
using Azure.Identity;
using OpenAI;
using OpenAI.Responses;
using System.ClientModel.Primitives;
#pragma warning disable OPENAI001
const string openAIEndpoint =
"https://<resource-name>.openai.azure.com/openai/v1/";
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
OpenAIClient openAIClient = new(
authenticationPolicy: tokenPolicy,
options: new OpenAIClientOptions()
{
Endpoint = new(openAIEndpoint),
});
ResponsesClient responsesClient = openAIClient.GetResponsesClient();
CreateResponseOptions options = new()
{
Model = "gpt-5-mini",
InputItems =
{
ResponseItem.CreateUserMessageItem(
"What is the size of France in square miles?")
},
};
var response = responsesClient.CreateResponse(options);
Console.WriteLine($"Response output: {response.Value.GetOutputText()}");
#pragma warning restore OPENAI001
Response output: <model response>
Riferimento: Azure Linguaggi di programmazione supportati da OpenAI
Anthropic SDK
Usare Anthropic SDK per usare i modelli Anthropic Claude distribuiti in Foundry. I modelli Claude usano un endpoint /anthropic separato e l'Anthropic Messages API, non l'endpoint compatibile con OpenAI.
L'endpoint Anthropic aggiunge /anthropic all'URL della risorsa:
https://<resource-name>.services.ai.azure.com/anthropic
L'API Messaggi è disponibile all'indirizzo:
https://<resource-name>.services.ai.azure.com/anthropic/v1/messages
from anthropic import AnthropicFoundry
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = AnthropicFoundry(
azure_ad_token_provider=token_provider,
base_url="https://<resource-name>.services.ai.azure.com/anthropic",
)
message = client.messages.create(
model="claude-sonnet-4-6", # Replace with your deployment name
messages=[
{"role": "user", "content": "What are 3 things to visit in Seattle?"}
],
max_tokens=1048,
)
print(f"Response output: {message.content[0].text}")
Response output: <model response>
L'SDK di Anthropic non fornisce un client C# nativo. Usare l'API REST con HttpClient per chiamare i modelli Claude.
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Azure.Identity;
string endpoint =
"https://<resource-name>.services.ai.azure.com/anthropic/v1/messages";
var credential = new DefaultAzureCredential();
var token = await credential.GetTokenAsync(
new Azure.Core.TokenRequestContext(["https://ai.azure.com/.default"]));
using var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", token.Token);
httpClient.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");
var requestBody = new
{
model = "claude-sonnet-4-6",
messages = new[]
{
new { role = "user", content = "Name three Seattle attractions." }
},
max_tokens = 1048
};
var response = await httpClient.PostAsync(
endpoint,
new StringContent(
JsonSerializer.Serialize(requestBody), Encoding.UTF8,
"application/json"));
string result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
<JSON response body containing the model response>
import AnthropicFoundry from "@anthropic-ai/foundry-sdk";
import {
DefaultAzureCredential,
getBearerTokenProvider,
} from "@azure/identity";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default",
);
const client = new AnthropicFoundry({
azureADTokenProvider: tokenProvider,
baseURL: "https://<resource-name>.services.ai.azure.com/anthropic",
apiVersion: "2023-06-01",
});
const message = await client.messages.create({
model: "claude-sonnet-4-6", // Replace with your deployment name
messages: [
{ role: "user", content: "What are 3 things to visit in Seattle?" },
],
max_tokens: 1048,
});
console.log(`Response output: ${message.content[0].text}`);
Response output: <model response>
L'SDK di Anthropic non fornisce un client Java nativo. Usare l'API REST con HttpClient per chiamare i modelli Claude.
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.core.credential.TokenRequestContext;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String endpoint =
"https://<resource-name>.services.ai.azure.com/anthropic/v1/messages";
var credential = new DefaultAzureCredentialBuilder().build();
var token = credential.getToken(new TokenRequestContext()
.addScopes("https://ai.azure.com/.default")).block();
String requestBody = """
{"model": "claude-sonnet-4-6",
"messages": [{"role": "user",
"content": "What are 3 things to visit in Seattle?"}],
"max_tokens": 1048}
""";
HttpClient httpClient = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(endpoint))
.header("Authorization", "Bearer " + token.getToken())
.header("Content-Type", "application/json")
.header("anthropic-version", "2023-06-01")
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse<String> response = httpClient.send(
request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
<JSON response body containing the model response>
Per altre informazioni, vedi Usare i modelli Anthropic Claude in Microsoft Foundry.
Framework dell'agente
Microsoft Agent Framework è un SDK open source per C#/.NET e Python che fornisce un'orchestrazione multi-agente unificata e astrazioni coerenti per creare agenti e sistemi multi-agente. Si tratta del livello di orchestrazione consigliato per gli agenti ospitati in Foundry.
- Se in precedenza è stato usato AutoGen o Kernel semantico per l'orchestrazione multi-agente (coordinando più agenti per lavorare insieme sulle attività), considerare Agent Framework come livello di orchestrazione principale. Consente di evitare di combinare più SDK di orchestrazione che risolve attività di coordinamento simili, che possono aggiungere astrazioni e dipendenze in conflitto.
- Se si dispone già di un codice di orchestrazione esistente sostanziale, dipendere da funzionalità specifiche del prodotto o soddisfare requisiti di migrazione complessi, valutare tali requisiti prima di consolidare in Agent Framework.
Eseguire il codice come agente ospitato
La storia principale per gli agenti basati su codice in Foundry è Gli agenti ospitati. Scrivi il tuo agente con Agent Framework, creane un pacchetto come immagine container o file ZIP del codice sorgente e lascia che Foundry lo esegua con un endpoint gestito, scalabilità automatica su Micro VM isolate, un'identità agente Microsoft Entra dedicata, stato a livello di sessione e osservabilità end-to-end.
Gli agenti ospitati sono la soluzione consigliata quando si desidera un endpoint gestito da Foundry e raggiungibile in rete, che altre app o agenti possono chiamare. Vedi Distribuire il primo agente ospitato.
Crea agenti nel codice al di fuori di Foundry con l'API Responses
Se si ospita l'agente all'esterno di Foundry, nel proprio processo o infrastruttura, è anche possibile usare Agent Framework per chiamare direttamente l'API Risposte nell'endpoint del progetto . Agent Framework si connette tramite il FoundryChatClient provider, destinato a:
{project_endpoint}/openai/v1/responses
L'utilizzo dell'endpoint del progetto — anziché di un endpoint OpenAI a livello di risorsa — offre al tuo agente:
- Modelli Foundry dal catalogo (Azure OpenAI e modelli Foundry diretti) attraverso un'unica API.
- Strumenti della piattaforma oltre il set di strumenti OpenAI, tra cui la ricerca di file, l'interprete del codice, la memoria, la ricerca Web, i server MCP, SharePoint, WorkIQ e Fabric IQ.
- I dati relativi al progetto, l'autenticazione tramite lo strumento On-Behalf-Of (OBO), nonché la tracciabilità, i filtri dei contenuti e la configurazione delle identità del progetto.
Questo modello è aggiuntivo per gli agenti ospitati, non un'alternativa. Lo stesso codice di Agent Framework può chiamare l'API Risposte dal proprio processo e essere incluso in un pacchetto come agente ospitato in un secondo momento quando si vuole un endpoint gestito da Foundry. Vedere Avvio rapido: Creare agenti usando l'API Risposte.
Per un confronto completo tra i tipi di agente e le opzioni di hosting, vedi Che cos'è Microsoft Foundry Agent Service?.
SDK degli strumenti di Foundry
Gli strumenti Foundry (precedentemente Azure AI Services) sono soluzioni pronte all'uso con SDK dedicati. Utilizzare i seguenti endpoint per interagire con gli strumenti Foundry.
Quale endpoint è necessario usare?
Scegliere un endpoint in base alle esigenze:
Usare l'endpoint di servizi di intelligenza artificiale Azure per accedere a Visione artificiale, sicurezza del contenuto, intelligence sui documenti, lingua, traduzione e strumenti di ricerca token.
Endpoint di Foundry Tools: https://<your-resource-name>.cognitiveservices.azure.com/
Nota
Gli endpoint usano il nome della risorsa o un sottodominio personalizzato. Se l'organizzazione configura un sottodominio personalizzato, sostituire your-resource-name con your-custom-subdomain in tutti gli esempi di endpoint.
Se i carichi di lavoro usano funzionalità di Lingua di Azure AI in fase di ritiro, ad esempio analisi del sentiment, estrazione di frasi chiave, riepilogo, collegamento di entità, CLU o CQA, pianificare la migrazione verso alternative di Microsoft Foundry. Per un nuovo sviluppo, è consigliabile usare Foundry SDK o l'endpoint compatibile con OpenAI, come descritto in precedenza in questo articolo. Consultare Migrate da Language Studio a Microsoft Foundry.
Per gli strumenti Speech and Translation Foundry, usare gli endpoint nelle tabelle seguenti. Sostituire i segnaposto con le informazioni sulla risorsa.
Endpoint di Voce
| Strumento di fonderia | Endpoint |
|---|---|
| Riconoscimento vocale (standard) | https://<YOUR-RESOURCE-REGION>.stt.speech.microsoft.com |
| Sintesi vocale (Neurale) | https://<YOUR-RESOURCE-REGION>.tts.speech.microsoft.com |
| Voce personalizzata | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Endpoint di traduzione
| Strumento di fonderia | Endpoint |
|---|---|
| Traduzione di testo | https://api.cognitive.microsofttranslator.com/ |
| Traduzione documenti | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Endpoint lingua
| Strumento di fonderia | Endpoint |
|---|---|
| Analisi del testo | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com |
Importante
Il 20 marzo 2027, Azure Language Studio ritirerà ed eseguirà la migrazione a Microsoft Foundry. Tutte le funzionalità e i miglioramenti futuri saranno disponibili in Microsoft Foundry.
Il 31 marzo 2029, le seguenti funzionalità del linguaggio di Azure verranno ritirati (fine del supporto). Prima di tale data, gli utenti devono eseguire la migrazione dei carichi di lavoro esistenti ed eseguire l'onboarding di nuovi progetti in Microsoft modelli Foundry per una migliore comprensione del linguaggio naturale e l'integrazione semplificata delle applicazioni:
- Estrazione frasi chiave
- Analisi del sentiment e estrazione delle opinioni
- Classificazione testo personalizzata
- Comprensione del Linguaggio Conversazionale (CLU)
- Risposta alle domande personalizzata (CQA)
- Flusso di lavoro di orchestrazione
- Riepilogo (estratto e astrazione, per documenti e conversazioni)
- Collegamento di entità
Funzionalità principali con supporto continuo: Rilevamento della Lingua, Rilevamento delle Informazioni Personali, Analisi del testo per la Salute, NER predefinito e NER personalizzato.
Per le opzioni di migrazione, vedere Migrate da Language Studio a Microsoft Foundry.
(
