compatibilidad con el lenguaje del SDK de OpenAI Azure

Use los SDK de OpenAI con el punto de conexión de OpenAI v1 de Azure para compilar aplicaciones de inferencia de modelos en Python, C#, JavaScript, Java o Go. En los ejemplos se usa la API de respuestas para nuevas aplicaciones y se muestran finalizaciones de chat para aplicaciones que siguen usando su interfaz basada en mensajes.

Requisitos previos

  • Una suscripción a Azure. Cree uno gratis si no tiene uno.
  • Un recurso de OpenAI Azure con una gpt-5-mini implementación de modelo.
  • El punto de conexión de recursos de OpenAI de Azure, como https://YOUR-RESOURCE-NAME.openai.azure.com.
  • Para Microsoft Entra ID autenticación, una identidad que tiene permiso para ejecutar la inferencia. Para ver las opciones de rol, consulte Configuración de la autenticación de Microsoft Entra ID.
  • Para la autenticación de clave de API, una clave de recurso de OpenAI Azure. Microsoft Entra ID se recomienda para aplicaciones de producción.
  • Administrador de paquetes y tiempo de ejecución de idioma admitidos para el idioma que seleccione.

El model valor de cada solicitud es el nombre de implementación del modelo Azure. Los ejemplos usan gpt-5-mini; reemplácelo si la implementación tiene un nombre diferente.

Código | fuentePaquete | Superficie de API

Los ejemplos se probaron con OpenAI 2.12.0, Azure.Identity 1.21.0 y .NET 8. El paquete OpenAI también tiene como destino .NET versiones estándar 2.0 y posteriores .NET.

Instalación de los paquetes

Instale los paquetes OpenAI y Azure Identity:

dotnet add package OpenAI
dotnet add package Azure.Identity

Los comandos agregan ambas referencias de paquete al proyecto.

Creación de una respuesta con Microsoft Entra ID

Use DefaultAzureCredential y BearerTokenPolicy para autenticarse sin almacenar una clave de 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());

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: ResponsesClient

Creación de una respuesta con una clave de API

Las claves de API no se recomiendan para su uso en producción. Almacene la clave en la AZURE_OPENAI_API_KEY variable de entorno en lugar de colocarla en el código fuente.

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

A continuación, cree el cliente y la solicitud:

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: CreateResponseAsync

Usar finalizaciones de chat

En el caso de las nuevas aplicaciones, use la API de respuestas. Use Finalizaciones de chat cuando necesite su interfaz basada en mensajes o mantenga una aplicación existente.

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: ChatClient

Transmisión de una respuesta

Llamar CreateResponseStreamingAsync y procesar actualizaciones diferenciales de texto a medida que el modelo las 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);
    }
}

La salida en secuencia siguiente es representativa. La redacción exacta puede variar:

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

Referencia: CreateResponseStreamingAsync

Control de errores y reintentos

El cliente reintenta automáticamente las respuestas HTTP 408, 429, 500, 502, 503 y 504 con retroceso exponencial. Configure la directiva de reintento a través de las opciones de cliente cuando necesite un comportamiento diferente. Captura ClientResultException para inspeccionar el estado HTTP y los detalles de error de una solicitud con error.

Para los diagnósticos, conserve el ClientResult<T> devuelto por una operación e inspeccione sus encabezados de respuesta sin procesar. Las operaciones con errores exponen información de estado a través de ClientResultException.

Referencia: Detalles del resultado del cliente y control de errores

Más ejemplos de SDK

Código | fuentePaquete | Referencia de | la API RESTReferencia de la API de Go

Los ejemplos requieren Go 1.25 o posterior. Se probaron con github.com/openai/openai-go/v3 3.44.0 y azidentity 1.14.0.

Instalación de los módulos

Instale los módulos OpenAI y Azure Identity:

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

El /v3 sufijo es necesario porque identifica la versión principal actual del módulo Go.

Creación de una respuesta con Microsoft Entra ID

Use DefaultAzureCredential y la opción de autenticación Azure para autenticarse sin almacenar una clave de 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())
}

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: ResponseService.New y WithTokenCredentialScopes

Creación de una respuesta con una clave de API

Las claves de API no se recomiendan para su uso en producción. Almacene la clave en la AZURE_OPENAI_API_KEY variable de entorno en lugar de colocarla en el código fuente.

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

