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


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

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 :

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.

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

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

Hitelesítés

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.

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.

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.

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

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/.

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

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

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.

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

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

Csevegés

chat.completions.create()

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

chat.completions.create() – streamelés

# 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='',)

chat.completions.create() – képbemenet

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

Beágyazások

embeddings.create()

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

Finomhangolás

Finomhangolás Python-útmutatóval

Batch

Batch és Python – útmutató cikk

Képek

images.generate()

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

Befejezések (örökölt)

completions.create()

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

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