Azure supporto del linguaggio OpenAI SDK

| Pacchetto | Superficie API

Gli esempi sono stati testati con OpenAI 2.12.0, Azure.Identity 1.21.0 e .NET 8. Il pacchetto OpenAI è destinato anche .NET versioni standard 2.0 e successive .NET.

Installare i pacchetti

Installare i pacchetti OpenAI e Azure Identity:

dotnet add package OpenAI
dotnet add package Azure.Identity

I comandi aggiungono entrambi i riferimenti al pacchetto al progetto.

Creare una risposta con Microsoft Entra ID

Usare DefaultAzureCredential e BearerTokenPolicy per eseguire l'autenticazione senza archiviare una chiave API.

using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

var endpoint = new Uri(
    "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/");
var tokenPolicy = new BearerTokenPolicy(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");
var openAIClient = new ResponsesClient(
    tokenPolicy,
    new ResponsesClientOptions { Endpoint = endpoint });

var response = await openAIClient.CreateResponseAsync(
    "gpt-5-mini",
    "Explain the purpose of an API in one sentence.");
Console.WriteLine(response.Value.GetOutputText());

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: ResponsesClient

Creare una risposta con una chiave API

Le chiavi API non sono consigliate per l'uso in produzione. Archiviare la chiave nella AZURE_OPENAI_API_KEY variabile di ambiente anziché inserirla nel codice sorgente.

export AZURE_OPENAI_API_KEY="<your-api-key>"

Creare quindi il client e la richiesta:

using OpenAI.Responses;
using System.ClientModel;

#pragma warning disable OPENAI001

var endpoint = new Uri(
    "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/");
var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")
    ?? throw new InvalidOperationException("AZURE_OPENAI_API_KEY is required.");
var openAIClient = new ResponsesClient(
    new ApiKeyCredential(apiKey),
    new ResponsesClientOptions { Endpoint = endpoint });

var response = await openAIClient.CreateResponseAsync(
    "gpt-5-mini",
    "Explain the purpose of an API in one sentence.");
Console.WriteLine(response.Value.GetOutputText());

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: CreateResponseAsync

Usare i completamenti della chat

Per le nuove applicazioni, usare l'API Risposte. Usare i completamenti della chat quando è necessaria l'interfaccia basata su messaggi o se si gestisce un'applicazione esistente.

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

var endpoint = new Uri(
    "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/");
var tokenPolicy = new BearerTokenPolicy(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");
var openAIClient = new ChatClient(
    model: "gpt-5-mini",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions { Endpoint = endpoint });

var completion = await openAIClient.CompleteChatAsync([
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("Explain the purpose of an API.")
]);
Console.WriteLine(completion.Value.Content[0].Text);

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: ChatClient

Trasmettere una risposta

Chiamare CreateResponseStreamingAsync ed elaborare gli aggiornamenti differenziali del testo man mano che il modello li genera:

using OpenAI.Responses;
using System.ClientModel;

#pragma warning disable OPENAI001

var endpoint = new Uri(
    "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/");
var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")
    ?? throw new InvalidOperationException("AZURE_OPENAI_API_KEY is required.");
var openAIClient = new ResponsesClient(
    new ApiKeyCredential(apiKey),
    new ResponsesClientOptions { Endpoint = endpoint });

// Stream text as the model generates it.
var updates = openAIClient.CreateResponseStreamingAsync(
    "gpt-5-mini",
    "Explain the purpose of an API in one sentence.");
await foreach (var update in updates)
{
    if (update is StreamingResponseOutputTextDeltaUpdate delta)
    {
        Console.Write(delta.Delta);
    }
}

L'output trasmesso seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: CreateResponseStreamingAsync

Gestire errori e ripetizioni

Il client ritenta automaticamente le risposte HTTP 408, 429, 500, 502, 503 e 504 con backoff esponenziale. Configurare i criteri di ripetizione dei tentativi tramite le opzioni client quando è necessario un comportamento diverso. Intercettare ClientResultException per esaminare lo stato HTTP e i dettagli dell'errore per una richiesta non riuscita.

Per la diagnostica, mantenere l'oggetto ClientResult<T> restituito da un'operazione ed esaminare le intestazioni di risposta non elaborate. Le operazioni non riuscite espongono informazioni sullo stato tramite ClientResultException.

Riferimento: Gestione degli errori e dettagli dei risultati del client

Altri esempi di SDK

• Usare l'API Risposte
• Generare incorporamenti
• Analizzare le immagini
• Ottimizzare un modello

| Pacchetto | Informazioni di riferimento | sulle API RESTInformazioni di riferimento sulle API Go

Gli esempi richiedono Go 1.25 o versione successiva. Sono stati testati con github.com/openai/openai-go/v3 3.44.0 e azidentity 1.14.0.

Installare i moduli

Installare i moduli OpenAI e Azure Identity:

go get github.com/openai/openai-go/v3
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Il /v3 suffisso è obbligatorio perché identifica la versione principale corrente del modulo Go.

Creare una risposta con Microsoft Entra ID

Usare DefaultAzureCredential e l'opzione di autenticazione Azure per eseguire l'autenticazione senza archiviare una chiave API.

package main

import (
	"context"
	"fmt"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/azure"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	credential, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil { panic(err) }
	endpoint := "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
	openaiClient := openai.NewClient(
		option.WithBaseURL(endpoint),
		azure.WithTokenCredential(credential, azure.WithTokenCredentialScopes(
			[]string{"https://ai.azure.com/.default"})))
	response, err := openaiClient.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: openai.ChatModel("gpt-5-mini"),
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(
			"Explain the purpose of an API in one sentence.")},
	})
	if err != nil { panic(err) }
	fmt.Println(response.OutputText())
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Riferimento: ResponseService.New e WithTokenCredentialScopes