A continuación, cree el cliente y la solicitud:

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: Responses.New

Usar finalizaciones de chat

En el caso de las nuevas aplicaciones, use la API de respuestas. Use Finalizaciones de chat cuando necesite su interfaz basada en mensajes o mantenga una aplicación existente.

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: Chat.Completions.New

Transmisión de una respuesta

Llame a Responses.NewStreamingy procese eventos delta de texto a medida que el modelo los 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) }
}

La salida en secuencia siguiente es representativa. La redacción exacta puede variar:

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

Referencia: Responses.NewStreaming

Control de errores y reintentos

El SDK reintenta los errores de conexión y las respuestas HTTP 408, 409, 429 y 5xx dos veces con retroceso exponencial. Use option.WithMaxRetries para cambiar el valor predeterminado. Compruebe el devuelto error antes de leer una respuesta y úselo errors.As para inspeccionar un 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())
}

Para una solicitud correcta, la salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: Errores y reintentos

Más ejemplos de SDK

Código | fuentePaquete | Referencia de | la API RESTReferencia de api de Java

Los ejemplos requieren Java 8 o posterior. Se probaron con openai-java 4.43.0 y azure-identity 1.18.4.

Instalación de los paquetes

Maven

Agregue las dependencias openAI y Azure Identity al proyecto de 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 resuelve los paquetes y sus dependencias transitivas al compilar el proyecto.

Gradle

Agregue los mismos paquetes al bloque en el dependencies archivo de compilación de Gradle:

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

Gradle resuelve los paquetes al compilar el proyecto.

Creación de una respuesta con Microsoft Entra ID

Use DefaultAzureCredential y BearerTokenCredential para autenticarse sin almacenar una clave de 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()));
    }
}

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: AzureEntraIdExample y ResponsesExample

Creación de una respuesta con una clave de API

No use claves de API para producción. Almacene la clave en la AZURE_OPENAI_API_KEY variable de entorno en lugar de colocarla en el código fuente.

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

A continuación, cree el cliente y la solicitud:

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: OpenAIOkHttpClient

Usar finalizaciones de chat

En el caso de las nuevas aplicaciones, use la API de respuestas. Use Finalizaciones de chat cuando necesite su interfaz basada en mensajes o mantenga una aplicación existente.

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: ChatCompletionCreateParams

Transmisión de una respuesta

Llame a createStreamingy procese eventos delta de texto a medida que el modelo los 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()));
        }
    }
}

La salida en secuencia siguiente es representativa. La redacción exacta puede variar:

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

Referencia: responses.createStreaming

Control de errores y reintentos

El SDK reintenta los errores de conexión y las respuestas HTTP 408, 409, 429 y 5xx dos veces con retroceso exponencial. Detectar OpenAIServiceException para inspeccionar el estado HTTP y los detalles de error de una respuesta de servicio y detectar OpenAIException otros errores del SDK.

Llame maxRetries a on OpenAIOkHttpClient.builder() para cambiar el valor predeterminado. Conserve la excepción de servicio para que la aplicación pueda registrar su estado y solicitar metadatos.

Referencia: Control de errores y reintentos

Más ejemplos de SDK

Código | fuentePaquete | Referencia de | la API RESTGuía de Azure OpenAI v1

Los ejemplos requieren Node.js 20 o posterior. Se probaron con openai 6.46.0 y @azure/identity 4.13.1. Use openai 5.18.0 o posterior cuando pase un proveedor de tokens de Microsoft Entra como apiKey.

Instalación de los paquetes

Instale los paquetes OpenAI y Azure Identity:

npm install openai @azure/identity

El comando agrega ambos paquetes al proyecto.

Creación de una respuesta con Microsoft Entra ID

Use DefaultAzureCredential y getBearerTokenProvider para autenticarse sin almacenar una clave de API. El proveedor de tokens actualiza el token de acceso cuando sea necesario.

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: OpenAI autenticación de cliente y Azure OpenAI v1

Creación de una respuesta con una clave de API

Las claves de API no se recomiendan para su uso en producción. Almacene la clave en la AZURE_OPENAI_API_KEY variable de entorno en lugar de colocarla en el código fuente.

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

A continuación, cree el cliente y la solicitud:

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: responses.create

Usar finalizaciones de chat

