Az Azure OpenAI által támogatott programozási nyelvek

Cikk
02/25/2025

A .NET-hez készült Azure OpenAI ügyfélkódtár a .NET-hez készült hivatalos OpenAI-ügyfélkódtár társa. Az Azure OpenAI-kódtár konfigurálja az ügyfelet az Azure OpenAI-hoz való használatra, és extra erősen gépelt bővítménytámogatást biztosít az Azure OpenAI-forgatókönyvekre jellemző kérés- és válaszmodellekhez.

Stabil kiadás:

Forráskódcsomag (NuGet) | Csomagreferenciák dokumentációja API-referenciadokumentáció minták | |

Előzetes kiadás:

Az előzetes kiadás hozzáféréssel rendelkezik a legújabb funkciókhoz.

Forráskódcsomag (NuGet) | API-referenciadokumentáció | Csomagreferenciák dokumentációja Minták |

Az Azure OpenAI API verziótámogatása

A Pythonhoz és JavaScripthez készült Azure OpenAI ügyfélkódtárakkal ellentétben az Azure OpenAI .NET-csomag az Azure OpenAI API-verziók egy adott részhalmazára korlátozódik. Általában minden Azure OpenAI .NET-csomag feloldja az Azure OpenAI API újabb kiadási funkcióihoz való hozzáférést. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.

A verzióválasztást az AzureOpenAIClientOptions.ServiceVersion enumerálás szabályozza.

A stabil kiadás jelenleg a következő célokat célozza:

2024-06-01

Az előzetes kiadás jelenleg a következő célokat célozhatja meg:

2024-06-01
2024-08-01-preview
2024-09-01-preview
2024-10-01-preview

Telepítés

dotnet add package Azure.AI.OpenAI --prerelease

A Azure.AI.OpenAI csomag a hivatalos OpenAI-csomagra épül, amely függőségként szerepel.

Hitelesítés

Az Azure OpenAI vagy az OpenAI használatához hozzon létre egy példányt az alábbi módszerek egyikével AzureOpenAIClient :

Microsoft Entra ID
API-kulcs

A biztonságos, kulcs nélküli hitelesítési módszer a Microsoft Entra ID (korábbi nevén Azure Active Directory) használata az Azure Identity-kódtáron keresztül. A kódtár használata:

dotnet add package Azure.Identity

Használja a tárból a kívánt hitelesítőadat-típust. Például DefaultAzureCredential:

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-mini-deployment");

Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.

string keyFromEnvironment = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new ApiKeyCredential(keyFromEnvironment));
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-35-turbo-deployment");

Hang

AzureOpenAIClient.GetAudioClient

Transzkripció

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());

AudioClient client = openAIClient.GetAudioClient("whisper");

string audioFilePath = Path.Combine("Assets", "speech.mp3");

AudioTranscriptionOptions options = new()
{
    ResponseFormat = AudioTranscriptionFormat.Verbose,
    TimestampGranularities = AudioTimestampGranularities.Word | AudioTimestampGranularities.Segment,
};

AudioTranscription transcription = client.TranscribeAudio(audioFilePath, options);

Console.WriteLine("Transcription:");
Console.WriteLine($"{transcription.Text}");

Console.WriteLine();
Console.WriteLine($"Words:");
foreach (TranscribedWord word in transcription.Words)
{
    Console.WriteLine($"  {word.Word,15} : {word.StartTime.TotalMilliseconds,5:0} - {word.EndTime.TotalMilliseconds,5:0}");
}

Console.WriteLine();
Console.WriteLine($"Segments:");
foreach (TranscribedSegment segment in transcription.Segments)
{
    Console.WriteLine($"  {segment.Text,90} : {segment.StartTime.TotalMilliseconds,5:0} - {segment.EndTime.TotalMilliseconds,5:0}");
}

Szövegfelolvasás (TTS)

using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Audio;

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());

AudioClient client = openAIClient.GetAudioClient("tts-hd"); //Replace with your Azure OpenAI model deployment

string input = "Testing, testing, 1, 2, 3";

BinaryData speech = client.GenerateSpeech(input, GeneratedSpeechVoice.Alloy);

using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.mp3");
speech.ToStream().CopyTo(stream);

Csevegés

AzureOpenAIClient.GetChatClient

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-deployment");

ChatCompletion completion = chatClient.CompleteChat(
    [
        // System messages represent instructions or other guidance about how the assistant should behave
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        // User messages represent user input, whether historical or the most recent input
        new UserChatMessage("Hi, can you help me?"),
        // Assistant messages in a request represent conversation history for responses
        new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
        new UserChatMessage("What's the best way to train a parrot?"),
    ]);

Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");

Csevegőüzenetek streamelése

A streamelt csevegések befejezései a és a CompleteChatStreaming metódust használják, amelyek egy ResultCollection<StreamingChatCompletionUpdate> vagy AsyncCollectionResult<StreamingChatCompletionUpdate> több elemet adnak ClientResult<ChatCompletion>CompleteChatStreamingAsync vissza.

Ezek az eredménygyűjtemények a foreach használatával iterálhatók, vagy várhatók a foreachra, és minden frissítés megérkezik, amint új adatok érhetők el a streamelt válaszból.

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-deployment");

CollectionResult<StreamingChatCompletionUpdate> completionUpdates = chatClient.CompleteChatStreaming(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Hi, can you help me?"),
        new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
        new UserChatMessage("What's the best way to train a parrot?"),
    ]);

foreach (StreamingChatCompletionUpdate completionUpdate in completionUpdates)
{
    foreach (ChatMessageContentPart contentPart in completionUpdate.ContentUpdate)
    {
        Console.Write(contentPart.Text);
    }
}

Beágyazások

AzureOpenAIClient.GetEmbeddingClient

using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Embeddings;

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());