Creare una risposta con una chiave API

Le chiavi API non sono consigliate per l'uso in produzione. Archiviare la chiave nella AZURE_OPENAI_API_KEY variabile di ambiente anziché inserirla nel codice sorgente.

export AZURE_OPENAI_API_KEY="<your-api-key>"

Creare quindi il client e la richiesta:

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	apiKey := os.Getenv("AZURE_OPENAI_API_KEY")
	if apiKey == "" { panic("AZURE_OPENAI_API_KEY is required") }
	endpoint := "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
	openaiClient := openai.NewClient(
		option.WithBaseURL(endpoint),
		option.WithAPIKey(apiKey))
	response, err := openaiClient.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: openai.ChatModel("gpt-5-mini"),
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(
			"Explain the purpose of an API in one sentence.")},
	})
	if err != nil { panic(err) }
	fmt.Println(response.OutputText())
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: Responses.New

Usare i completamenti della chat

Per le nuove applicazioni, usare l'API Risposte. Usare i completamenti della chat quando è necessaria l'interfaccia basata su messaggi o se si gestisce un'applicazione esistente.

package main

import (
	"context"
	"fmt"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/azure"
	"github.com/openai/openai-go/v3/option"
)

func main() {
	credential, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil { panic(err) }
	endpoint := "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
	openaiClient := openai.NewClient(
		option.WithBaseURL(endpoint),
		azure.WithTokenCredential(credential, azure.WithTokenCredentialScopes(
			[]string{"https://ai.azure.com/.default"})))
	completion, err := openaiClient.Chat.Completions.New(context.Background(),
		openai.ChatCompletionNewParams{
			Model: openai.ChatModel("gpt-5-mini"),
			Messages: []openai.ChatCompletionMessageParamUnion{
				openai.DeveloperMessage("You are a helpful assistant."),
				openai.UserMessage("Explain the purpose of an API.")}})
	if err != nil { panic(err) }
	fmt.Println(completion.Choices[0].Message.Content)
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: Chat.Completions.New

Trasmettere una risposta

Chiamare Responses.NewStreaminggli eventi delta del testo ed elaborarli man mano che il modello li genera:

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	endpoint := "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
	openaiClient := openai.NewClient(option.WithBaseURL(endpoint),
		option.WithAPIKey(os.Getenv("AZURE_OPENAI_API_KEY")))
	// Stream text as the model generates it.
	stream := openaiClient.Responses.NewStreaming(context.Background(), responses.ResponseNewParams{
		Model: openai.ChatModel("gpt-5-mini"),
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(
			"Explain the purpose of an API in one sentence.")},
	})
	for stream.Next() { fmt.Print(stream.Current().Delta) }
	if err := stream.Err(); err != nil { panic(err) }
}

