Azure OpenAI-Clientbibliothek für .NET – Version 1.0.0-beta.9

Artikel
11/09/2023

Die Azure OpenAI-Clientbibliothek für .NET ist eine Anpassung der REST-APIs von OpenAI, die eine idiomatische Schnittstelle und eine umfassende Integration in das restliche Azure SDK-Ökosystem bietet. Es kann eine Verbindung mit Azure OpenAI-Ressourcen oder mit dem Nicht-Azure OpenAI-Rückschlussendpunkt herstellen, was es zu einer hervorragenden Wahl für die Nicht-Azure OpenAI-Entwicklung macht.

Verwenden Sie die Clientbibliothek für Azure OpenAI für Folgendes:

Azure OpenAI ist ein verwalteter Dienst, mit dem Entwickler Inhalte aus OpenAI-Modellen in Azure-Ressourcen bereitstellen, optimieren und generieren können.

Quellcode | Paket (NuGet) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Voraussetzungen

Wenn Sie eine Azure OpenAI-Ressource verwenden möchten, benötigen Sie ein Azure-Abonnement und Azure OpenAI-Zugriff. Dadurch können Sie eine Azure OpenAI-Ressource erstellen und sowohl eine Verbindungs-URL als auch API-Schlüssel abrufen. Weitere Informationen finden Sie unter Schnellstart: Erste Schritte beim Generieren von Text mithilfe von Azure OpenAI Service.

Wenn Sie die Azure OpenAI .NET-Clientbibliothek verwenden möchten, um eine Verbindung mit Nicht-Azure OpenAI herzustellen, benötigen Sie einen API-Schlüssel aus einem Entwicklerkonto unter https://platform.openai.com/.

Installieren des Pakets

Installieren Sie die Clientbibliothek für .NET mit NuGet:

dotnet add package Azure.AI.OpenAI --prerelease

Authentifizieren des Clients

Um mit Azure OpenAI oder OpenAI zu interagieren, müssen Sie eine instance der OpenAIClient-Klasse erstellen. Um einen Client für die Verwendung mit Azure OpenAI zu konfigurieren, geben Sie einen gültigen Endpunkt-URI für eine Azure OpenAI-Ressource zusammen mit den entsprechenden Schlüsselanmeldeinformationen, Tokenanmeldeinformationen oder Azure-Identitätsanmeldeinformationen an, die für die Verwendung der Azure OpenAI-Ressource autorisiert sind. Um stattdessen den Client für die Verbindung mit dem OpenAI-Dienst zu konfigurieren, geben Sie einen API-Schlüssel aus dem OpenAI-Entwicklerportal an.

OpenAIClient client = useAzureOpenAI
    ? new OpenAIClient(
        new Uri("https://your-azure-openai-resource.com/"),
        new AzureKeyCredential("your-azure-openai-resource-api-key"))
    : new OpenAIClient("your-api-key-from-platform.openai.com");

Erstellen von OpenAIClient mit Azure Active Directory-Anmeldeinformationen

Die Authentifizierung des Clientabonnements wird in den meisten Beispielen in diesem Leitfaden für die ersten Schritte verwendet. Sie können sich jedoch auch mithilfe der Azure Identity-Bibliothek bei Azure Active Directory authentifizieren. Um den unten gezeigten Anbieter DefaultAzureCredential oder andere Anbieter von Anmeldeinformationen zu verwenden, die mit dem Azure SDK bereitgestellt werden, installieren Sie das Azure.Identity-Paket:

dotnet add package Azure.Identity

string endpoint = "https://myaccount.openai.azure.com/";
var client = new OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());

Wichtige Begriffe

Das zu verstehende Standard Konzept ist Vervollständigungen. Kurz erläutert, bietet Vervollständigungen ihre Funktionalität in Form einer Texteingabeaufforderung, die mithilfe eines bestimmten Modells dann versucht, den Kontext und die Muster abzugleichen, und einen Ausgabetext bereitstellt. Der folgende Codeausschnitt bietet eine grobe Übersicht (weitere Details finden Sie im GenerateChatbotResponsesWithToken Beispielcode):