EmbeddingClient client = openAIClient.GetEmbeddingClient("text-embedding-3-large"); //Replace with your model deployment name

string description = "This is a test embedding";

OpenAIEmbedding embedding = client.GenerateEmbedding(description);
ReadOnlyMemory<float> vector = embedding.ToFloats();

Console.WriteLine(string.Join(", ", vector.ToArray()));

Finomhangolás

Az Azure OpenAI .NET-csomagok jelenleg nem támogatottak.

Batch

Az Azure OpenAI .NET-csomagok jelenleg nem támogatottak.

Képek

AzureOpenAIClient.GetImageClient

using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Images;

AzureOpenAIClient openAIClient = new(
    new Uri("https://your-azure-openai-resource.com"),
    new DefaultAzureCredential());

ImageClient client = openAIClient.GetImageClient("dall-e-3"); // replace with your model deployment name.

string prompt = "A rabbit eating pancakes.";

ImageGenerationOptions options = new()
{
     Quality = GeneratedImageQuality.High,
     Size = GeneratedImageSize.W1792xH1024,
     Style = GeneratedImageStyle.Vivid,
     ResponseFormat = GeneratedImageFormat.Bytes
};

GeneratedImage image = client.GenerateImage(prompt, options);
BinaryData bytes = image.ImageBytes;

using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.png");
bytes.ToStream().CopyTo(stream);

C# DALL-E rövid útmutató

Befejezések (örökölt)

Az Azure OpenAI .NET-csomagok nem támogatottak.

Hibakezelés

Hibakódok

Állapotkód	Hibatípus
400	`Bad Request Error`
401	`Authentication Error`
403	`Permission Denied Error`
404	`Not Found Error`
422	`Unprocessable Entity Error`
429	`Rate Limit Error`
500	`Internal Server Error`
503	`Service Unavailable`
504	`Gateway Timeout`

Újrapróbálkozások

Az ügyfélosztályok exponenciális visszalépéssel automatikusan újrapróbálkoznak a következő hibákra, akár háromszor is:

408 Kérés időtúllépése
429 – Túl sok kérelem
500 Belső kiszolgálóhiba
502 Hibás átjáró
503 A szolgáltatás nem érhető el
504 Időtúllépés az átjárón

Forráskódcsomag (pkg.go.dev) | API-referenciadokumentáció | Csomagreferenciák dokumentációja Minták |

Az Azure OpenAI API verziótámogatása

A Pythonhoz és JavaScripthez készült Azure OpenAI-ügyfélkódtárakkal ellentétben az Azure OpenAI Go-kódtár egy adott Azure OpenAI API-verzióra van megcélzva. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.

Az Azure OpenAI API aktuális verziócélja: 2024-10-01-preview

Ez a custom_client.go fájlban van definiálva .

Telepítés

Telepítse a modulokat és azidentity a azopenai modulokat a következő lépésekkel:

go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai

# optional
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Az azidentity modul az Azure Active Directory-hitelesítéshez használható az Azure OpenAI-val.

package main