L'output trasmesso seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: Responses.NewStreaming

Gestire errori e ripetizioni

L'SDK ritenta gli errori di connessione e le risposte HTTP 408, 409, 429 e 5xx due volte con backoff esponenziale. Usare option.WithMaxRetries per modificare il valore predefinito. Controllare l'oggetto restituito error prima di leggere una risposta e usare errors.As per controllare un oggetto openai.Error.

package main

import (
	"context"
	"errors"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	endpoint := "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
	openaiClient := openai.NewClient(option.WithBaseURL(endpoint),
		option.WithAPIKey(os.Getenv("AZURE_OPENAI_API_KEY")), option.WithMaxRetries(4))
	// Send the request and inspect structured service errors.
	result, err := openaiClient.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: openai.ChatModel("gpt-5-mini"),
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain an API.")},
	})
	if err != nil {
		var apiError *openai.Error
		if errors.As(err, &apiError) { fmt.Printf("Status: %d; Request ID: %s\n",
			apiError.StatusCode, apiError.Response.Header.Get("x-request-id")) }
		panic(err)
	}
	fmt.Println(result.OutputText())
}

Per una richiesta con esito positivo, l'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Riferimento: errori e tentativi

Altri esempi di SDK

• Usare l'API Risposte
• Generare incorporamenti
• Analizzare le immagini
• Ottimizzare un modello

| Pacchetto | Informazioni di riferimento | sulle API RESTInformazioni di riferimento sulle API Java

Gli esempi richiedono Java 8 o versione successiva. Sono stati testati con openai-java 4.43.0 e azure-identity 1.18.4.

Installare i pacchetti

Maven

Aggiungere le dipendenze OpenAI e Azure Identity al progetto Maven:

<dependencies>
  <dependency>
    <groupId>com.openai</groupId>
    <artifactId>openai-java</artifactId>
                <version>4.43.0</version>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.18.4</version>
  </dependency>
</dependencies>

Maven risolve i pacchetti e le relative dipendenze transitive quando si compila il progetto.

Gradle

Aggiungere gli stessi pacchetti al dependencies blocco nel file di compilazione Gradle:

dependencies {
        implementation("com.openai:openai-java:4.43.0")
        implementation("com.azure:azure-identity:1.18.4")
}

Gradle risolve i pacchetti quando si compila il progetto.

Creare una risposta con Microsoft Entra ID

Usare DefaultAzureCredential e BearerTokenCredential per eseguire l'autenticazione senza archiviare una chiave API.

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.ResponseCreateParams;