OpenAIClient client = useAzureOpenAI
    ? new OpenAIClient(
        new Uri("https://your-azure-openai-resource.com/"),
        new AzureKeyCredential("your-azure-openai-resource-api-key"))
    : new OpenAIClient("your-api-key-from-platform.openai.com");

Response<Completions> response = await client.GetCompletionsAsync(new CompletionsOptions()
{
    DeploymentName = "text-davinci-003", // assumes a matching model deployment or model name
    Prompts = { "Hello, world!" },
});

foreach (Choice choice in response.Value.Choices)
{
    Console.WriteLine(choice.Text);
}

Threadsicherheit

Wir garantieren, dass alle Client-instance Methoden threadsicher und unabhängig voneinander sind (Richtlinie). Dadurch wird sichergestellt, dass die Empfehlung, Clientinstanzen wiederzuverwenden, immer sicher ist, auch über Threads hinweg.

Zusätzliche Konzepte

Beispiele

Mithilfe von Beispielen können Sie sich mit verschiedenen APIs vertraut machen.

Generieren einer Chatbotantwort

Die GenerateChatbotResponse Methode authentifiziert sich mithilfe von DefaultAzureCredential und generiert dann Textantworten auf Eingabeaufforderungen.

string endpoint = "https://myaccount.openai.azure.com/";
var client = new OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());

CompletionsOptions completionsOptions = new()
{
    DeploymentName = "text-davinci-003",
    Prompts = { "What is Azure OpenAI?" },
};

Response<Completions> completionsResponse = client.GetCompletions(completionsOptions);
string completion = completionsResponse.Value.Choices[0].Text;
Console.WriteLine($"Chatbot: {completion}");

Generieren mehrerer Chatbotantworten mit Abonnementschlüssel

Die GenerateMultipleChatbotResponsesWithSubscriptionKey -Methode enthält ein Beispiel für das Generieren von Textantworten auf Eingabeaufforderungen mithilfe eines Azure-Abonnementschlüssels.

// Replace with your Azure OpenAI key
string key = "YOUR_AZURE_OPENAI_KEY";
string endpoint = "https://myaccount.openai.azure.com/";
var client = new OpenAIClient(new Uri(endpoint), new AzureKeyCredential(key));

CompletionsOptions completionsOptions = new()
{
    DeploymentName = "text-davinci-003",
    Prompts =
    {
        "How are you today?",
        "What is Azure OpenAI?",
        "Why do children love dinosaurs?",
        "Generate a proof of Euler's identity",
        "Describe in single words only the good things that come into your mind about your mother."
    },
};

Response<Completions> completionsResponse = client.GetCompletions(completionsOptions);

foreach (Choice choice in completionsResponse.Value.Choices)
{
    Console.WriteLine($"Response for prompt {choice.Index}: {choice.Text}");
}

Text mit Vervollständigung zusammenfassen

Die SummarizeText -Methode generiert eine Zusammenfassung der angegebenen Eingabeeingabeaufforderung.

string endpoint = "https://myaccount.openai.azure.com/";
var client = new OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());

string textToSummarize = @"
    Two independent experiments reported their results this morning at CERN, Europe's high-energy physics laboratory near Geneva in Switzerland. Both show convincing evidence of a new boson particle weighing around 125 gigaelectronvolts, which so far fits predictions of the Higgs previously made by theoretical physicists.

    ""As a layman I would say: 'I think we have it'. Would you agree?"" Rolf-Dieter Heuer, CERN's director-general, asked the packed auditorium. The physicists assembled there burst into applause.
:";

string summarizationPrompt = @$"
    Summarize the following text.

    Text:
    """"""
    {textToSummarize}
    """"""

    Summary:
";

Console.Write($"Input: {summarizationPrompt}");
var completionsOptions = new CompletionsOptions()
{
    DeploymentName = "text-davinci-003",
    Prompts = { summarizationPrompt },
};

Response<Completions> completionsResponse = client.GetCompletions(completionsOptions);
string completion = completionsResponse.Value.Choices[0].Text;
Console.WriteLine($"Summarization: {completion}");

Streamen von Chatnachrichten mit Nicht-Azure OpenAI