import (
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

func main() {
	dac, err := azidentity.NewDefaultAzureCredential(nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	// NOTE: this constructor creates a client that connects to an Azure OpenAI endpoint.
	// To connect to the public OpenAI endpoint, use azopenai.NewClientForOpenAI
	client, err := azopenai.NewClient("https://<your-azure-openai-host>.openai.azure.com", dac, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	_ = client
}

További információ az Azure OpenAI kulcs nélküli hitelesítéséről: Az Azure OpenAI használata kulcsok nélkül.

package main

import (
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)

func main() {
	keyCredential := azcore.NewKeyCredential("<Azure-OpenAI-APIKey>")

	// NOTE: this constructor creates a client that connects to an Azure OpenAI endpoint.
	// To connect to the public OpenAI endpoint, use azopenai.NewClientForOpenAI
	client, err := azopenai.NewClientWithKeyCredential("https://<your-azure-openai-host>.openai.azure.com", keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	_ = client
}

Hang

Client.GenerateSpeechFromText

ackage main

import (
	"context"
	"fmt"
	"io"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	openAIKey := os.Getenv("OPENAI_API_KEY")

	// Ex: "https://api.openai.com/v1"
	openAIEndpoint := os.Getenv("OPENAI_ENDPOINT")

	modelDeploymentID := "tts-1"

	if openAIKey == "" || openAIEndpoint == "" || modelDeploymentID == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(openAIKey)

	client, err := azopenai.NewClientForOpenAI(openAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	audioResp, err := client.GenerateSpeechFromText(context.Background(), azopenai.SpeechGenerationOptions{
		Input:          to.Ptr("i am a computer"),
		Voice:          to.Ptr(azopenai.SpeechVoiceAlloy),
		ResponseFormat: to.Ptr(azopenai.SpeechGenerationResponseFormatFlac),
		DeploymentName: to.Ptr("tts-1"),
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	defer audioResp.Body.Close()

	audioBytes, err := io.ReadAll(audioResp.Body)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	fmt.Fprintf(os.Stderr, "Got %d bytes of FLAC audio\n", len(audioBytes))

}

Client.GetAudioTranscription

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_WHISPER_API_KEY")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_WHISPER_ENDPOINT")

	modelDeploymentID := os.Getenv("AOAI_WHISPER_MODEL")

	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || modelDeploymentID == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	mp3Bytes, err := os.ReadFile("testdata/sampledata_audiofiles_myVoiceIsMyPassportVerifyMe01.mp3")

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	resp, err := client.GetAudioTranscription(context.TODO(), azopenai.AudioTranscriptionOptions{
		File: mp3Bytes,

		// this will return _just_ the translated text. Other formats are available, which return
		// different or additional metadata. See [azopenai.AudioTranscriptionFormat] for more examples.
		ResponseFormat: to.Ptr(azopenai.AudioTranscriptionFormatText),

		DeploymentName: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	fmt.Fprintf(os.Stderr, "Transcribed text: %s\n", *resp.Text)

}

Csevegés

Client.GetChatCompletions

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_CHAT_COMPLETIONS_API_KEY")
	modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatRequestMessageClassification{
		// You set the tone and rules of the conversation with a prompt as the system role.
		&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate.")},

		// The user asks a question
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},

		// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
		&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},

		// The user answers the question based on the latest reply.
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},

		// from here you'd keep iterating, sending responses back from ChatGPT
	}

	gotReply := false

	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:       messages,
		DeploymentName: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	for _, choice := range resp.Choices {
		gotReply = true

		if choice.ContentFilterResults != nil {
			fmt.Fprintf(os.Stderr, "Content filter results\n")

			if choice.ContentFilterResults.Error != nil {
				fmt.Fprintf(os.Stderr, "  Error:%v\n", choice.ContentFilterResults.Error)
			}

			fmt.Fprintf(os.Stderr, "  Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
			fmt.Fprintf(os.Stderr, "  SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
			fmt.Fprintf(os.Stderr, "  Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
			fmt.Fprintf(os.Stderr, "  Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
		}

		if choice.Message != nil && choice.Message.Content != nil {
			fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
		}

		if choice.FinishReason != nil {
			// this choice's conversation is complete.
			fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
		}
	}

	if gotReply {
		fmt.Fprintf(os.Stderr, "Got chat completions reply\n")
	}

}

Client.GetChatCompletionsStream

package main

import (
	"context"
	"errors"
	"fmt"
	"io"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_CHAT_COMPLETIONS_API_KEY")
	modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatRequestMessageClassification{
		// You set the tone and rules of the conversation with a prompt as the system role.
		&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate and limit your responses to 20 words or less.")},

		// The user asks a question
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},

		// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
		&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},

		// The user answers the question based on the latest reply.
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},

		// from here you'd keep iterating, sending responses back from ChatGPT
	}

	resp, err := client.GetChatCompletionsStream(context.TODO(), azopenai.ChatCompletionsStreamOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:       messages,
		N:              to.Ptr[int32](1),
		DeploymentName: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	defer resp.ChatCompletionsStream.Close()

	gotReply := false

	for {
		chatCompletions, err := resp.ChatCompletionsStream.Read()

		if errors.Is(err, io.EOF) {
			break
		}

		if err != nil {
			//  TODO: Update the following line with your application specific error handling logic
			log.Printf("ERROR: %s", err)
			return
		}

		for _, choice := range chatCompletions.Choices {
			gotReply = true

			text := ""

			if choice.Delta.Content != nil {
				text = *choice.Delta.Content
			}

			role := ""

			if choice.Delta.Role != nil {
				role = string(*choice.Delta.Role)
			}

			fmt.Fprintf(os.Stderr, "Content[%d], role %q: %q\n", *choice.Index, role, text)
		}
	}

	if gotReply {
		fmt.Fprintf(os.Stderr, "Got chat completions streaming reply\n")
	}

}

Beágyazások

Client.GetEmbeddings

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_EMBEDDINGS_API_KEY")
	modelDeploymentID := os.Getenv("AOAI_EMBEDDINGS_MODEL")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_EMBEDDINGS_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	resp, err := client.GetEmbeddings(context.TODO(), azopenai.EmbeddingsOptions{
		Input:          []string{"Testing, testing, 1,2,3."},
		DeploymentName: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	for _, embed := range resp.Data {
		// embed.Embedding contains the embeddings for this input index.
		fmt.Fprintf(os.Stderr, "Got embeddings for input %d\n", *embed.Index)
	}

}

Képgenerálás

Client.GetImageGenerations

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_DALLE_API_KEY")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_DALLE_ENDPOINT")

	azureDeployment := os.Getenv("AOAI_DALLE_MODEL")

	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || azureDeployment == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	resp, err := client.GetImageGenerations(context.TODO(), azopenai.ImageGenerationOptions{
		Prompt:         to.Ptr("a cat"),
		ResponseFormat: to.Ptr(azopenai.ImageGenerationResponseFormatURL),
		DeploymentName: &azureDeployment,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	for _, generatedImage := range resp.Data {
		// the underlying type for the generatedImage is dictated by the value of
		// ImageGenerationOptions.ResponseFormat. In this example we used `azopenai.ImageGenerationResponseFormatURL`,
		// so the underlying type will be ImageLocation.

		resp, err := http.Head(*generatedImage.URL)

		if err != nil {
			// TODO: Update the following line with your application specific error handling logic
			log.Printf("ERROR: %s", err)
			return
		}

		_ = resp.Body.Close()
		fmt.Fprintf(os.Stderr, "Image generated, HEAD request on URL returned %d\n", resp.StatusCode)
	}

}

Befejezések (örökölt)

Client.GetChatCompletions

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AOAI_COMPLETIONS_API_KEY")
	modelDeployment := os.Getenv("AOAI_COMPLETIONS_MODEL")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AOAI_COMPLETIONS_ENDPOINT")

	if azureOpenAIKey == "" || modelDeployment == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	resp, err := client.GetCompletions(context.TODO(), azopenai.CompletionsOptions{
		Prompt:         []string{"What is Azure OpenAI, in 20 words or less"},
		MaxTokens:      to.Ptr(int32(2048)),
		Temperature:    to.Ptr(float32(0.0)),
		DeploymentName: &modelDeployment,
	}, nil)

	if err != nil {
		// TODO: Update the following line with your application specific error handling logic
		log.Printf("ERROR: %s", err)
		return
	}

	for _, choice := range resp.Choices {
		fmt.Fprintf(os.Stderr, "Result: %s\n", *choice.Text)
	}

}

Hibakezelés

A HTTP-kéréseket küldő metódusok akkor térnek vissza *azcore.ResponseError , ha ezek a kérések sikertelenek. ResponseError hibaadatokkal és a szolgáltatás nyers válaszával rendelkezik.

Naplózás

Ez a modul az azcore naplózási implementációt használja. Az összes Azure SDK-modul naplózásának bekapcsolásához állítsa AZURE_SDK_GO_LOGGING az összesre. Alapértelmezés szerint a naplózó a stderrbe ír. A naplókimenet szabályozásához használja az azcore/log csomagot. Például csak HTTP-kérés- és válaszeseményeket naplózhat, és stdoutra nyomtathatja őket:

import azlog "github.com/Azure/azure-sdk-for-go/sdk/azcore/log"

// Print log events to stdout
azlog.SetListener(func(cls azlog.Event, msg string) {
	fmt.Println(msg)
})

// Includes only requests and responses in credential logs
azlog.SetEvents(azlog.EventRequest, azlog.EventResponse)

Forráskód | összetevő (Maven) | API-referenciadokumentáció | csomaghivatkozási dokumentációmintái

Az Azure OpenAI API verziótámogatása

A Pythonhoz és JavaScripthez készült Azure OpenAI ügyfélkódtárakkal ellentétben az Azure OpenAI Java-csomag kompatibilitásának biztosítása érdekében az Azure OpenAI API-verziók egy adott részhalmazára korlátozódik. Általában minden Azure OpenAI Java-csomag feloldja az Azure OpenAI API újabb kiadási funkcióinak elérését. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.

A verzióválasztást az OpenAIServiceVersion enumerálás szabályozza.

Az Azure OpenAI legújabb előzetes API-ja a következő:

-2024-08-01-preview

A legújabb stabil (GA) kiadás támogatott:

-2024-06-01

Telepítés

Csomag részletei

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-openai</artifactId>
    <version>1.0.0-beta.12</version>
</dependency>

Hitelesítés

Az Azure OpenAI szolgáltatással való interakcióhoz létre kell hoznia egy ügyfélosztály-példányt, OpenAIAsyncClient vagy OpenAIClient a használatával OpenAIClientBuilder. Ha konfigurálni szeretne egy ügyfelet az Azure OpenAI-val való használatra, adjon meg érvényes végponti URI-t egy Azure OpenAI-erőforrásnak, valamint egy megfelelő kulcs-hitelesítő adatot, jogkivonat-hitelesítő adatot vagy Azure Identity-hitelesítő adatot, amely jogosult az Azure OpenAI-erőforrás használatára.

Microsoft Entra ID
API-kulcs

A Microsoft Entra-azonosítóval való hitelesítéshez kezdeti beállítás szükséges:

Adja hozzá az Azure Identity-csomagot:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.13.3</version>
</dependency>

A beállítás után kiválaszthatja, hogy milyen típusú hitelesítő azure.identity adatokat használjon. Példaként DefaultAzureCredential használható az ügyfél hitelesítésére: A Microsoft Entra ID alkalmazás ügyfélazonosítójának, bérlőazonosítójának és ügyféltitkának értékeit környezeti változókként állíthatja be: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

Az engedélyezés a DefaultAzureCredential használatával a legegyszerűbb. A rendszer megkeresi a legjobb hitelesítő adatokat a futó környezetben.

TokenCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
    .credential(defaultCredential)
    .endpoint("{endpoint}")
    .buildClient();

További információ az Azure OpenAI kulcs nélküli hitelesítéséről: Az Azure OpenAI használata kulcsok nélkül.

OpenAIClient client = new OpenAIClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildClient();

Aszinkron

OpenAIAsyncClient client = new OpenAIClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildAsyncClient();

Hang

client.getAudioTranscription

String fileName = "{your-file-name}";
Path filePath = Paths.get("{your-file-path}" + fileName);

byte[] file = BinaryData.fromFile(filePath).toBytes();
AudioTranscriptionOptions transcriptionOptions = new AudioTranscriptionOptions(file)
    .setResponseFormat(AudioTranscriptionFormat.JSON);

AudioTranscription transcription = client.getAudioTranscription("{deploymentOrModelName}", fileName, transcriptionOptions);

System.out.println("Transcription: " + transcription.getText());

client.generateSpeechFromText

Szövegfelolvasás (TTS)

String deploymentOrModelId = "{azure-open-ai-deployment-model-id}";
SpeechGenerationOptions options = new SpeechGenerationOptions(
        "Today is a wonderful day to build something people love!",
        SpeechVoice.ALLOY);
BinaryData speech = client.generateSpeechFromText(deploymentOrModelId, options);
// Checkout your generated speech in the file system.
Path path = Paths.get("{your-local-file-path}/speech.wav");
Files.write(path, speech.toBytes());

Csevegés

client.getChatCompletions

List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));

ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
    new ChatCompletionsOptions(chatMessages));

System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
    ChatResponseMessage message = choice.getMessage();
    System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
    System.out.println("Message:");
    System.out.println(message.getContent());
}

Streamelés

List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));

ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
    new ChatCompletionsOptions(chatMessages));

