Este artigo explica como gerar respostas textuais para modelos Foundry, como Microsoft AI, DeepSeek e modelos Grok, utilizando a API Responses. Para uma lista completa dos Modelos Foundry que suportam a utilização da API Responses, consulte Modelos Foundry Suportados.
Pré-requisitos
Para usar a API Responses com modelos implementados na sua aplicação, precisa de:
Uma subscrição do Azure. Se estiveres a usar GitHub Models, podes atualizar a tua experiência e criar uma subscrição do Azure no processo. Leia Upgrade de GitHub Models para Microsoft Foundry Models se for esse o seu caso.
Um projeto da Foundry. Este tipo de projeto é gerido através de um recurso da Foundry. Se não tiver um projeto Foundry, veja Criar um projeto para Microsoft Foundry.
O endereço URL do endpoint do seu projeto Foundry, que tem o formato https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME.
Uma implementação de um Modelo de Fundição, como o DeepSeek-R1-0528 modelo utilizado neste artigo. Se ainda não tiver uma implementação, veja Adicionar e configurar Modelos Foundry para implementação de modelos nos seus recursos.
Usa o kit inicial de modelos de IA
Os excertos de código neste artigo são do kit inicial de modelos de IA. Use este kit inicial como uma forma rápida de começar com toda a infraestrutura cloud e o código necessários para chamar Foundry Models, usando uma biblioteca OpenAI estável com a API Responses.
Utilize a API de Respostas para gerar texto
Use o código nesta secção para fazer chamadas Response API para modelos Foundry. Nos exemplos de código, cria-se o cliente para consumir o modelo e depois envia-se um pedido básico.
Dica
Quando implementas um modelo no portal Foundry, atribuis-lhe um nome de implementação. Use este nome de implementação (não o ID do catálogo de modelos) no model parâmetro das suas chamadas de API.
Bibliotecas de instalação, incluindo a biblioteca cliente Azure Identity:
pip install azure-identity
pip install -U openai
Use o código seguinte para configurar o objeto cliente OpenAI na rota do projeto, especificar a sua implementação e gerar respostas.
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI
project_endpoint = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME"
# Build the base URL: project_endpoint + /openai/v1 (no api-version needed)
base_url = project_endpoint.rstrip("/") + "/openai/v1"
# get_bearer_token_provider returns a callable; call it to get automatic refresh of the token string
credential = DefaultAzureCredential()
token_provider = get_bearer_token_provider(credential, "https://ai.azure.com/.default")
client = OpenAI(
base_url=base_url,
api_key=token_provider(),
)
response = client.responses.create(
model="DeepSeek-R1-0528", # Replace with your deployment name, not the model ID
input="What are the top 3 benefits of cloud computing? Be concise.",
max_output_tokens=500,
)
print(f"Response: {response.output_text}")
print(f"Status: {response.status}")
print(f"Output tokens: {response.usage.output_tokens}")
Instalar a biblioteca cliente Azure Identity:
dotnet add package Azure.Identity
dotnet add package OpenAI
Use o código seguinte para configurar o objeto cliente OpenAI na rota do projeto, especificar a sua implementação e gerar respostas.
using Azure.Identity;
using OpenAI;
using OpenAI.Responses;
var deploymentName = "DeepSeek-R1-0528"; // Replace with your deployment name, not the model ID
var project_endpoint = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME";
// Get EntraID token for keyless auth
var credential = new DefaultAzureCredential();
var token = await credential.GetTokenAsync(
new Azure.Core.TokenRequestContext(["https://ai.azure.com/.default"])
);
// Standard OpenAI client — no AzureOpenAI wrapper (no api-version needed with /v1 path)
var baseUrl = project_endpoint.TrimEnd('/') + "/openai/v1";
var client = new OpenAIClient(
new ApiKeyCredential(token.Token),
new OpenAIClientOptions { Endpoint = new Uri(baseUrl) });
// GetResponsesClient takes no parameter; model goes in CreateResponseOptions
var responseClient = client.GetResponsesClient(deploymentName);
var result = await responseClient.CreateResponseAsync(new CreateResponseOptions(
[ResponseItem.CreateUserMessageItem("What are the top 3 benefits of cloud computing? Be concise.")])
{ MaxOutputTokenCount = 500 }
);
Console.WriteLine($"Response: {result.Value.GetOutputText()}");
Console.WriteLine($"Status: {result.Value.Status}");
Console.WriteLine($"Output tokens: {result.Value.Usage.OutputTokenCount}");
Instale a biblioteca cliente Azure Identity antes de poder usar DefaultAzureCredential:
npm install @azure/identity
npm install openai
Use o código seguinte para configurar o objeto cliente OpenAI na rota do projeto, especificar a sua implementação e gerar respostas.
import OpenAI from "openai";
import { DefaultAzureCredential } from "@azure/identity";
async function getToken(): Promise<string> {
const credential = new DefaultAzureCredential();
const tokenResponse = await credential.getToken(
"https://ai.azure.com/.default"
);
return tokenResponse.token;
}
async function main() {
const projectEndpoint = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME";
const deploymentName = "DeepSeek-R1-0528"; // Replace with your deployment name, not the model ID
const baseURL = projectEndpoint.replace(/\/+$/, "") + "/openai/v1";
const token = await getToken();
const client = new OpenAI({
baseURL,
apiKey: token,
});
const response = await client.responses.create({
model: deploymentName,
input: "What are the top 3 benefits of cloud computing? Be concise.",
max_output_tokens: 500,
});
console.log(`Response: ${response.output_text}`);
console.log(`Status: ${response.status}`);
console.log(`Output tokens: ${response.usage?.output_tokens}`);
}
main();
A autenticação com Microsoft Entra ID requer alguma configuração inicial. Primeiro, instala a biblioteca cliente Azure Identity. Para mais opções sobre como instalar esta biblioteca, consulte Azure Biblioteca cliente de identidade para Java.
Adicionar a biblioteca cliente Azure Identity:
<dependencies>
<dependency>
<groupId>com.openai</groupId>
<artifactId>openai-java</artifactId>
<version>4.22.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.15.4</version>
</dependency>
</dependencies>
Depois de configurado, escolha de azure.identity o tipo de credencial a usar. Por exemplo, usar DefaultAzureCredential para autenticar o cliente.
DefaultAzureCredential é a opção mais fácil porque encontra a melhor credencial para usar no seu ambiente de execução.
Use o código seguinte para configurar o objeto cliente OpenAI na rota do projeto, especificar a sua implementação e gerar respostas.
import com.azure.core.credential.TokenRequestContext;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
public class Sample {
public static void main(String[] args) {
String endpoint = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME";
String deploymentName = "DeepSeek-R1-0528"; // Replace with your deployment name, not the model ID
// Get EntraID token for keyless auth
var credential = new DefaultAzureCredentialBuilder().build();
var context = new TokenRequestContext().addScopes("https://ai.azure.com/.default");
String token = credential.getToken(context).block().getToken();
// Standard OpenAI client — no Azure wrapper
// Java SDK uses /openai/v1 path (no api-version needed; SDK manages versioning internally)
String baseUrl = endpoint.replaceAll("/+$", "") + "/openai/v1";
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl(baseUrl)
.apiKey(token)
.build();
var response = client.responses().create(
ResponseCreateParams.builder()
.model(deploymentName)
.input("What are the top 3 benefits of cloud computing? Be concise.")
.maxOutputTokens(500)
.build()
);
System.out.printf("Response: %s%n", response.outputText());
System.out.printf("Status: %s%n", response.status());
response.usage().ifPresent(u ->
System.out.printf("Output tokens: %d%n", u.outputTokens()));
}
}
Antes de executar o exemplo, instale os módulos Go necessários.
go get github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1
go get github.com/openai/openai-go/v3 v3.22.0
Use o código seguinte para configurar o objeto cliente OpenAI na rota do projeto, especificar a sua implementação e gerar respostas.
package main
import (
"context"
"fmt"
"os"
"strings"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
"github.com/openai/openai-go/v3/responses"
)
func main() {
projectEndpoint := "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME"
deploymentName := "DeepSeek-R1-0528" // Replace with your deployment name, not the model ID
ctx := context.Background()
// Get EntraID token for keyless auth
credential, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to create credential: %v\n", err)
os.Exit(1)
}
token, err := credential.GetToken(ctx, policy.TokenRequestOptions{
Scopes: []string{"https://ai.azure.com/.default"},
})
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to get token: %v\n", err)
os.Exit(1)
}
// Standard OpenAI client — no Azure wrapper (no api-version needed with /v1 path)
baseURL := strings.TrimRight(projectEndpoint, "/") + "/openai/v1"
client := openai.NewClient(
option.WithBaseURL(baseURL),
option.WithAPIKey(token.Token),
)
resp, err := client.Responses.New(ctx, responses.ResponseNewParams{
Model: deploymentName,
Input: responses.ResponseNewParamsInputUnion{
OfString: openai.String("What are the top 3 benefits of cloud computing? Be concise."),
},
MaxOutputTokens: openai.Int(500),
})
if err != nil {
fmt.Fprintf(os.Stderr, "API error: %v\n", err)
os.Exit(1)
}
fmt.Printf("Response: %s\n", resp.OutputText())
fmt.Printf("Status: %s\n", resp.Status)
fmt.Printf("Output tokens: %d\n", resp.Usage.OutputTokens)
}
A resposta inclui o texto gerado juntamente com os metadados do modelo e da utilização.
Modelos de Fundição Suportados
Uma seleção de Modelos Foundry é suportada para utilização com a API Responses.
Veja os modelos suportados no portal Foundry
Para ver a lista completa dos modelos suportados no portal Foundry:
- Iniciar sessão no Microsoft Foundry. Certifica-te de que a opção New Foundry está ativada. Estes passos referem-se à Foundry (nova).
- Selecione Descobrir no canto superior direito da navegação, depois Modelos no painel esquerdo.
- Abra o menu de opções Capacidades e selecione o filtro Agente Suportado.
Lista de modelos suportados
Esta secção lista alguns dos Modelos Foundry suportados para uso com a API Responses. Para os modelos OpenAI Azure suportados, veja Modelos OpenAI Azure disponíveis.
Modelos vendidos diretamente por Azure:
-
MAI-DS-R1: Raciocínio determinístico e focado na precisão.
-
grok-4: Raciocínio à escala de fronteira para resolução complexa de problemas em múltiplos passos.
-
grok-4-fast-reasoning: Raciocínio agential acelerado otimizado para automação de fluxos de trabalho.
-
grok-4-fast-non-reasoning: Criação de alta eficiência e roteamento de sistema com baixa latência.
-
grok-3: Raciocínio forte para fluxos de trabalho complexos ao nível do sistema.
-
grok-3-mini: Modelo leve otimizado para casos de uso interativos e de alto volume.
-
Llama-3.3-70B-Instruct: Modelo versátil para perguntas e respostas empresariais, apoio à decisão e orquestração de sistemas.
-
Llama-4-Maverick-17B-128E-Instruct-FP8: Modelo otimizado para FP8 que oferece inferências rápidas e económicas.
-
DeepSeek-V3-0324: Compreensão multimodal em texto e imagens.
-
DeepSeek-V3.1: Raciocínio multimodal aprimorado e recuperação fundamentada.
-
DeepSeek-R1-0528: Raciocínio avançado em formato longo e múltiplos passos.
-
gpt-oss-120b: Modelo de ecossistema aberto que suporta transparência e reprodutibilidade.
Resolução de erros comuns
| Erro |
Causa |
Resolução |
| 401 Não Autorizado |
Credencial inválida ou expirada |
Verifica se o teu DefaultAzureCredential tem o papel Utilizador OpenAI de Serviços Cognitivos atribuído no recurso. |
| 404 Não Encontrado |
Endpoint ou nome de implementação errado |
Confirme que a URL do seu endpoint inclui /api/projects/YOUR_PROJECT_NAME e o nome da implementação corresponde ao seu portal Foundry. |
| Modelo 400 não suportado |
O Model não suporta a API de Respostas |
Verifique a lista de modelos suportados e verifique se a sua implementação utiliza um modelo compatível. |
Conteúdo relacionado