string nonAzureOpenAIApiKey = "your-api-key-from-platform.openai.com";
var client = new OpenAIClient(nonAzureOpenAIApiKey, new OpenAIClientOptions());
var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = "gpt-3.5-turbo", // Use DeploymentName for "model" with non-Azure clients
    Messages =
    {
        new ChatMessage(ChatRole.System, "You are a helpful assistant. You will talk like a pirate."),
        new ChatMessage(ChatRole.User, "Can you help me?"),
        new ChatMessage(ChatRole.Assistant, "Arrrr! Of course, me hearty! What can I do for ye?"),
        new ChatMessage(ChatRole.User, "What's the best way to train a parrot?"),
    }
};

await foreach (StreamingChatCompletionsUpdate chatUpdate in client.GetChatCompletionsStreaming(chatCompletionsOptions))
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
    }
    if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
    {
        Console.Write(chatUpdate.ContentUpdate);
    }
}

Wenn Sie während des Streamings explizit mehr als eins Choice anfordern, verwenden Sie die ChoiceIndex Eigenschaft on StreamingChatCompletionsUpdate , um zu bestimmen, welche Choice Aktualisierungen entsprechen.

// A ChoiceCount > 1 will feature multiple, parallel, independent text generations arriving on the
// same response. This may be useful when choosing between multiple candidates for a single request.
var chatCompletionsOptions = new ChatCompletionsOptions()
{
    Messages = { new ChatMessage(ChatRole.User, "Write a limerick about bananas.") },
    ChoiceCount = 4
};

await foreach (StreamingChatCompletionsUpdate chatUpdate
    in client.GetChatCompletionsStreaming(chatCompletionsOptions))
{
    // Choice-specific information like Role and ContentUpdate will also provide a ChoiceIndex that allows
    // StreamingChatCompletionsUpdate data for independent choices to be appropriately separated.
    if (chatUpdate.ChoiceIndex.HasValue)
    {
        int choiceIndex = chatUpdate.ChoiceIndex.Value;
        if (chatUpdate.Role.HasValue)
        {
            textBoxes[choiceIndex].Text += $"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ";
        }
        if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
        {
            textBoxes[choiceIndex].Text += chatUpdate.ContentUpdate;
        }
    }
}

Verwenden von Chatfunktionen

Chatfunktionen ermöglichen es einem Aufrufer von Chat-Vervollständigungen, Funktionen zu definieren, mit denen das Modell seine Funktionalität auf externe Tools und Datenquellen erweitern kann.

Weitere Informationen zu Chatfunktionen finden Sie im Blog von OpenAI: https://openai.com/blog/function-calling-and-other-api-updates

HINWEIS: Chatfunktionen erfordern Modellversionen, die mit den Bezeichnungen gpt-4 und gpt-3.5-turbo -0613 beginnen. In älteren Versionen der Modelle sind sie nicht verfügbar.

HINWEIS: Die gleichzeitige Verwendung von Chatfunktionen und Azure Chat-Erweiterungen für eine einzelne Anforderung wird noch nicht unterstützt. Die Bereitstellung beider Funktionen führt dazu, dass die Chatfunktionen-Informationen ignoriert werden und sich der Vorgang so verhält, als ob nur die Azure Chat-Erweiterungen bereitgestellt würden. Um diese Einschränkung zu beheben, erwägen Sie, die Auswertung von Chatfunktionen und Azure Chat-Erweiterungen auf mehrere Anforderungen in Ihrem Lösungsentwurf zu trennen.

Um Chatfunktionen zu verwenden, definieren Sie zunächst die Funktion, die das Modell bei Bedarf verwenden soll. Verwenden Sie das Beispiel aus dem verknüpften Blogbeitrag oben:

var getWeatherFuntionDefinition = new FunctionDefinition()
{
    Name = "get_current_weather",
    Description = "Get the current weather in a given location",
    Parameters = BinaryData.FromObjectAsJson(
    new
    {
        Type = "object",
        Properties = new
        {
            Location = new
            {
                Type = "string",
                Description = "The city and state, e.g. San Francisco, CA",
            },
            Unit = new
            {
                Type = "string",
                Enum = new[] { "celsius", "fahrenheit" },
            }
        },
        Required = new[] { "location" },
    },
    new JsonSerializerOptions() {  PropertyNamingPolicy = JsonNamingPolicy.CamelCase }),
};