System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
    ChatResponseMessage message = choice.getMessage();
    System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
    System.out.println("Message:");
    System.out.println(message.getContent());
}

Csevegés befejezése képekkel

List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant that describes images"));
chatMessages.add(new ChatRequestUserMessage(Arrays.asList(
        new ChatMessageTextContentItem("Please describe this image"),
        new ChatMessageImageContentItem(
                new ChatMessageImageUrl("https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"))
)));

ChatCompletionsOptions chatCompletionsOptions = new ChatCompletionsOptions(chatMessages);
ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}", chatCompletionsOptions);

System.out.println("Chat completion: " + chatCompletions.getChoices().get(0).getMessage().getContent());

Beágyazások

client.getEmbeddings

EmbeddingsOptions embeddingsOptions = new EmbeddingsOptions(
    Arrays.asList("Your text string goes here"));

Embeddings embeddings = client.getEmbeddings("{deploymentOrModelName}", embeddingsOptions);

for (EmbeddingItem item : embeddings.getData()) {
    System.out.printf("Index: %d.%n", item.getPromptIndex());
    for (Float embedding : item.getEmbedding()) {
        System.out.printf("%f;", embedding);
    }
}

Képgenerálás

ImageGenerationOptions imageGenerationOptions = new ImageGenerationOptions(
    "A drawing of the Seattle skyline in the style of Van Gogh");