public class ResponsesExample {
    public static void main(String[] args) {
        String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
        OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
                .baseUrl(endpoint)
                .credential(BearerTokenCredential.create(
                        AuthenticationUtil.getBearerTokenSupplier(
                                new DefaultAzureCredentialBuilder().build(),
                                "https://ai.azure.com/.default")))
                .build();
        ResponseCreateParams params = ResponseCreateParams.builder()
                .model("gpt-5-mini")
                .input("Explain the purpose of an API in one sentence.")
                .build();
        openAIClient.responses().create(params).output().stream()
                .flatMap(item -> item.message().stream())
                .flatMap(message -> message.content().stream())
                .flatMap(content -> content.outputText().stream())
                .forEach(output -> System.out.println(output.text()));
    }
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Riferimento: AzureEntraIdExample e ResponsesExample

Creare una risposta con una chiave API

Non usare le chiavi API per l'ambiente di produzione. Archiviare la chiave nella AZURE_OPENAI_API_KEY variabile di ambiente anziché inserirla nel codice sorgente.

export AZURE_OPENAI_API_KEY="<your-api-key>"

Creare quindi il client e la richiesta:

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

public class ApiKeyResponsesExample {
    public static void main(String[] args) {
        String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
        String apiKey = System.getenv("AZURE_OPENAI_API_KEY");
        if (apiKey == null) throw new IllegalStateException(
                "AZURE_OPENAI_API_KEY is required.");
        OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
                .baseUrl(endpoint).apiKey(apiKey).build();
        ResponseCreateParams params = ResponseCreateParams.builder()
                .model("gpt-5-mini")
                .input("Explain the purpose of an API in one sentence.")
                .build();
        openAIClient.responses().create(params).output().stream()
                .flatMap(item -> item.message().stream())
                .flatMap(message -> message.content().stream())
                .flatMap(content -> content.outputText().stream())
                .forEach(output -> System.out.println(output.text()));
    }
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: OpenAIOkHttpClient

Usare i completamenti della chat

Per le nuove applicazioni, usare l'API Risposte. Usare i completamenti della chat quando è necessaria l'interfaccia basata su messaggi o se si gestisce un'applicazione esistente.

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class ChatExample {
    public static void main(String[] args) {
        String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
        String apiKey = System.getenv("AZURE_OPENAI_API_KEY");
        if (apiKey == null) throw new IllegalStateException(
                "AZURE_OPENAI_API_KEY is required.");
        OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
                .baseUrl(endpoint).apiKey(apiKey).build();
        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
                .model("gpt-5-mini")
                .addDeveloperMessage("You are a helpful assistant.")
                .addUserMessage("Explain the purpose of an API.")
                .build();
        openAIClient.chat().completions().create(params).choices().stream()
                .flatMap(choice -> choice.message().content().stream())
                .forEach(System.out::println);
    }
}

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: ChatCompletionCreateParams

Trasmettere una risposta

Chiamare createStreaminggli eventi delta del testo ed elaborarli man mano che il modello li genera:

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseStreamEvent;

public class StreamingExample {
    public static void main(String[] args) {
        String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
        String apiKey = System.getenv("AZURE_OPENAI_API_KEY");
        if (apiKey == null) throw new IllegalStateException(
                "AZURE_OPENAI_API_KEY is required.");
        OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
                .baseUrl(endpoint).apiKey(apiKey).build();
        // Stream text as the model generates it.
        ResponseCreateParams params = ResponseCreateParams.builder()
                .model("gpt-5-mini")
                .input("Explain the purpose of an API in one sentence.")
                .build();
        try (StreamResponse<ResponseStreamEvent> stream =
                openAIClient.responses().createStreaming(params)) {
            stream.stream().flatMap(event -> event.outputTextDelta().stream())
                    .forEach(delta -> System.out.print(delta.delta()));
        }
    }
}

L'output trasmesso seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: responses.createStreaming

Gestire errori e ripetizioni

L'SDK ritenta gli errori di connessione e le risposte HTTP 408, 409, 429 e 5xx due volte con backoff esponenziale. Intercettare OpenAIServiceException per esaminare lo stato HTTP e i dettagli dell'errore per una risposta al servizio e rilevare OpenAIException altri errori dell'SDK.

Chiamare maxRetries su OpenAIOkHttpClient.builder() per modificare il valore predefinito. Mantenere l'eccezione del servizio in modo che l'applicazione possa registrarne lo stato e richiedere i metadati.

Riferimento: Gestione degli errori e tentativi

Altri esempi di SDK

• Usare l'API Risposte
• Generare incorporamenti
• Analizzare le immagini
• Ottimizzare un modello

| Pacchetto | Informazioni di riferimento | sulle API RESTLinee guida Azure OpenAI v1

Gli esempi richiedono Node.js 20 o versione successiva. Sono stati testati con openai 6.46.0 e @azure/identity 4.13.1. Usare openai la versione 5.18.0 o successiva quando si passa un provider di token Microsoft Entra come apiKey.

Installare i pacchetti

Installare i pacchetti OpenAI e Azure Identity:

npm install openai @azure/identity

Il comando aggiunge entrambi i pacchetti al progetto.

Creare una risposta con Microsoft Entra ID

Usare DefaultAzureCredential e getBearerTokenProvider per eseguire l'autenticazione senza archiviare una chiave API. Il provider di token aggiorna il token di accesso quando necessario.

import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import OpenAI from "openai";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: endpoint, apiKey: tokenProvider });

async function main() {
  const response = await openai.responses.create({
    model: "gpt-5-mini",
    input: "Explain the purpose of an API in one sentence.",
  });
  console.log(response.output_text);
}

