obsługa języka zestawu SDK platformy Azure OpenAI

Kod | źródłowyPakiet | Powierzchnia interfejsu API

Przykłady zostały przetestowane przy użyciu OpenAI wersji 2.12.0, Azure.Identity 1.21.0 i .NET 8. Pakiet OpenAI jest również przeznaczony dla wersji .NET Standard 2.0 i nowszych .NET.

Instalowanie pakietów

Zainstaluj pakiety OpenAI i Azure Identity:

dotnet add package OpenAI
dotnet add package Azure.Identity

Polecenia dodają oba odwołania do pakietu do projektu.

Tworzenie odpowiedzi za pomocą Microsoft Entra ID

Użyj polecenia DefaultAzureCredential i BearerTokenPolicy , aby uwierzytelnić się bez przechowywania klucza interfejsu 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());

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: ResponsesClient

Tworzenie odpowiedzi przy użyciu klucza interfejsu API

Klucze interfejsu API nie są zalecane do użytku produkcyjnego. Zapisz klucz w zmiennej środowiskowej AZURE_OPENAI_API_KEY zamiast umieszczać go w kodzie źródłowym.

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

Następnie utwórz klienta i zażądaj:

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: CreateResponseAsync

Korzystanie z uzupełniania czatu

W przypadku nowych aplikacji użyj interfejsu API odpowiedzi. Użyj uzupełniania czatów, gdy potrzebujesz interfejsu opartego na komunikatach lub utrzymuje istniejącą aplikację.

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: ChatClient

Streamuj odpowiedź

Wywoływanie CreateResponseStreamingAsync i przetwarzanie aktualizacji różnicowych tekstu podczas generowania przez model:

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

Następujące dane wyjściowe przesyłane strumieniowo są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: CreateResponseStreamingAsync

Obsługa błędów i ponownych prób

Klient automatycznie ponawia próby HTTP 408, 429, 500, 502, 503 i 504 odpowiedzi z wykładniczym wycofywaniem. Skonfiguruj zasady ponawiania za pomocą opcji klienta, gdy potrzebujesz innego zachowania. Przechwyć ClientResultException , aby sprawdzić stan HTTP i szczegóły błędu dla żądania, które zakończyło się niepowodzeniem.

W przypadku diagnostyki zachowaj zwrócony ClientResult<T> przez operację i sprawdź nieprzetworzone nagłówki odpowiedzi. Nieudane operacje uwidaczniają informacje o stanie za pośrednictwem programu ClientResultException.

Dokumentacja: Obsługa błędów i szczegóły wyniku klienta

Więcej przykładów zestawu SDK

• Korzystanie z interfejsu API odpowiedzi
• Generowanie osadzania
• Analizowanie obrazów
• Dopasowanie modelu

Kod | źródłowyPakiet | Dokumentacja | Dokumentacja interfejsu API języka Go

Przykłady wymagają języka Go 1.25 lub nowszego. Zostały przetestowane z wersjami github.com/openai/openai-go/v3 3.44.0 i azidentity 1.14.0.

Instalowanie modułów

Zainstaluj moduły OpenAI i Azure Identity:

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

Sufiks /v3 jest wymagany, ponieważ identyfikuje bieżącą wersję główną modułu Go.

Tworzenie odpowiedzi za pomocą Microsoft Entra ID

Użyj DefaultAzureCredential opcji uwierzytelniania Azure, aby uwierzytelnić się bez przechowywania klucza interfejsu 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())
}

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: ResponseService.New i WithTokenCredentialScopes

Tworzenie odpowiedzi przy użyciu klucza interfejsu API

Klucze interfejsu API nie są zalecane do użytku produkcyjnego. Zapisz klucz w zmiennej środowiskowej AZURE_OPENAI_API_KEY zamiast umieszczać go w kodzie źródłowym.

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

Następnie utwórz klienta i zażądaj:

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: Responses.New

Korzystanie z uzupełniania czatu

W przypadku nowych aplikacji użyj interfejsu API odpowiedzi. Użyj uzupełniania czatów, gdy potrzebujesz interfejsu opartego na komunikatach lub utrzymuje istniejącą aplikację.

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: Chat.Completions.New

Streamuj odpowiedź

Wywołaj Responses.NewStreamingzdarzenia różnicowe tekstu , a następnie przetwórz zdarzenia różnicowe, gdy model je generuje:

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

Następujące dane wyjściowe przesyłane strumieniowo są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: Responses.NewStreaming

Obsługa błędów i ponownych prób

Zestaw SDK ponawia próby błędów połączenia i http 408, 409, 429 i 5xx odpowiedzi dwa razy z wykładniczym wycofywaniem. Użyj option.WithMaxRetries polecenia , aby zmienić wartość domyślną. Sprawdź zwrócone error przed odczytaniem odpowiedzi i użyj polecenia errors.As , aby sprawdzić openai.Errorelement .

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