ImageGenerations images = client.getImageGenerations("{deploymentOrModelName}", imageGenerationOptions);

for (ImageGenerationData imageGenerationData : images.getData()) {
    System.out.printf(
        "Image location URL that provides temporary access to download the generated image is %s.%n",
        imageGenerationData.getUrl());
}

Hibák kezelése

Ügyfélnaplózás engedélyezése

Az Azure OpenAI-kódtárkal kapcsolatos problémák elhárításához fontos, hogy először engedélyezze a naplózást az alkalmazás viselkedésének monitorozásához. A naplókban szereplő hibák és figyelmeztetések általában hasznos betekintést nyújtanak a hibákba, és időnként korrekciós műveleteket is tartalmaznak a problémák megoldásához. A Java-hoz készült Azure-ügyfélkódtárak két naplózási lehetőséggel rendelkeznek:

Beépített naplózási keretrendszer.
A naplózás támogatása az SLF4J felülettel.

Tekintse meg a jelen referenciadokumentum utasításait a [naplózás konfigurálásához a Java-hoz készült Azure SDK-ban][logging_overview].

HTTP-kérések/válaszok naplózásának engedélyezése

A hibák elhárításához hasznos lehet az Azure OpenAI szolgáltatáson keresztül küldött VAGY a hálózaton keresztül kapott HTTP-kérés vagy válasz áttekintése. A HTTP-kérések és válaszok hasznos adatainak naplózásához az [OpenAIClient][openai_client] konfigurálható az alábbiak szerint. Ha nincs SLF4J Logger az osztályútvonalon, állítson be egy környezeti változót [AZURE_LOG_LEVEL][azure_log_level] a gépen a naplózás engedélyezéséhez.

OpenAIClient openAIClient = new OpenAIClientBuilder()
        .endpoint("{endpoint}")
        .credential(new AzureKeyCredential("{key}"))
        .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
        .buildClient();
// or
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();
OpenAIClient configurationClientAad = new OpenAIClientBuilder()
        .credential(credential)
        .endpoint("{endpoint}")
        .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
        .buildClient();

Másik lehetőségként konfigurálhatja a http-kérések és válaszok naplózását a teljes alkalmazáshoz az alábbi környezeti változó beállításával. Vegye figyelembe, hogy ez a módosítás minden olyan Azure-ügyfél naplózását engedélyezi, amely támogatja a HTTP-kérések/válaszok naplózását.

Környezeti változó neve: AZURE_HTTP_LOG_DETAIL_LEVEL

Érték	Naplózási szint
Nincs	A HTTP-kérések/válaszok naplózása le van tiltva
alapvető	Csak URL-címeket, HTTP-metódusokat és a kérés befejezéséhez szükséges időt naplózza.
Fejlécek	Mindent naplóz a BASIC-ben, valamint az összes kérés- és válaszfejlécet.
törzs	Mindent naplóz a BASIC-ben, valamint az összes kérés- és választörzset.
body_and_headers	Mindent naplóz a FEJLÉCEKBEN és a TÖRZSben.

Feljegyzés

A kérések és válaszok törzsének naplózásakor győződjön meg arról, hogy nem tartalmaznak bizalmas információkat. A fejlécek naplózásakor az ügyféltár alapértelmezett fejléckészlettel rendelkezik, amelyek biztonságosnak tekinthetők, de ez a készlet frissíthető a szerkesztő naplóbeállításainak frissítésével az alábbiak szerint.

clientBuilder.httpLogOptions(new HttpLogOptions().addAllowedHeaderName("safe-to-log-header-name"))

Kivételek hibaelhárítása

Az Azure OpenAI szolgáltatás metódusai hibát jeleznek[HttpResponseException , vagy annak alosztályát. Az HttpResponseException OpenAI ügyfélkódtár által létrehozott részletes válaszhiba-objektum konkrét hasznos elemzéseket nyújt a hiba elhárításához, és korrekciós műveleteket tartalmaz a gyakori problémák megoldásához. Ez a hibainformáció az objektum üzenettulajdonságában HttpResponseException található.

Az alábbi példa azt mutatja be, hogyan foghatja el szinkron ügyféllel

List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));

try {
    ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
            new ChatCompletionsOptions(chatMessages));
} catch (HttpResponseException e) {
    System.out.println(e.getMessage());
    // Do something with the exception
}

Az aszinkron ügyfelekkel a hibavisszahívások kivételeit észlelheti és kezelheti:

asyncClient.getChatCompletions("{deploymentOrModelName}", new ChatCompletionsOptions(chatMessages))
        .doOnSuccess(ignored -> System.out.println("Success!"))
        .doOnError(
                error -> error instanceof ResourceNotFoundException,
                error -> System.out.println("Exception: 'getChatCompletions' could not be performed."));

Hitelesítési hibák

Az Azure OpenAI támogatja a Microsoft Entra ID-hitelesítést. OpenAIClientBuilder metódust használ a beállításhoz credential. Érvényes hitelesítő adatok megadásához használhat azure-identity függőséget.

Forráskódcsomag (npm) | referencia | |

Az Azure OpenAI API verziótámogatása

