Comment générer des réponses textuelles avec les modèles Foundry de Microsoft

Cet article explique comment générer des réponses de texte pour les modèles Foundry, tels que Microsoft IA, DeepSeek et Grok, à l’aide de l’API Réponses. Pour obtenir la liste complète des Modèles Foundry qui prennent en charge l'utilisation de l'API Réponses, consultez Modèles Foundry pris en charge.

Conditions préalables

Pour utiliser l’API Réponses avec des modèles déployés dans votre application, vous avez besoin des éléments suivants :

Un abonnement Azure. Si vous utilisez GitHub Modèles, vous pouvez mettre à niveau votre expérience et créer un abonnement Azure dans le processus. Lisez Upgrader à partir de GitHub Models vers Microsoft Foundry Models si c'est votre cas.
Un projet nommé Foundry. Ce type de projet est géré sous une ressource Foundry. Si vous n'avez pas de projet Foundry, consultez Créer un projet pour Microsoft Foundry.
URL du point de terminaison de votre projet Foundry, qui est de la forme https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME.
Déploiement d’un modèle Foundry, tel que le DeepSeek-R1-0528 modèle utilisé dans cet article. Si vous n’avez pas encore de déploiement, consultez Ajouter et configurer des modèles Foundry à un déploiement de modèle sur votre ressource.

Utiliser le kit de démarrage du modèle IA

Les extraits de code de cet article proviennent du kit de démarrage du modèle IA. Utilisez ce kit de démarrage comme moyen rapide de bien démarrer avec l’infrastructure cloud complète et le code nécessaires pour appeler des modèles Foundry, à l’aide d’une bibliothèque OpenAI stable avec l’API Réponses.

Utiliser l’API Réponses pour générer du texte

Utilisez le code de cette section pour effectuer des appels d’API Réponses pour les modèles Foundry. Dans les exemples de code, vous créez le client pour consommer le modèle, puis envoyez-le une demande de base.

Conseil

Lorsque vous déployez un modèle dans le portail Foundry, vous lui attribuez un nom de déploiement. Utilisez ce nom de déploiement (et non l’ID du catalogue de modèles) dans le model paramètre de vos appels d’API.

Note

Utilisez l’authentification sans clé avec Microsoft Entra ID. Pour en savoir plus sur l’authentification sans clé, consultez Quel est l’authentification Microsoft Entra ? et DefaultAzureCredential.

Installez des bibliothèques, notamment la bibliothèque cliente Azure Identity :
```
pip install azure-identity
pip install -U openai
```

Utilisez le code suivant pour configurer l’objet client OpenAI dans l’itinéraire du projet, spécifier votre déploiement et générer des réponses.

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}")

Installez la bibliothèque de client Azure Identity :

dotnet add package Azure.Identity
dotnet add package OpenAI

Utilisez le code suivant pour configurer l’objet client OpenAI dans l’itinéraire du projet, spécifier votre déploiement et générer des réponses.

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}");

Installez la bibliothèque cliente Azure Identity avant de pouvoir utiliser DefaultAzureCredential :
```
npm install @azure/identity
npm install openai
```

Utilisez le code suivant pour configurer l’objet client OpenAI dans l’itinéraire du projet, spécifier votre déploiement et générer des réponses.

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();

L’authentification avec Microsoft Entra ID nécessite une configuration initiale. Tout d’abord, installez la bibliothèque de client Azure Identity. Pour plus d’options sur l’installation de cette bibliothèque, consultez Azure bibliothèque cliente Identity pour Java.

Ajoutez la bibliothèque de client 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>
```
Après l’installation, choisissez le type d’informations d’identification azure.identity à utiliser. Par exemple, utilisez-le DefaultAzureCredential pour authentifier le client. DefaultAzureCredential est l’option la plus simple, car elle trouve les meilleures informations d’identification à utiliser dans son environnement en cours d’exécution.

Utilisez le code suivant pour configurer l’objet client OpenAI dans l’itinéraire du projet, spécifier votre déploiement et générer des réponses.

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()));
    }
}

Avant d’exécuter l’exemple, installez les modules Go requis.

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

Utilisez le code suivant pour configurer l’objet client OpenAI dans l’itinéraire du projet, spécifier votre déploiement et générer des réponses.

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)
}

La réponse inclut le texte généré, ainsi que les métadonnées de modèle et d’utilisation.

Modèles Foundry pris en charge

Une sélection de modèles Foundry est prise en charge pour une utilisation avec l’API Réponses.

Afficher les modèles pris en charge dans le portail Foundry

Pour afficher la liste complète des modèles pris en charge dans le portail Foundry :

Connectez-vous à Microsoft Foundry. Vérifiez que le commutateur New Foundry est activé. Ces étapes font référence à Foundry (nouveau).
Sélectionnez Découvrir dans le volet supérieur droit, puis Modèles dans le volet gauche.
Ouvrez la liste déroulante Fonctionnalités et sélectionnez le filtre pris en charge par l’agent .

Liste des modèles pris en charge

Cette section répertorie certains des Modèles Foundry pris en charge pour une utilisation avec l'API Réponses. Pour connaître les modèles OpenAI Azure disponibles et pris en charge, consultez modèles OpenAI Azure disponibles.

Models vendus directement par Azure :

MAI-DS-R1 : raisonnement déterministe et axé sur la précision.
grok-4 : raisonnement de pointe pour la résolution de problèmes complexes et en plusieurs étapes.
grok-4-fast-reasoning : raisonnement agentique accéléré optimisé pour l’automatisation du flux de travail.
grok-4-fast-non-reasoning : génération à haut débit, faible latence et routage système.
grok-3 : raisonnement fort pour les flux de travail complexes au niveau du système.
grok-3-mini : modèle léger optimisé pour les cas d’usage interactifs et à volume élevé.
Llama-3.3-70B-Instruct : Modèle polyvalent pour les Q&A d’entreprise, prise de décision et orchestration du système.
Llama-4-Maverick-17B-128E-Instruct-FP8 : modèle optimisé fp8 qui offre une inférence rapide et économique.
DeepSeek-V3-0324 : compréhension modale entre le texte et les images.
DeepSeek-V3.1 : raisonnement modal amélioré et récupération fondée.
DeepSeek-R1-0528 : raisonnement avancé à long terme et en plusieurs étapes.
gpt-oss-120b : modèle écosystème ouvert qui prend en charge la transparence et la reproductibilité.

Résoudre les erreurs courantes

Erreur	Cause	Résolution
401 Non autorisé	Informations d’identification non valides ou expirées	Vérifiez que votre `DefaultAzureCredential` a le rôle d’utilisateur OpenAI de Cognitive Services attribué sur la ressource.
404 Introuvable	Nom de point de terminaison ou de déploiement incorrect	Vérifiez que l’URL de votre point de terminaison inclut `/api/projects/YOUR_PROJECT_NAME` et que le nom du déploiement correspond à votre portail Foundry.
Modèle 400 non pris en charge	Le modèle ne prend pas en charge l’API Réponses	Vérifiez la liste des modèles pris en charge et vérifiez que votre déploiement utilise un modèle compatible.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-29