main().catch(console.error);

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Riferimento: OpenAI autenticazione client e Azure OpenAI v1

Creare una risposta con una chiave API

Le chiavi API non sono consigliate per l'uso in produzione. Archiviare la chiave nella AZURE_OPENAI_API_KEY variabile di ambiente anziché inserirla nel codice sorgente.

export AZURE_OPENAI_API_KEY="<your-api-key>"

Creare quindi il client e la richiesta:

import OpenAI from "openai";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const apiKey = process.env["AZURE_OPENAI_API_KEY"];
if (!apiKey) throw new Error("AZURE_OPENAI_API_KEY is required.");

const openai = new OpenAI({ baseURL: endpoint, apiKey });

async function main() {
  const response = await openai.responses.create({
    model: "gpt-5-mini",
    input: "Explain the purpose of an API in one sentence.",
  });
  console.log(response.output_text);
}

main().catch(console.error);

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: responses.create

Usare i completamenti della chat

Per le nuove applicazioni, usare l'API Risposte. Usare i completamenti della chat quando è necessaria l'interfaccia basata su messaggi o se si gestisce un'applicazione esistente.

import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import OpenAI from "openai";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: endpoint, apiKey: tokenProvider });

async function main() {
  const completion = await openai.chat.completions.create({
    model: "gpt-5-mini",
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: "Explain the purpose of an API." },
    ],
  });
  console.log(completion.choices[0]?.message.content ?? "No response returned.");
}

main().catch(console.error);

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Il mantenimento messages all'interno della richiesta fornisce la digitazione contestuale necessaria per i role valori. Se si definisce la matrice separatamente, dichiararla come OpenAI.Chat.ChatCompletionMessageParam[].

Informazioni di riferimento: chat.completions.create

Trasmettere una risposta

Impostare su streamtruee elaborare gli eventi delta del testo durante la generazione del modello:

import OpenAI from "openai";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const apiKey = process.env["AZURE_OPENAI_API_KEY"];
if (!apiKey) throw new Error("AZURE_OPENAI_API_KEY is required.");
const openai = new OpenAI({ baseURL: endpoint, apiKey });

async function main() {
  // Stream text as the model generates it.
  const stream = await openai.responses.create({
    model: "gpt-5-mini",
    input: "Explain the purpose of an API in one sentence.",
    stream: true,
  });
  for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
      process.stdout.write(event.delta);
    }
  }
}

main().catch(console.error);

L'output trasmesso seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: responses.create streaming

Gestire errori e ripetizioni

L'SDK ritenta automaticamente errori di connessione, timeout, HTTP 408, 409, 429 e risposte 5xx due volte con backoff esponenziale. Impostare maxRetries sul OpenAI client per modificare questo comportamento. Catch APIError per esaminare lo stato HTTP, l'ID richiesta e i dettagli dell'errore per una richiesta non riuscita.

L'esempio seguente imposta quattro tentativi e registra l'ID richiesta per le richieste riuscite e non riuscite:

import OpenAI from "openai";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const apiKey = process.env["AZURE_OPENAI_API_KEY"];
if (!apiKey) throw new Error("AZURE_OPENAI_API_KEY is required.");
const openai = new OpenAI({ baseURL: endpoint, apiKey, maxRetries: 4 });

async function main() {
  try {
    // Send the request and record its request ID.
    const response = await openai.responses.create({
      model: "gpt-5-mini",
      input: "Explain the purpose of an API in one sentence.",
    });
    console.log(response.output_text);
    console.log(`Request ID: ${response._request_id}`);
  } catch (error) {
    if (error instanceof OpenAI.APIError) {
      console.error(`Status: ${error.status}; Request ID: ${error.requestID}`);
    }
    throw error;
  }
}

main().catch(console.error);

Per una richiesta con esito positivo, l'output seguente è rappresentativo. Il testo della risposta e l'ID richiesta variano:

An API allows software applications to communicate and exchange data through a defined set of rules.
Request ID: <request-id>

Riferimento: ID richiesta, errori e tentativi

Altri esempi di SDK

• Usare l'API Risposte
• Generare incorporamenti
• Analizzare le immagini
• Ottimizzare un modello