Az Azure OpenAI szolgáltatás rendelkezésre állása a megcélzott REST API melyik verziójától függ. A legújabb funkciók esetében a legújabb előzetes API-t célozd meg.

Legújabb GA API	Legújabb előzetes verziójú API
`2024-10-21`	`2025-01-01-preview`

Telepítés

npm install openai

Hitelesítés

Microsoft Entra ID
API-kulcs

Az Azure OpenAI szolgáltatással többféleképpen is hitelesíthető a Microsoft Entra ID-jogkivonatok használatával. Az alapértelmezett módszer az osztály használata a DefaultAzureCredential@azure/identity csomagból.

import { DefaultAzureCredential } from "@azure/identity";
const credential = new DefaultAzureCredential();

Ezt az objektumot ezután az AzureClientOptions objektum részeként továbbítja a rendszer az AzureOpenAIAssistantsClient ügyfélkonstruktoroknak.

Az ügyfél hitelesítéséhez AzureOpenAI azonban a getBearerTokenProvider csomagból származó @azure/identity függvényt kell használnunk. Ez a függvény létrehoz egy jogkivonat-szolgáltatót, amely AzureOpenAI belsőleg használja az egyes kérések jogkivonatainak lekérését. A jogkivonat-szolgáltató a következőképpen jön létre:

import { AzureOpenAI } from 'openai';
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const credential = new DefaultAzureCredential();
const endpoint = "https://your-azure-openai-resource.com";
const apiVersion = "2024-10-21"
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);
const deployment = "gpt-35-turbo";

const client = new AzureOpenAI({ 
    endpoint, 
    apiVersion,
    deployment,
    azureADTokenProvider
});

Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.

Konfiguráció

Az AzureClientOptions objektum kibővíti az OpenAI ClientOptions objektumot. Ez az Azure-specifikus ügyfélobjektum az Azure OpenAI-ügyfél kapcsolatának és viselkedésének konfigurálására szolgál. Az Azure-ban egyedi tulajdonságok megadására szolgáló tulajdonságokat tartalmaz.

Tulajdonság	Részletek
apiVersion: `string`	A használni kívánt API-verziót adja meg.
azureADTokenProvider: `(() => Promise<string>)`	Egy függvény, amely a Microsoft Entra (korábbi nevén Azure Active Directory) hozzáférési jogkivonatát adja vissza, amelyet minden kéréskor meghívnak.
felfejlődés: `string`	Modelltelepítés. Ha meg van adva, az alapügyfél URL-címét adja meg.`/deployments/{deployment}` A nem üzembehelyezési végpontok nem használhatók (az Assistants API-k nem támogatottak).
végpont: `string`	Az Azure OpenAI-végpont a következő formátumban: `https://RESOURCE-NAME.azure.openai.com/`.

Az API-kulcsok éles használatra nem ajánlottak, mert kevésbé biztonságosak, mint más hitelesítési módszerek.

import { AzureKeyCredential } from "@azure/openai";
const apiKey = new AzureKeyCredential("your API key");
const endpoint = "https://your-azure-openai-resource.com";
const apiVersion = "2024-10-21"
const deployment = "gpt-35-turbo";

const client = new AzureOpenAI({ 
    apiKey, 
    endpoint, 
    apiVersion, 
    deployment 
});

Konfiguráció

Tulajdonság	Részletek
apiKey: `string`	Az API-kulcs a kérések hitelesítéséhez.
apiVersion: `string`	A használni kívánt API-verziót adja meg.
felfejlődés: `string`	Modelltelepítés. Ha meg van adva, az alapügyfél URL-címét adja meg.`/deployments/{deployment}` A nem üzembehelyezési végpontok nem használhatók (az Assistants API-k nem támogatottak).
végpont: `string`	Az Azure OpenAI-végpont a következő formátumban: `https://RESOURCE-NAME.azure.openai.com/`.

Fontos

Óvatosan használja az API-kulcsokat. Ne foglalja bele közvetlenül az API-kulcsot a kódba, és soha ne tegye közzé nyilvánosan. HA API-kulcsot használ, biztonságosan tárolja az Azure Key Vaultban. További információ az API-kulcsok biztonságos használatáról az alkalmazásokban: API-kulcsok az Azure Key Vaulttal.

Az AI-szolgáltatások biztonságáról további információt az Azure AI-szolgáltatásokhoz érkező kérelmek hitelesítése című témakörben talál.

Hang

Transzkripció

import { createReadStream } from "fs";

const result = await client.audio.transcriptions.create({
  model: '',
  file: createReadStream(audioFilePath),
});

Csevegés

chat.completions.create

const result = await client.chat.completions.create({ messages, model: '', max_tokens: 100 });

Streamelés

const stream = await client.chat.completions.create({ model: '', messages, max_tokens: 100, stream: true });

Beágyazások

const embeddings = await client.embeddings.create({ input, model: '' });

Képgenerálás

  const results = await client.images.generate({ prompt, model: '', n, size });

Hibakezelés

Hibakódok

Állapotkód	Hibatípus
400	`Bad Request Error`
401	`Authentication Error`
403	`Permission Denied Error`
404	`Not Found Error`
422	`Unprocessable Entity Error`
429	`Rate Limit Error`
500	`Internal Server Error`
503	`Service Unavailable`
504	`Gateway Timeout`

Újrapróbálkozások

A rendszer alapértelmezés szerint automatikusan kétszer kivonja a következő hibákat egy rövid exponenciális visszalépéssel:

Csatlakozási hibák
408 Kérés időtúllépése
429 sebességkorlát
>=500 belső hiba

Az újrapróbálkozás viselkedésének beállítására/letiltására használható maxRetries :

// Configure the default for all requests:
const client = new AzureOpenAI({
  maxRetries: 0, // default is 2
});