En el caso de las nuevas aplicaciones, use la API de respuestas. Use Finalizaciones de chat cuando necesite su interfaz basada en mensajes o mantenga una aplicación existente.

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

La salida siguiente es representativa. La redacción exacta puede variar:

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

Mantener dentro de messages la solicitud proporciona la escritura contextual necesaria para los role valores. Si define la matriz por separado, declárela como OpenAI.Chat.ChatCompletionMessageParam[].

Referencia: chat.completions.create

Transmisión de una respuesta

Establezca en streamtruey procese eventos delta de texto a medida que el modelo los genera:

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

La salida en secuencia siguiente es representativa. La redacción exacta puede variar:

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

Referencia: responses.create streaming

Control de errores y reintentos

El SDK reintenta automáticamente errores de conexión, tiempos de espera, HTTP 408, 409, 429 y 5xx respuestas dos veces con retroceso exponencial. Establezca maxRetries en el OpenAI cliente para cambiar este comportamiento. Capture APIError para inspeccionar el estado HTTP, el identificador de solicitud y los detalles de error de una solicitud con error.

En el ejemplo siguiente se establecen cuatro reintentos y se registra el identificador de solicitud para las solicitudes correctas y con errores:

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

Para una solicitud correcta, la salida siguiente es representativa. El texto de respuesta y el identificador de solicitud varían:

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

Referencia: Identificadores de solicitud, errores y reintentos

Más ejemplos de SDK

Código | fuentePaquete | Referencia de API

Los ejemplos requieren Python 3.9 o posterior. Se probaron con openai 2.46.0 y azure-identity 1.25.3. Use openai 1.106.0 o posterior cuando pase un proveedor de tokens de Microsoft Entra como api_key.

Instalación de los paquetes

Instale los paquetes OpenAI y Azure Identity:

pip install openai azure-identity

El comando instala ambos paquetes en el entorno de Python activo.

Creación de una respuesta con Microsoft Entra ID

Use DefaultAzureCredential y get_bearer_token_provider para autenticarse sin almacenar una clave de API. El proveedor de tokens actualiza el token de acceso cuando sea necesario.

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)

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: OpenAI cliente y get_bearer_token_provider

Creación de una respuesta con una clave de API

Las claves de API no se recomiendan para su uso en producción. Almacene la clave en la AZURE_OPENAI_API_KEY variable de entorno en lugar de colocarla en el código fuente.

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

A continuación, cree el cliente y la solicitud:

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)

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: responses.create

Usar finalizaciones de chat

En el caso de las nuevas aplicaciones, use la API de respuestas. Use Finalizaciones de chat cuando necesite su interfaz basada en mensajes o mantenga una aplicación existente.

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)

La salida siguiente es representativa. La redacción exacta puede variar:

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

Referencia: chat.completions.create

Transmisión de una respuesta

Establezca en streamTruey procese eventos delta de texto a medida que el modelo los genera:

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)

La salida en secuencia siguiente es representativa. La redacción exacta puede variar:

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

Referencia: responses.create streaming

Control de errores y reintentos

El SDK reintenta automáticamente errores de conexión, tiempos de espera, HTTP 408, 409, 429 y 5xx respuestas dos veces con retroceso exponencial. Establezca max_retries en el OpenAI cliente para cambiar este comportamiento. Catch openai.APIStatusError para inspeccionar el estado HTTP, el identificador de solicitud y la respuesta de una solicitud con error.

En el ejemplo siguiente se establecen cuatro reintentos y se registra el identificador de solicitud para las solicitudes correctas y con errores:

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

Para una solicitud correcta, la salida siguiente es representativa. El texto de respuesta y el identificador de solicitud varían:

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

Referencia: Identificadores de solicitud, errores y reintentos

Más ejemplos de SDK

Solución de problemas

  • Para una 401 respuesta o 403 , confirme que la identidad o la clave de API deseadas pueden acceder al recurso de OpenAI de Azure.
  • Para obtener una 404 respuesta, confirme que la dirección URL base termina en /openai/v1/ y que model contiene un nombre de implementación válido.
  • Para un paquete o error de tipo, actualice el SDK y compare la versión instalada con la versión probada en esta página.
  • Para ver un error de parámetro de modelo, compruebe si el modelo implementado admite el parámetro . La compatibilidad con parámetros puede diferir entre las familias de modelos.

Contenido relacionado

  • Last updated on