Wenn die Funktion definiert ist, kann sie dann über ihre Optionen in einer Chat-Vervollständigungsanforderung verwendet werden. Funktionsdaten werden über mehrere Aufrufe hinweg verarbeitet, die Daten für nachfolgende zustandslose Anforderungen erstellen, sodass wir eine Liste mit Chatnachrichten als Form des Unterhaltungsverlaufs verwalten.

var conversationMessages = new List<ChatMessage>()
{
    new(ChatRole.User, "What is the weather like in Boston?"),
};

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = "gpt-35-turbo-0613",
};
foreach (ChatMessage chatMessage in conversationMessages)
{
    chatCompletionsOptions.Messages.Add(chatMessage);
}
chatCompletionsOptions.Functions.Add(getWeatherFuntionDefinition);

Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);

Wenn das Modell feststellt, dass eine Chatfunktion aufgerufen werden soll, wird ein Abschlussgrund von "FunctionCall" für die Auswahl aufgefüllt, und details werden in der Eigenschaft der Antwortnachricht FunctionCall vorhanden sein. In der Regel wird der Name des Funktionsaufrufs angegeben, und die Argumente sind ein ausgefülltes JSON-Dokument, das dem im FunctionDefinition verwendeten Schema enthaltenen Schema entspricht. Es ist jedoch nicht garantiert , dass diese Daten gültig oder sogar ordnungsgemäß formatiert sind. Daher sollten Validierung und Fehlerüberprüfung immer die Verarbeitung von Funktionsaufrufen begleiten.

Um den Funktionsaufruf aufzulösen und die benutzerseitige Interaktion fortzusetzen, verarbeiten Sie die Argumentnutzlast nach Bedarf, und serialisieren Sie dann die entsprechenden Antwortdaten in eine neue Nachricht mit ChatRole.Function. Stellen Sie dann eine neue Anforderung mit allen bisherigen Nachrichten - der ersten User Nachricht, der Nachricht der ersten Antwort FunctionCall und der als Antwort auf den Funktionsaufruf generierten auflösenden Function Nachricht -, damit das Modell die Daten verwenden kann, um eine Chatvervollständigungsantwort besser zu formulieren.

Beachten Sie, dass die Von Ihnen angegebene Funktionsaufrufantwort keinem Schema folgen muss, das im ersten Aufruf angegeben wurde. Das Modell leitet die Verwendung der Antwortdaten basierend auf dem abgeleiteten Kontext von Namen und Feldern ab.

ChatChoice responseChoice = response.Value.Choices[0];
if (responseChoice.FinishReason == CompletionsFinishReason.FunctionCall)
{
    // Include the FunctionCall message in the conversation history
    conversationMessages.Add(responseChoice.Message);

    if (responseChoice.Message.FunctionCall.Name == "get_current_weather")
    {
        // Validate and process the JSON arguments for the function call
        string unvalidatedArguments = responseChoice.Message.FunctionCall.Arguments;
        var functionResultData = (object)null; // GetYourFunctionResultData(unvalidatedArguments);
        // Here, replacing with an example as if returned from GetYourFunctionResultData
        functionResultData = new
        {
            Temperature = 31,
            Unit = "celsius",
        };
        // Serialize the result data from the function into a new chat message with the 'Function' role,
        // then add it to the messages after the first User message and initial response FunctionCall
        var functionResponseMessage = new ChatMessage(
            ChatRole.Function,
            JsonSerializer.Serialize(
                functionResultData,
                new JsonSerializerOptions() {  PropertyNamingPolicy = JsonNamingPolicy.CamelCase }))
        {
            Name = responseChoice.Message.FunctionCall.Name
        };
        conversationMessages.Add(functionResponseMessage);
        // Now make a new request using all three messages in conversationMessages
    }
}

Wenn Sie Streaming verwenden, erfassen Sie Streamingantwortkomponenten beim Eintreffen, und sammeln Sie Streamingfunktionsargumente auf die gleiche Weise, die für Streaminginhalte verwendet werden. Fügen Sie dann anstelle der ChatMessage aus der Nichtstreamingantwort einen neuen ChatMessage instance für den Verlauf hinzu, der aus den gestreamten Informationen erstellt wird.