// Or, configure per-request:
await client.chat.completions.create({ messages: [{ role: 'user', content: 'How can I get the name of the current day in Node.js?' }], model: '' }, {
  maxRetries: 5,
});

Kódtár forráskódcsomagja (PyPi) | -referencia | |

Feljegyzés

Ezt a könyvtárat az OpenAI tartja karban. A kódtár legújabb frissítéseinek nyomon követéséhez tekintse meg a kiadási előzményeket.

Az Azure OpenAI API verziótámogatása

Az Azure OpenAI szolgáltatás rendelkezésre állása a megcélzott REST API melyik verziójától függ. A legújabb funkciók esetében a legújabb előzetes API-t célozd meg.

Legújabb GA API	Legújabb előzetes verziójú API
`2024-10-21`	`2025-01-01-preview`

Telepítés

pip install openai

A legújabb verzió esetén:

pip install openai --upgrade

Hitelesítés

Microsoft Entra ID
API-kulcs

import os
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  azure_ad_token_provider=token_provider,
  api_version="2024-10-21"
)

Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.

Fontos

Az AI-szolgáltatások biztonságáról további információt az Azure AI-szolgáltatásokhoz érkező kérelmek hitelesítése című témakörben talál.

import os
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-10-21",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )

Hang

audio.speech.create()

Ez a függvény jelenleg előzetes verziójú API-t igényel.

Állítsa be api_version="2024-10-01-preview" ezt a függvényt.

# from openai import AzureOpenAI
# client = AzureOpenAI()

from pathlib import Path
import os

speech_file_path = Path("speech.mp3")

response = client.audio.speech.create(
  model="tts-hd", #Replace with model deployment name
  voice="alloy",
  input="Testing, testing, 1,2,3."
)
response.write_to_file(speech_file_path)

audio.transcriptions.create()

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

audio_file = open("speech1.mp3", "rb")
transcript = client.audio.transcriptions.create(
  model="whisper", # Replace with model deployment name
  file=audio_file
)

print(transcript)

Transcription(text='Testing, testing, one, two, three.')

Csevegés

chat.completions.create()

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

completion = client.chat.completions.create(
  model="gpt-4o", # Replace with your model dpeloyment name.
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "When was Microsoft founded?"}
  ]
)

#print(completion.choices[0].message)
print(completion.model_dump_json(indent=2)

{
  "id": "chatcmpl-AUhZ11g6aNb1Nnxjp4hFUNcszw3uf",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "Microsoft was founded on April 4, 1975, by Bill Gates and Paul Allen in Albuquerque, New Mexico.",
        "refusal": null,
        "role": "assistant",
        "function_call": null,
        "tool_calls": null
      },
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ],
  "created": 1731880663,
  "model": "gpt-4o-2024-08-06",
  "object": "chat.completion",
  "service_tier": null,
  "system_fingerprint": "fp_04751d0b65",
  "usage": {
    "completion_tokens": 24,
    "prompt_tokens": 22,
    "total_tokens": 46,
    "completion_tokens_details": null,
    "prompt_tokens_details": null
  },
  "prompt_filter_results": [
    {
      "prompt_index": 0,
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "jailbreak": {
          "filtered": false,
          "detected": false
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}

chat.completions.create() – streamelés

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

completion = client.chat.completions.create(
  model="gpt-4o", # Replace with your model dpeloyment name.
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "When was Microsoft founded?"}
  ],
  stream=True
)

for chunk in completion:
    if chunk.choices and chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end='',)

Microsoft was founded on April 4, 1975, by Bill Gates and Paul Allen.

chat.completions.create() – képbemenet

Python
Válasz

completion = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png",
                    }
                },
            ],
        }
    ],
    max_tokens=300,
)

print(completion.model_dump_json(indent=2))