W przypadku pomyślnego żądania następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: Błędy i ponawianie prób

Więcej przykładów zestawu SDK

• Korzystanie z interfejsu API odpowiedzi
• Generowanie osadzania
• Analizowanie obrazów
• Dopasowanie modelu

Kod | źródłowyPakiet | Dokumentacja | Dokumentacja interfejsu API Java

Przykłady wymagają Java 8 lub nowszych. Zostały przetestowane z wersjami openai-java 4.43.0 i azure-identity 1.18.4.

Instalowanie pakietów

Maven

Dodaj zależności openAI i Azure Identity do projektu 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>

Narzędzie Maven rozwiązuje pakiety i ich przechodnie zależności podczas kompilowanie projektu.

Gradle

Dodaj te same pakiety do dependencies bloku w pliku kompilacji narzędzia Gradle:

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

Narzędzie Gradle rozpoznaje pakiety podczas kompilowanie projektu.

Tworzenie odpowiedzi za pomocą Microsoft Entra ID

Użyj polecenia DefaultAzureCredential i BearerTokenCredential , aby uwierzytelnić się bez przechowywania klucza interfejsu 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()));
    }
}

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: AzureEntraIdExample i ResponsesExample

Tworzenie odpowiedzi przy użyciu klucza interfejsu API

Nie używaj kluczy interfejsu API do produkcji. Zapisz klucz w zmiennej środowiskowej AZURE_OPENAI_API_KEY zamiast umieszczać go w kodzie źródłowym.

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

Następnie utwórz klienta i zażądaj:

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: OpenAIOkHttpClient

Korzystanie z uzupełniania czatu

W przypadku nowych aplikacji użyj interfejsu API odpowiedzi. Użyj uzupełniania czatów, gdy potrzebujesz interfejsu opartego na komunikatach lub utrzymuje istniejącą aplikację.

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: ChatCompletionCreateParams

Streamuj odpowiedź

Wywołaj createStreamingzdarzenia różnicowe tekstu , a następnie przetwórz zdarzenia różnicowe, gdy model je generuje:

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

Następujące dane wyjściowe przesyłane strumieniowo są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: responses.createStreaming

Obsługa błędów i ponownych prób

Zestaw SDK ponawia próby błędów połączenia i http 408, 409, 429 i 5xx odpowiedzi dwa razy z wykładniczym wycofywaniem. Przechwyć OpenAIServiceException , aby sprawdzić stan HTTP i szczegóły błędu odpowiedzi usługi i przechwytywać OpenAIException inne błędy zestawu SDK.

Wywołaj maxRetries polecenie , OpenAIOkHttpClient.builder() aby zmienić wartość domyślną. Zachowaj wyjątek usługi, aby aplikacja mogła rejestrować jego stan i żądać metadanych.

Dokumentacja: Obsługa błędów i ponawianie prób

Więcej przykładów zestawu SDK

• Korzystanie z interfejsu API odpowiedzi
• Generowanie osadzania
• Analizowanie obrazów
• Dopasowanie modelu

Kod | źródłowyPakiet | Dokumentacja | wskazówki dotyczące platformy Azure OpenAI w wersji 1

Przykłady wymagają Node.js 20 lub nowszych. Zostały przetestowane z wersjami openai 6.46.0 i @azure/identity 4.13.1. Użyj openai wersji 5.18.0 lub nowszej, gdy przekażesz dostawcę tokenu Microsoft Entra jako apiKey.

Instalowanie pakietów

Zainstaluj pakiety OpenAI i Azure Identity:

npm install openai @azure/identity

Polecenie dodaje oba pakiety do projektu.

Tworzenie odpowiedzi za pomocą Microsoft Entra ID

Użyj polecenia DefaultAzureCredential i getBearerTokenProvider , aby uwierzytelnić się bez przechowywania klucza interfejsu API. Dostawca tokenu odświeża token dostępu w razie potrzeby.

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: OpenAI uwierzytelnianie klienta i Azure OpenAI w wersji 1

Tworzenie odpowiedzi przy użyciu klucza interfejsu API

Klucze interfejsu API nie są zalecane do użytku produkcyjnego. Zapisz klucz w zmiennej środowiskowej AZURE_OPENAI_API_KEY zamiast umieszczać go w kodzie źródłowym.

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

Następnie utwórz klienta i zażądaj:

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: responses.create

Korzystanie z uzupełniania czatu

