I modelli di Microsoft Foundry consentono di accedere ai modelli più potenti dai provider di modelli leader tramite un singolo endpoint e un set di credenziali. Questa funzionalità consente di passare da un modello all'altro e usarli nell'applicazione senza modificare alcun codice.
Questo articolo illustra come i servizi Foundry organizzano i modelli e come usare l'endpoint di inferenza per accedervi.
Una risorsa Foundry può avere molte distribuzioni di modelli. Si paga solo per l'inferenza eseguita nelle implementazioni dei modelli. Le distribuzioni sono risorse di Azure, quindi sono soggette ai criteri di Azure.
Installare il pacchetto openai usando la propria gestione pacchetti, come pip:
pip install openai --upgrade
Quindi, è possibile usare il pacchetto per usare il modello. Gli esempi seguenti mostrano come creare un client per utilizzare i completamenti chat:
import os
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint = "https://<resource>.services.ai.azure.com"
api_key=os.getenv("AZURE_INFERENCE_CREDENTIAL"),
api_version="2024-10-21",
)
Installare il pacchetto openai usando npm:
npm install openai
Quindi, è possibile usare il pacchetto per usare il modello. Gli esempi seguenti mostrano come creare un client per utilizzare i completamenti chat:
import { AzureKeyCredential } from "@azure/openai";
const endpoint = "https://<resource>.services.ai.azure.com";
const apiKey = new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL);
const apiVersion = "2024-10-21"
const client = new AzureOpenAI({
endpoint,
apiKey,
apiVersion,
"deepseek-v3-0324"
});
Qui, deepseek-v3-0324 è il nome di una distribuzione del modello nella risorsa Microsoft Foundry.
Installare la libreria OpenAI con il comando seguente:
dotnet add package Azure.AI.OpenAI --prerelease
È possibile usare il pacchetto per utilizzare il modello. Gli esempi seguenti mostrano come creare un client per utilizzare i completamenti chat:
AzureOpenAIClient client = new(
new Uri("https://<resource>.services.ai.azure.com"),
new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);
Aggiungere il pacchetto al progetto:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-openai</artifactId>
<version>1.0.0-beta.16</version>
</dependency>
Quindi, è possibile usare il pacchetto per usare il modello. Gli esempi seguenti mostrano come creare un client per utilizzare i completamenti chat:
OpenAIClient client = new OpenAIClientBuilder()
.credential(new AzureKeyCredential("{key}"))
.endpoint("https://<resource>.services.ai.azure.com")
.buildClient();
Usare la sezione di riferimento per esplorare la progettazione API e quali parametri sono disponibili. Ad esempio, la sezione di riferimento per i completamenti di Chat illustra in dettaglio come usare la route /chat/completions per generare stime in base alle istruzioni in formato chat:
Richiedi
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
Ecco, deepseek-v3-0324 è il nome di una distribuzione del modello nella risorsa Foundry.
response = client.chat.completions.create(
model="deepseek-v3-0324", # Replace with your model deployment name.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain Riemann's conjecture in 1 paragraph"}
]
)
print(response.model_dump_json(indent=2)
var messages = [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "Explain Riemann's conjecture in 1 paragraph" },
];
const response = await client.chat.completions.create({ messages, model: "deepseek-v3-0324" });
console.log(response.choices[0].message.content)
ChatCompletion response = chatClient.CompleteChat(
[
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("Explain Riemann's conjecture in 1 paragraph"),
]);
Console.WriteLine($"{response.Role}: {response.Content[0].Text}");
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant"));
chatMessages.add(new ChatRequestUserMessage("Explain Riemann's conjecture in 1 paragraph"));
ChatCompletions chatCompletions = client.getChatCompletions("deepseek-v3-0324",
new ChatCompletionsOptions(chatMessages));
System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
System.out.println("Message:");
System.out.println(message.getContent());
}
Qui, deepseek-v3-0324 è il nome di una distribuzione del modello nella risorsa Microsoft Foundry.
Richiedi
POST https://<resource>.services.ai.azure.com/openai/deployments/deepseek-v3-0324/chat/completions?api-version=2024-10-21
api-key: <api-key>
Content-Type: application/json
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
"role": "user",
"content": "Explain Riemann's conjecture in 1 paragraph"
}
]
}
Ecco, deepseek-v3-0324 è il nome di una distribuzione del modello nella risorsa Foundry.
I modelli distribuiti su Foundry Models negli strumenti Foundry supportano l'autenticazione senza chiave usando Microsoft Entra ID. L'autorizzazione senza chiave migliora la sicurezza, semplifica l'esperienza utente, riduce la complessità operativa e offre un supporto affidabile per la conformità per lo sviluppo moderno. Rende l'autorizzazione senza chiave una scelta efficace per le organizzazioni che adottano soluzioni di gestione delle identità sicure e scalabili.
Installare OpenAI SDK usando una gestione pacchetti come pip:
pip install openai
Per l'autenticazione di Microsoft Entra ID, installare anche:
pip install azure-identity
Usare il pacchetto per utilizzare il modello. L'esempio seguente illustra come creare un client per usufruire dei completamenti della chat utilizzando l'ID Microsoft Entra e eseguire una chiamata di prova all'endpoint dei completamenti della chat nell'ambito della distribuzione del modello.
Sostituisci <resource> con il nome della risorsa Foundry. Trovarlo nel portale di Azure o eseguendo az cognitiveservices account list. Sostituire DeepSeek-V3.1 con il nome attuale della distribuzione.
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(),
"https://cognitiveservices.azure.com/.default"
)
client = OpenAI(
base_url="https://<resource>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
completion = client.chat.completions.create(
model="DeepSeek-V3.1", # Required: your deployment name
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is Azure AI?"}
]
)
print(completion.choices[0].message.content)
Output previsto
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Riferimento: OpenAI Python SDK e classe DefaultAzureCredential.
Installare OpenAI SDK:
dotnet add package OpenAI
Per l'autenticazione di Microsoft Entra ID, installare anche il Azure.Identity pacchetto:
dotnet add package Azure.Identity
Importa i seguenti namespace:
using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;
Usare quindi il pacchetto per utilizzare il modello. L'esempio seguente illustra come creare un client per utilizzare i completamenti di chat con Microsoft Entra ID e quindi effettuare una chiamata di test all'endpoint dei completamenti di chat con la distribuzione del modello.
Sostituire <resource> con il nome della risorsa Foundry (trovarlo nel portale di Azure). Sostituire gpt-4o-mini con il nome attuale della distribuzione.
#pragma warning disable OPENAI001
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://cognitiveservices.azure.com/.default"
);
ChatClient client = new(
model: "gpt-4o-mini", // Your deployment name
authenticationPolicy: tokenPolicy,
options: new OpenAIClientOptions() {
Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1/")
}
);
ChatCompletion completion = client.CompleteChat(
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("What is Azure AI?")
);
Console.WriteLine(completion.Content[0].Text);
Output previsto:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Riferimento: OpenAI .NET SDK e classe DefaultAzureCredential.
Installare OpenAI SDK con npm:
npm install openai
Per l'autenticazione di Microsoft Entra ID, installare anche:
npm install @azure/identity
Usare quindi il pacchetto per utilizzare il modello. L'esempio seguente illustra come creare un client per utilizzare i completamenti di chat con Microsoft Entra ID e quindi effettuare una chiamata di test all'endpoint dei completamenti di chat con la distribuzione del modello.
Sostituire <resource> con il nome della risorsa Foundry (trovarlo nel portale di Azure o eseguendo az cognitiveservices account list). Sostituire DeepSeek-V3.1 con il nome attuale della distribuzione.
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { OpenAI } from "openai";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
'https://cognitiveservices.azure.com/.default'
);
const client = new OpenAI({
baseURL: "https://<resource>.openai.azure.com/openai/v1/",
apiKey: tokenProvider
});
const completion = await client.chat.completions.create({
model: "DeepSeek-V3.1", // Required: your deployment name
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "What is Azure AI?" }
]
});
console.log(completion.choices[0].message.content);
Output previsto:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Riferimento: OpenAI Node.js SDK e classe DefaultAzureCredential.
Aggiungere OpenAI SDK al progetto. Controllare il repository GitHub Java OpenAI per la versione più recente e le istruzioni di installazione.
Per l'autenticazione di Microsoft Entra ID, aggiungere anche:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.0</version>
</dependency>
Usare quindi il pacchetto per utilizzare il modello. L'esempio seguente illustra come creare un client per utilizzare i completamenti di chat con Microsoft Entra ID e quindi effettuare una chiamata di test all'endpoint dei completamenti di chat con la distribuzione del modello.
Sostituire <resource> con il nome della risorsa Foundry (trovarlo nel portale di Azure). Sostituire DeepSeek-V3.1 con il nome attuale della distribuzione.
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.chat.completions.*;
DefaultAzureCredential tokenCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://<resource>.openai.azure.com/openai/v1/")
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
tokenCredential,
"https://cognitiveservices.azure.com/.default"
)
))
.build();
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.addSystemMessage("You are a helpful assistant.")
.addUserMessage("What is Azure AI?")
.model("DeepSeek-V3.1") // Required: your deployment name
.build();
ChatCompletion completion = client.chat().completions().create(params);
System.out.println(completion.choices().get(0).message().content());
Output previsto:
Azure AI is a comprehensive suite of artificial intelligence services and tools from Microsoft that enables developers to build intelligent applications. It includes services for natural language processing, computer vision, speech recognition, and machine learning capabilities.
Riferimento: OpenAI Java SDK e classe DefaultAzureCredential.
Esplorare la progettazione dell'API nella sezione di riferimento per vedere quali parametri sono disponibili. Indicare il token di autenticazione nell'intestazione Authorization. Ad esempio, la sezione di riferimento al completamento della chat descrive in dettaglio come usare la /chat/completions route per generare stime in base alle istruzioni in formato chat. Il percorso /models è incluso nella radice dell'URL:
Richiedi
Sostituire <resource> con il nome della risorsa Foundry (trovarlo nel portale di Azure o eseguendo az cognitiveservices account list). Sostituire MAI-DS-R1 con il nome attuale della distribuzione.
La base_url accetterà entrambi i formati https://<resource>.openai.azure.com/openai/v1/ e https://<resource>.services.ai.azure.com/openai/v1/.
curl -X POST https://<resource>.openai.azure.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
-d '{
"model": "MAI-DS-R1",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Explain what the bitter lesson is?"
}
]
}'
risposta
Se l'autenticazione ha esito positivo, viene visualizzata una 200 OK risposta con il completamento della chat nel corpo della risposta:
{
"id": "chatcmpl-...",
"object": "chat.completion",
"created": 1738368234,
"model": "MAI-DS-R1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The bitter lesson refers to a key insight in AI research that emphasizes the importance of general-purpose learning methods that leverage computation, rather than human-designed domain-specific approaches. It suggests that methods which scale with increased computation tend to be more effective in the long run."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 28,
"completion_tokens": 52,
"total_tokens": 80
}
}
I token devono essere rilasciati con l'ambito https://cognitiveservices.azure.com/.default.
Ai fini dei test, il modo più semplice per ottenere un token valido per l'account utente consiste nell'usare l'interfaccia della riga di comando di Azure. In una console, eseguire il seguente comando Azure CLI:
az account get-access-token --resource https://cognitiveservices.azure.com --query "accessToken" --output tsv
Questo comando restituisce un token di accesso che è possibile archiviare nella $AZURE_OPENAI_AUTH_TOKEN variabile di ambiente.
Riferimento: Chat Completions API