{
  "id": "chatcmpl-AUisNBsjzPisMbx3k5Uz5SOKN63KN",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "This image is a watercolor painting of a city skyline, featuring a prominent tower that resembles the Space Needle, which is located in Seattle. The painting uses a blend of colors to depict the cityscape and sky.",
        "refusal": null,
        "role": "assistant",
        "function_call": null,
        "tool_calls": null
      },
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ],
  "created": 1731885707,
  "model": "gpt-4o-2024-08-06",
  "object": "chat.completion",
  "service_tier": null,
  "system_fingerprint": "fp_04751d0b65",
  "usage": {
    "completion_tokens": 42,
    "prompt_tokens": 639,
    "total_tokens": 681,
    "completion_tokens_details": null,
    "prompt_tokens_details": null
  },
  "prompt_filter_results": [
    {
      "prompt_index": 0,
      "content_filter_result": {
        "jailbreak": {
          "filtered": false,
          "detected": false
        }
      }
    },
    {
      "prompt_index": 1,
      "content_filter_result": {
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        },
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}

Beágyazások

embeddings.create()

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

embedding = client.embeddings.create(
  model="text-embedding-3-large", # Replace with your model deployment name
  input="Attenion is all you need",
  encoding_format="float" 
)

print(embedding)

A válasz rövidsége csonkolt.

CreateEmbeddingResponse(data=[Embedding(embedding=[0.009098228, -0.010369237, -0.00048062875, -0.014328566, 0.019677775, 0.010049199, -0.005600668, 0.003858746, -0.007818076, 0.012554641, 0.005134327, 0.004514824, -0.020262988, -0.0039181816, 0.025475038, 0.016733425, 0.002136255, 0.0155172795, 0.0058978465, 0.012911255, -0.014273703, -0.016806576, 0.0265906, 0.037673064, 0.003909038, 0.0265906, -0.001935088, -0.014913779, 0.01781241, -0.017821554, 0.0016596265, -0.002987785, -0.014346854, -0.000962972, 0.0068671047, 0.004405097, -0.015764166, -0.007539185, -0.030394483, -0.01586475, 0.0074706054, -0.013761641, 0.010186358, 0.008805621, -0.009939471, 0.013944521, -0.010113207, -0.015745878, -0.021927187, 0.03231471, 0.0026951786, 0.004759425, 0.0065196347, 0.010927018, 0.017263774, 0.0055229445, 0.009381691, -0.042903405], index=0, object='embedding')], model='text-embedding-3-large', object='list', usage=Usage(prompt_tokens=7, total_tokens=7))

Finomhangolás

Finomhangolás Python-útmutatóval

Batch

Batch és Python – útmutató cikk

Képek

images.generate()

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

generate_image = client.images.generate(
  model="dall-e-3", #replace with your model deployment name
  prompt="A rabbit eating pancakes",
  n=1,
  size="1024x1024",
  quality = "hd",
  response_format = "url",
  style = "vivid"
)

print(generate_image.model_dump_json(indent=2))

{
  "created": 1731894125,
  "data": [
    {
      "b64_json": null,
      "revised_prompt": "A fluffy rabbit contentedly munching on a stack of miniature pancakes laid out on a small plate just its size, set against the backdrop of a sunny meadow.",
      "url": "{Secure path to generated image's Azure Blob storage image url}",
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      },
      "prompt_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "profanity": {
          "detected": false,
          "filtered": false
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}

Befejezések (örökölt)

completions.create()

Python
Válasz

# from openai import AzureOpenAI
# client = AzureOpenAI()

legacy_completion = client.completions.create(
  model="gpt-35-turbo-instruct", # Replace with model deployment name
  prompt="Hello World!",
  max_tokens=100,
  temperature=0
)

print(legacy_completion.model_dump_json(indent=2))

{
  "id": "cmpl-AUlF8xymP0ngMlIgIEYlT7C3Igi2H",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "text": "\n\nHello World!\n\nHello World!",
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ],
  "created": 1731894806,
  "model": "gpt-35-turbo-instruct",
  "object": "text_completion",
  "system_fingerprint": null,
  "usage": {
    "completion_tokens": 8,
    "prompt_tokens": 3,
    "total_tokens": 11,
    "completion_tokens_details": null,
    "prompt_tokens_details": null
  },
  "prompt_filter_results": [
    {
      "prompt_index": 0,
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}

Hibakezelés

# from openai import AzureOpenAI
# client = AzureOpenAI()

import openai

try:
    client.fine_tuning.jobs.create(
        model="gpt-4o",
        training_file="file-test",
    )
except openai.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)  # an underlying Exception, likely raised within httpx.
except openai.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")
except openai.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)

Hibakódok

Állapotkód	Hibatípus
400	`BadRequestError`
401	`AuthenticationError`
403	`PermissionDeniedError`
404	`NotFoundError`
422	`UnprocessableEntityError`
429	`RateLimitError`
>=500	`InternalServerError`
n/a	`APIConnectionError`

Azonosítók kérése

A kérés azonosítójának lekéréséhez használhatja a _request_id válaszfejlécnek x-request-id megfelelő tulajdonságot.

print(completion._request_id) 
print(legacy_completion._request_id)

Újrapróbálkozások

A rendszer alapértelmezés szerint automatikusan kétszer kivonja a következő hibákat egy rövid exponenciális visszalépéssel:

Csatlakozási hibák
408 Kérés időtúllépése
429 sebességkorlát
>=500 belső hiba

Az újrapróbálkozás viselkedésének beállítására/letiltására használható max_retries :

# For all requests

from openai import AzureOpenAI
client = AzureOpenAI(
      max_retries=0
)

# max retires for specific requests

client.with_options(max_retries=5).chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "When was Microsoft founded?",
        }
    ],
    model="gpt-4o",
)

Következő lépések

A jelenleg támogatott modellek megtekintéséhez tekintse meg az Azure OpenAI-modellek oldalát

Megosztás a következőn keresztül:

Az Azure OpenAI által támogatott programozási nyelvek

Stabil kiadás:

Előzetes kiadás:

Az Azure OpenAI API verziótámogatása

Telepítés

Hitelesítés

Hang

Transzkripció

Szövegfelolvasás (TTS)

Csevegés

Csevegőüzenetek streamelése

Beágyazások

Finomhangolás

Batch

Képek

Befejezések (örökölt)

Hibakezelés

Hibakódok

Újrapróbálkozások

Az Azure OpenAI API verziótámogatása

Telepítés

Hitelesítés

Hang

Client.GenerateSpeechFromText

Client.GetAudioTranscription

Csevegés

Client.GetChatCompletions

Client.GetChatCompletionsStream

Beágyazások

Client.GetEmbeddings

Képgenerálás

Client.GetImageGenerations

Befejezések (örökölt)

Client.GetChatCompletions

Hibakezelés

Naplózás

Az Azure OpenAI API verziótámogatása

Telepítés

Csomag részletei

Hitelesítés

Hang

client.getAudioTranscription

client.generateSpeechFromText

Csevegés

client.getChatCompletions

Streamelés

Csevegés befejezése képekkel

Beágyazások

client.getEmbeddings

Képgenerálás

Hibák kezelése

Ügyfélnaplózás engedélyezése

HTTP-kérések/válaszok naplózásának engedélyezése

Kivételek hibaelhárítása

Hitelesítési hibák

Az Azure OpenAI API verziótámogatása

Telepítés

Hitelesítés

Konfiguráció

Hang

Transzkripció

Csevegés

Streamelés

Beágyazások

Képgenerálás

Hibakezelés

Hibakódok

Újrapróbálkozások

Az Azure OpenAI API verziótámogatása

Telepítés

Hitelesítés

Hang

audio.speech.create()

audio.transcriptions.create()

Csevegés

chat.completions.create()

chat.completions.create() – streamelés

chat.completions.create() – képbemenet

Beágyazások