string functionName = null;
StringBuilder contentBuilder = new();
StringBuilder functionArgumentsBuilder = new();
ChatRole streamedRole = default;
CompletionsFinishReason finishReason = default;

await foreach (StreamingChatCompletionsUpdate update
    in client.GetChatCompletionsStreaming(chatCompletionsOptions))
{
    contentBuilder.Append(update.ContentUpdate);
    functionName ??= update.FunctionName;
    functionArgumentsBuilder.Append(update.FunctionArgumentsUpdate);
    streamedRole = update.Role ?? default;
    finishReason = update.FinishReason ?? default;
}

if (finishReason == CompletionsFinishReason.FunctionCall)
{
    string lastContent = contentBuilder.ToString();
    string unvalidatedArguments = functionArgumentsBuilder.ToString();
    ChatMessage chatMessageForHistory = new(streamedRole, lastContent)
    {
        FunctionCall = new(functionName, unvalidatedArguments),
    };
    conversationMessages.Add(chatMessageForHistory);

    // Handle from here just like the non-streaming case
}

Bitte beachten Sie: Während gestreamte Funktionsinformationen (Name, Argumente) beim Eintreffen ausgewertet werden können, sollten sie erst dann als vollständig oder bestätigt betrachtet werden, wenn die FinishReason von FunctionCall empfangen wird. Es kann angebracht sein, Best-Effort-Versuche zum Aufwärmen oder einer anderen spekulativen Vorbereitung zu unternehmen, die auf einem Funktionsnamen oder einem bestimmten Schlüssel/Wert basiert, der in den akkumulierten, teilweisen JSON-Argumenten angezeigt wird, aber es sollten keine starken Annahmen über Gültigkeit, Reihenfolge oder andere Details ausgewertet werden, bis die Argumente vollständig verfügbar sind und über FinishReasonbestätigt werden.

Verwenden Ihrer eigenen Daten mit Azure OpenAI

Das Feature "Eigene Daten verwenden" ist für Azure OpenAI eindeutig und funktioniert nicht mit einem Client, der für die Verwendung des Nicht-Azure-Diensts konfiguriert ist. In der Schnellstartanleitung zu Azure OpenAI mit eigenen Daten finden Sie konzeptionelle Hintergrundinformationen und ausführliche Einrichtungsanweisungen.

AzureCognitiveSearchChatExtensionConfiguration contosoExtensionConfig = new()
{
    SearchEndpoint = new Uri("https://your-contoso-search-resource.search.windows.net"),
    IndexName = "contoso-products-index",
};

contosoExtensionConfig.SetSearchKey("<your Cognitive Search resource API key>");

ChatCompletionsOptions chatCompletionsOptions = new()
{
    DeploymentName = "gpt-35-turbo-0613",
    Messages =
    {
        new ChatMessage(
            ChatRole.System,
            "You are a helpful assistant that answers questions about the Contoso product database."),
        new ChatMessage(ChatRole.User, "What are the best-selling Contoso products this month?")
    },

    // The addition of AzureChatExtensionsOptions enables the use of Azure OpenAI capabilities that add to
    // the behavior of Chat Completions, here the "using your own data" feature to supplement the context
    // with information from an Azure Cognitive Search resource with documents that have been indexed.
    AzureExtensionsOptions = new AzureChatExtensionsOptions()
    {
        Extensions = { contosoExtensionConfig }
    }
};

Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
ChatMessage message = response.Value.Choices[0].Message;

// The final, data-informed response still appears in the ChatMessages as usual
Console.WriteLine($"{message.Role}: {message.Content}");

// Responses that used extensions will also have Context information that includes special Tool messages
// to explain extension activity and provide supplemental information like citations.
Console.WriteLine($"Citations and other information:");

foreach (ChatMessage contextMessage in message.AzureExtensionsContext.Messages)
{
    // Note: citations and other extension payloads from the "tool" role are often encoded JSON documents
    // and need to be parsed as such; that step is omitted here for brevity.
    Console.WriteLine($"{contextMessage.Role}: {contextMessage.Content}");
}