W przypadku nowych aplikacji użyj interfejsu API odpowiedzi. Użyj uzupełniania czatów, gdy potrzebujesz interfejsu opartego na komunikatach lub utrzymuje istniejącą aplikację.

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

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Przechowywanie messages wewnątrz żądania zapewnia kontekstowe wpisywanie wymagane dla role wartości. Jeśli zdefiniujesz tablicę oddzielnie, zadeklaruj ją jako OpenAI.Chat.ChatCompletionMessageParam[].

Odwołanie: chat.completions.create

Streamuj odpowiedź

Ustaw stream wartość truena , i przetwarzaj zdarzenia różnicowe tekstu podczas generowania przez model:

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

Następujące dane wyjściowe przesyłane strumieniowo są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: responses.create przesyłanie strumieniowe

Obsługa błędów i ponownych prób

Zestaw SDK automatycznie ponawia próby błędów połączenia, limitów czasu, HTTP 408, 409, 429 i 5xx odpowiedzi dwa razy z wykładniczym wycofywaniem. Ustaw maxRetries na kliencie OpenAI , aby zmienić to zachowanie. Przechwyć APIError , aby sprawdzić stan HTTP, identyfikator żądania i szczegóły błędu dla żądania, które zakończyło się niepowodzeniem.

W poniższym przykładzie ustawiono cztery ponawianie prób i rejestruje identyfikator żądania dla żądań zakończonych powodzeniem i niepowodzeniem:

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

W przypadku pomyślnego żądania następujące dane wyjściowe są reprezentatywne. Tekst odpowiedzi i identyfikator żądania różnią się:

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

Odwołanie: identyfikatory żądań, błędy i ponawianie prób

Więcej przykładów zestawu SDK

• Korzystanie z interfejsu API odpowiedzi
• Generowanie osadzania
• Analizowanie obrazów
• Dopasowanie modelu

Kod | źródłowyPakiet | Dokumentacja interfejsu API

Przykłady wymagają Python 3.9 lub nowszej. Zostały przetestowane z wersjami openai 2.46.0 i azure-identity 1.25.3. Użyj openai wersji 1.106.0 lub nowszej, gdy przekażesz dostawcę tokenu Microsoft Entra jako api_key.

Instalowanie pakietów

Zainstaluj pakiety OpenAI i Azure Identity:

pip install openai azure-identity

Polecenie instaluje oba pakiety w aktywnym środowisku Python.

Tworzenie odpowiedzi za pomocą Microsoft Entra ID

Użyj polecenia DefaultAzureCredential i get_bearer_token_provider , aby uwierzytelnić się bez przechowywania klucza interfejsu API. Dostawca tokenu odświeża token dostępu w razie potrzeby.

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)

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: OpenAI klient i get_bearer_token_provider

Tworzenie odpowiedzi przy użyciu klucza interfejsu API

Klucze interfejsu API nie są zalecane do użytku produkcyjnego. Zapisz klucz w zmiennej środowiskowej AZURE_OPENAI_API_KEY zamiast umieszczać go w kodzie źródłowym.

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

Następnie utwórz klienta i zażądaj:

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)

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: responses.create

Korzystanie z uzupełniania czatu

W przypadku nowych aplikacji użyj interfejsu API odpowiedzi. Użyj uzupełniania czatów, gdy potrzebujesz interfejsu opartego na komunikatach lub utrzymuje istniejącą aplikację.

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)

Następujące dane wyjściowe są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Odwołanie: chat.completions.create

Streamuj odpowiedź

Ustaw stream wartość Truena , i przetwarzaj zdarzenia różnicowe tekstu podczas generowania przez model:

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)

Następujące dane wyjściowe przesyłane strumieniowo są reprezentatywne. Dokładne sformułowanie może się różnić:

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

Dokumentacja: responses.create przesyłanie strumieniowe

Obsługa błędów i ponownych prób

Zestaw SDK automatycznie ponawia próby błędów połączenia, limitów czasu, HTTP 408, 409, 429 i 5xx odpowiedzi dwa razy z wykładniczym wycofywaniem. Ustaw max_retries na kliencie OpenAI , aby zmienić to zachowanie. Przechwyć openai.APIStatusError , aby sprawdzić stan HTTP, identyfikator żądania i odpowiedź na żądanie, które zakończyło się niepowodzeniem.

W poniższym przykładzie ustawiono cztery ponawianie prób i rejestruje identyfikator żądania dla żądań zakończonych powodzeniem i niepowodzeniem:

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

W przypadku pomyślnego żądania następujące dane wyjściowe są reprezentatywne. Tekst odpowiedzi i identyfikator żądania różnią się:

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

Odwołanie: identyfikatory żądań, błędy i ponawianie prób

Więcej przykładów zestawu SDK

• Korzystanie z interfejsu API odpowiedzi
• Generowanie osadzania
• Analizowanie obrazów
• Dopasowanie modelu