| Pacchetto | Informazioni di riferimento sulle API

Gli esempi richiedono Python 3.9 o versione successiva. Sono stati testati con openai 2.46.0 e azure-identity 1.25.3. Usare openai la versione 1.106.0 o successiva quando si passa un provider di token Microsoft Entra come api_key.

Installare i pacchetti

Installare i pacchetti OpenAI e Azure Identity:

pip install openai azure-identity

Il comando installa entrambi i pacchetti nell'ambiente di Python attivo.

Creare una risposta con Microsoft Entra ID

Usare DefaultAzureCredential e get_bearer_token_provider per eseguire l'autenticazione senza archiviare una chiave API. Il provider di token aggiorna il token di accesso quando necessario.

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI

endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
openai = OpenAI(base_url=endpoint, api_key=token_provider)

response = openai.responses.create(
    model="gpt-5-mini",
    input="Explain the purpose of an API in one sentence.",
)
print(response.output_text)

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Riferimento: OpenAI client e get_bearer_token_provider

Creare una risposta con una chiave API

Le chiavi API non sono consigliate per l'uso in produzione. Archiviare la chiave nella AZURE_OPENAI_API_KEY variabile di ambiente anziché inserirla nel codice sorgente.

export AZURE_OPENAI_API_KEY="<your-api-key>"

Creare quindi il client e la richiesta:

import os
from openai import OpenAI

endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
api_key = os.environ["AZURE_OPENAI_API_KEY"]
openai = OpenAI(base_url=endpoint, api_key=api_key)

response = openai.responses.create(
    model="gpt-5-mini",
    input="Explain the purpose of an API in one sentence.",
)
print(response.output_text)

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: responses.create

Usare i completamenti della chat

Per le nuove applicazioni, usare l'API Risposte. Usare i completamenti della chat quando è necessaria l'interfaccia basata su messaggi o se si gestisce un'applicazione esistente.

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI

endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
openai = OpenAI(base_url=endpoint, api_key=token_provider)

completion = openai.chat.completions.create(
    model="gpt-5-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain the purpose of an API."},
    ],
)
print(completion.choices[0].message.content)

L'output seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: chat.completions.create

Trasmettere una risposta

Impostare su streamTruee elaborare gli eventi delta del testo durante la generazione del modello:

import os
from openai import OpenAI

endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
openai = OpenAI(
    base_url=endpoint,
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
)

# Stream text as the model generates it.
stream = openai.responses.create(
    model="gpt-5-mini",
    input="Explain the purpose of an API in one sentence.",
    stream=True,
)
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

L'output trasmesso seguente è rappresentativo. La formulazione esatta può variare:

An API allows software applications to communicate and exchange data through a defined set of rules.

Informazioni di riferimento: responses.create streaming

Gestire errori e ripetizioni

L'SDK ritenta automaticamente errori di connessione, timeout, HTTP 408, 409, 429 e risposte 5xx due volte con backoff esponenziale. Impostare max_retries sul OpenAI client per modificare questo comportamento. Catch openai.APIStatusError per esaminare lo stato HTTP, l'ID richiesta e la risposta per una richiesta non riuscita.

L'esempio seguente imposta quattro tentativi e registra l'ID richiesta per le richieste riuscite e non riuscite:

import os
import openai as openai_sdk
from openai import OpenAI

endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
openai = OpenAI(
    base_url=endpoint,
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    max_retries=4,
)

try:
    # Send the request and record its request ID.
    response = openai.responses.create(
        model="gpt-5-mini",
        input="Explain the purpose of an API in one sentence.",
    )
    print(response.output_text)
    print(f"Request ID: {response._request_id}")
except openai_sdk.APIStatusError as error:
    print(f"Status: {error.status_code}; Request ID: {error.request_id}")
    raise

Per una richiesta con esito positivo, l'output seguente è rappresentativo. Il testo della risposta e l'ID richiesta variano:

An API allows software applications to communicate and exchange data through a defined set of rules.
Request ID: <request-id>

Riferimento: ID richiesta, errori e tentativi

Altri esempi di SDK

• Usare l'API Risposte
• Generare incorporamenti
• Analizzare le immagini
• Ottimizzare un modello