Generieren von Einbettungen

EmbeddingsOptions embeddingsOptions = new()
{
    DeploymentName = "text-embedding-ada-002",
    Input = { "Your text string goes here" },
};
Response<Embeddings> response = await client.GetEmbeddingsAsync(embeddingsOptions);

// The response includes the generated embedding.
EmbeddingItem item = response.Value.Data[0];
ReadOnlyMemory<float> embedding = item.Embedding;

Generieren von Bildern mit DALL-E-Bildgenerierungsmodellen

Response<ImageGenerations> imageGenerations = await client.GetImageGenerationsAsync(
    new ImageGenerationOptions()
    {
        Prompt = "a happy monkey eating a banana, in watercolor",
        Size = ImageSize.Size256x256,
    });

// Image Generations responses provide URLs you can use to retrieve requested images
Uri imageUri = imageGenerations.Value.Data[0].Url;

Transkribieren von Audiodaten mit Whisper-Sprachmodellen

using Stream audioStreamFromFile = File.OpenRead("myAudioFile.mp3");

var transcriptionOptions = new AudioTranscriptionOptions()
{
    DeploymentName = "my-whisper-deployment", // whisper-1 as model name for non-Azure OpenAI
    AudioData = BinaryData.FromStream(audioStreamFromFile),
    ResponseFormat = AudioTranscriptionFormat.Verbose,
};

Response<AudioTranscription> transcriptionResponse
    = await client.GetAudioTranscriptionAsync(transcriptionOptions);
AudioTranscription transcription = transcriptionResponse.Value;

// When using Simple, SRT, or VTT formats, only transcription.Text will be populated
Console.WriteLine($"Transcription ({transcription.Duration.Value.TotalSeconds}s):");
Console.WriteLine(transcription.Text);

Übersetzen von Audiodaten in englischer Sprache mit Flüster-Sprachmodellen

using Stream audioStreamFromFile = File.OpenRead("mySpanishAudioFile.mp3");

var translationOptions = new AudioTranslationOptions()
{
    DeploymentName = "my-whisper-deployment", // whisper-1 as model name for non-Azure OpenAI
    AudioData = BinaryData.FromStream(audioStreamFromFile),
    ResponseFormat = AudioTranslationFormat.Verbose,
};

Response<AudioTranslation> translationResponse = await client.GetAudioTranslationAsync(translationOptions);
AudioTranslation translation = translationResponse.Value;

// When using Simple, SRT, or VTT formats, only translation.Text will be populated
Console.WriteLine($"Translation ({translation.Duration.Value.TotalSeconds}s):");
// .Text will be translated to English (ISO-639-1 "en")
Console.WriteLine(translation.Text);

Problembehandlung

Wenn Sie mit Azure OpenAI mithilfe des .NET SDK interagieren, entsprechen vom Dienst zurückgegebene Fehler den gleichen HTTP-status-Codes, die für REST-API-Anforderungen zurückgegeben werden.

Wenn Sie beispielsweise versuchen, einen Client mithilfe eines Endpunkts zu erstellen, der nicht ihrem Azure OpenAI-Ressourcenendpunkt entspricht, wird ein 404 Fehler zurückgegeben, der Resource Not Foundangibt.

Nächste Schritte

Stellen Sie einen Link zu zusätzlichen Codebeispielen bereit, idealerweise für diejenigen, die neben der INFOdatei im Verzeichnis des Pakets /samples sitzen.
Verweisen Sie ggf. benutzer auf andere Pakete, die nützlich sein könnten.
Wenn Sie der Meinung sind, dass es eine gute Chance gibt, dass Entwickler irrtümlich über Ihr Paket stolpern (weil sie nach bestimmten Funktionen suchen und fälschend der Meinung sind, dass das Paket diese Funktionalität bietet), zeigen Sie sie auf die Pakete, nach denen sie möglicherweise suchen.

Mitwirken

Weitere Informationen zum Erstellen, Testen und Mitwirken zu dieser Bibliothek finden Sie im OpenAI-CONTRIBUTING.md .

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Weitere Informationen finden Sie unter cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.

Aufrufe