Schnellstart: Erste Schritte beim Generieren von Text mithilfe der Legacy-Vervollständigungs-API

Voraussetzungen

• Azure-Abonnement – kostenloses Abonnement erstellen.
• Eine Azure OpenAI-Ressource mit einem bereitgestellten Modell. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Wechseln zu Azure OpenAI Studio

Navigieren Sie unter https://oai.azure.com/ zu „Azure OpenAI Studio“, und melden Sie sich mit den Anmeldeinformationen an, mit denen Sie Zugriff auf Ihre Azure OpenAI-Ressource haben. Wählen Sie während oder nach dem Anmeldeworkflow das passende Verzeichnis, Azure-Abonnement und die Azure OpenAI-Ressource aus.

Navigieren Sie weiter auf der Azure OpenAI Studio-Landing Page, um sich Beispiele für die Vervollständigung von Aufforderungen anzusehen, Ihre Bereitstellungen und Modelle zu verwalten und Lernressourcen wie Dokumentationen und Communityforen zu finden.

Playground

Beginnen Sie mit der Erkundung der Azure OpenAI-Funktionen mit einem No-Code-Ansatz mithilfe des GPT-3 Playground. Es handelt sich ganz einfach um ein Textfeld, in das Sie einen Befehlstext eingeben, um eine Vervollständigung zu generieren. Auf dieser Seite können Sie die Funktionen ganz einfach schrittweise erkunden und mit ihnen experimentieren.

Sie können für den Start eine Bereitstellung auswählen und sich für eines der vorab geladenen Beispiele entscheiden. Wenn Ihre Ressource keine Bereitstellung aufweist, wählen Sie Bereitstellung erstellen aus, und folgen Sie den Anweisungen des Assistenten. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Sie können mit den Konfigurationseinstellungen wie Temperatur und Pre-Response-Text experimentieren, um die Leistungsfähigkeit Ihres Tasks zu verbessern. Weitere Informationen zu den einzelnen Parametern finden Sie in der REST-API.

• Durch Auswahl der Schaltfläche Generieren wird der eingegebene Text an die Vervollständigungs-API gesendet, und die Ergebnisse werden zurück in das Textfeld gestreamt.
• Wählen Sie die Schaltfläche Rückgängig machen aus, um den vorherigen Generierungsaufruf rückgängig zu machen.
• Wählen Sie die Schaltfläche Erneut generieren aus, um einen Aufruf zum Rückgängigmachen und gleichzeitig einen zum Generieren abzuschließen.

Azure OpenAI führt außerdem Inhaltsmoderation für die Eingabeaufforderungen und generierten Ausgaben aus. Die Eingabeaufforderungen oder Antworten können gefiltert werden, wenn schädliche Inhalte erkannt werden. Weitere Informationen finden Sie im Artikel zu Inhaltsfiltern.

Im Vervollständigungs-Playground können Sie auch Python- und Curl-Codebeispiele anzeigen, die anhand der von Ihnen ausgewählten Einstellungen vorab ausgefüllt wurden. Wählen Sie einfach Code anzeigen neben der Dropdownliste mit den Beispielen aus. Sie können eine Anwendung schreiben, um dieselbe Aufgabe mit dem OpenAI Python SDK, mit Curl oder mit einem anderen REST-API-Client auszuführen.

Textzusammenfassung ausprobieren

Um Azure OpenAI für die Textzusammenfassung im Vervollständigungs-Playground zu verwenden, führen Sie die folgenden Schritte aus:

1. Melden Sie sich bei Azure OpenAI Studio an.

2. Wählen Sie das Abonnement und die OpenAI-Ressource aus, mit denen Sie arbeiten möchten.

3. Wählen Sie den Vervollständigungs-Playground auf der Startseite aus.

4. Wählen Sie Ihre Bereitstellung in der Dropdownliste Bereitstellungen aus. Wenn Ihre Ressource keine Bereitstellung aufweist, wählen Sie Bereitstellung erstellen aus, und kehren Sie dann zu diesem Schritt zurück.

5. Geben Sie einen Prompt für das Modell ein.

   

6. Wählen Sie Generate aus. Azure OpenAI wird versuchen, den Kontext des Texts zu erfassen und eine kurze und prägnante Zusammenfassung erstellen. Sie sollten ein Ergebnis erhalten, das dem folgenden Text ähnelt:

Die Genauigkeit der Antwort kann je nach Modell variieren. Das gpt-35-turbo-instruct-basierte Modell in diesem Beispiel eignet sich gut für diese Art von Zusammenfassung, aber im Allgemeinen empfehlen wir die Verwendung der API für alternative Chatvervollständigungen, es sei denn, Sie haben einen bestimmten Anwendungsfall, der besonders für die Vervollständigungs-API geeignet ist.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource selbst oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• In unserem Leitfaden zu Vervollständigungen erfahren Sie mehr darüber, wie Sie Vervollständigungen am besten generieren.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele.

Quellcode | Paket (NuGeT) | Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Aktuelle Version von .NET Core
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo-instruct. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Erstellen einer neuen .NET Core-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen azure-openai-quickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-Projekt mit einer einzigen C#-Quelldatei: Program.cs.

dotnet new console -n azure-openai-quickstart

Wechseln Sie zum Ordner der neu erstellten App. Sie können die Anwendung mit folgendem Befehl erstellen:

dotnet build

Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installieren Sie die OpenAI .NET-Clientbibliothek mit:

dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.17

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer Beispielanwendung

Öffnen Sie im Projektverzeichnis die Datei program.cs, und ersetzen Sie den Inhalt durch den folgenden Code:

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

var client = new OpenAIClient(
    new Uri(endpoint),
    new AzureKeyCredential(key));

CompletionsOptions completionsOptions = new()
{
    DeploymentName = "gpt-35-turbo-instruct",
    Prompts = { "When was Microsoft founded?" },
};

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

dotnet run program.cs

Ausgabe

Chatbot:

Microsoft was founded on April 4, 1975.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Paket (Go)| Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Lokale Installation von Go 1.21.0 oder höher.
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo-instuct. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer Beispielanwendung

Erstellen Sie eine neue Datei mit dem Namen completions.go. Kopieren Sie den folgenden Code in die Datei „completion.go“.

package main

import (
	"context"
	"fmt"
	"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("AZURE_OPENAI_API_KEY")
	modelDeploymentID := "gpt-35-turbo-instruct"

	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		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: handle error
	}

	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: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: handle error
	}

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

}

Öffnen Sie nun eine Eingabeaufforderung, und führen Sie Folgendes aus:

go mod init completions.go

Nächste Ausführung:

go mod tidy

go run completions.go

Ausgabe

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Artefakt (Maven) | Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto

• Aktuelle Version des Java Development Kit (JDK)
• Gradle-Buildtool oder einen anderen Abhängigkeit-Manager

• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo-instruct. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer neuen Java-Anwendung

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle, u. a. die Datei build.gradle.kts, erstellt. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.

gradle init --type basic

Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

Installieren des Java SDK

In dieser Schnellstartanleitung wird der Gradle-Abhängigkeits-Manager verwendet. Die Clientbibliothek und Informationen zu anderen Abhängigkeits-Managern finden Sie im zentralen Maven-Repository.

Navigieren Sie zur Datei build.gradle.kts, und öffnen Sie sie in Ihrer bevorzugten IDE bzw. Ihrem bevorzugten Text-Editor. Kopieren Sie anschließend die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java-Anwendung, deren Einstiegspunkt die Klasse OpenAIQuickstart ist. Dies importiert die Azure KI Vision-Bibliothek.

plugins {
    java
    application
}
application { 
    mainClass.set("GetCompletionsSample")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.3")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Erstellen einer Beispielanwendung

1. Erstellen einer Java-Datei

   Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus, um einen Projektquellordner zu erstellen:

   mkdir -p src/main/java
   

   Navigieren Sie zum neuen Ordner, und erstellen Sie eine Datei mit dem Namen GetCompletionsSample.java.

2. Öffnen Sie GetCompletionsSample.java in Ihrem bevorzugten Editor oder Ihrer IDE, und fügen Sie den folgenden Code ein.

   package com.azure.ai.openai.usage;
   
   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.Choice;
   import com.azure.ai.openai.models.Completions;
   import com.azure.ai.openai.models.CompletionsOptions;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GetCompletionsSample {
   
       public static void main(String[] args) {
           String azureOpenaiKey = System.getenv("AZURE_OPENAI_API_KEY");;
           String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");;
           String deploymentOrModelId = "gpt-35-turbo-instruct";
   
           OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<String> prompt = new ArrayList<>();
           prompt.add("When was Microsoft founded?");
   
           Completions completions = client.getCompletions(deploymentOrModelId, new CompletionsOptions(prompt));
   
           System.out.printf("Model ID=%s is created at %s.%n", completions.getId(), completions.getCreatedAt());
           for (Choice choice : completions.getChoices()) {
               System.out.printf("Index: %d, Text: %s.%n", choice.getIndex(), choice.getText());
           }
   
           CompletionsUsage usage = completions.getUsage();
           System.out.printf("Usage: number of prompt token is %d, "
                   + "number of completion token is %d, and number of total tokens in request and response is %d.%n",
               usage.getPromptTokens(), usage.getCompletionTokens(), usage.getTotalTokens());
       }
   }
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Navigieren Sie zurück zum Projektstammordner, und erstellen Sie die App mit:

   gradle build
   

   Führen Sie ihn dann mit dem gradle run-Befehl aus:

   gradle run
   

Ausgabe

Model ID=cmpl-7JZRbWuEuHX8ozzG3BXC2v37q90mL is created at 1684898835.
Index: 0, Text:

Microsoft was founded on April 4, 1975..
Usage: number of prompt token is 5, number of completion token is 11, and number of total tokens in request and response is 16.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Artifacts (Maven) | Beispiel

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Aktuelle Version des Java Development Kit (JDK)
• Das Spring Boot CLI-Tool
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

export SPRING_AI_AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export SPRING_AI_AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"
export SPRING_AI_AZURE_OPENAI_MODEL="REPLACE_WITH_YOUR_MODEL_NAME_HERE"

Erstellen einer neuen Spring-Anwendung

Erstellen Sie ein neues Spring-Projekt.

Erstellen Sie in einem Bash-Fenster ein neues Verzeichnis für Ihre App, und navigieren Sie dorthin.

mkdir ai-completion-demo && cd ai-completion-demo

Führen Sie den Befehl spring init in Ihrem Arbeitsverzeichnis aus. Dieser Befehl erstellt eine Standardverzeichnisstruktur für Ihr Spring-Projekt, einschließlich der Hauptquelldatei der Java-Klassen und der Datei pom.xml, die für die Verwaltung von Maven-basierten Projekten verwendet wird.

spring init -a ai-completion-demo -n AICompletion --force --build maven -x

Die generierten Dateien und Ordner ähneln der folgenden Struktur:

ai-completion-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aicompletiondemo/
    |                   |-- AiCompletionApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aicompletiondemo/
                        |-- AiCompletionApplicationTests.java

Bearbeiten der Spring-Anwendung

1. Bearbeiten Sie die pom.xml-Datei.

   Öffnen Sie im Stammverzeichnis des Projektverzeichnisses die Datei pom.xml in Ihrem bevorzugten Editor oder Ihrer IDE, und überschreiben Sie die Datei mit folgendem Inhalt:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.2.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>ai-completion-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AICompletion</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.experimental.ai</groupId>
               <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
               <version>0.7.0-SNAPSHOT</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
       <repositories>
           <repository>
               <id>spring-snapshots</id>
               <name>Spring Snapshots</name>
               <url>https://repo.spring.io/snapshot</url>
               <releases>
                   <enabled>false</enabled>
               </releases>
           </repository>
       </repositories>
   </project>
   

2. Öffnen Sie im Ordner src/main/java/com/example/aicompletiondemo AiCompletionApplication.java in Ihrem bevorzugten Editor oder Ihrer IDE, und fügen Sie den folgenden Code ein:

   package com.example.aicompletiondemo;
   
   import java.util.Collections;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.ai.prompt.messages.UserMessage;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class AiCompletionApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiCompletionApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending completion prompt to AI service. One moment please...\r\n"));
   
           final List<Message> msgs =
                   Collections.singletonList(new UserMessage("When was Microsoft founded?"));
   
           final var resps = aiClient.generate(new Prompt(msgs));
   
           System.out.println(String.format("Prompt created %d generated response(s).", resps.getGenerations().size()));
   
           resps.getGenerations().stream()
             .forEach(gen -> {
                 final var role = gen.getInfo().getOrDefault(ROLE_INFO_KEY, MessageType.ASSISTANT.getValue());
   
                 System.out.println(String.format("Generated respose from \"%s\": %s", role, gen.getText()));
             });
       }
   
   }
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Navigieren Sie zurück zum Projektstammordner, und führen Sie die App mithilfe des folgenden Befehls aus:

   ./mvnw spring-boot:run
   

Output

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.5)

2023-11-07T12:47:46.126-06:00  INFO 98687 --- [           main] c.e.a.AiCompletionApplication            : No active profile set, falling back to 1 default profile: "default"
2023-11-07T12:47:46.823-06:00  INFO 98687 --- [           main] c.e.a.AiCompletionApplication            : Started AiCompletionApplication in 0.925 seconds (process running for 1.238)
Sending completion prompt to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Microsoft was founded on April 4, 1975.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Paket (npm) | Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• LTS-Versionen von Node.js
• Die Azure CLI wird für die kennwortlose Authentifizierung in einer lokalen Entwicklungsumgebung verwendet. Erstellen Sie den erforderlichen Kontext, indem Sie sich mit der Azure CLI anmelden.
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo-instruct. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

Installieren der Clientbibliothek

Installieren Sie die erforderlichen Pakete für JavaScript mit npm aus dem Kontext Ihres neuen Verzeichnisses:

npm install openai @azure/identity

Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.

Erstellen einer Beispielanwendung

Öffnen Sie am Ort, an dem Sie das neue Projekt erstellt haben, eine Eingabeaufforderung, und erstellen Sie eine neue Datei mit dem Namen „Completion.js“. Kopieren Sie den folgenden Code in die Datei „Completion.js“.

const { AzureOpenAI } = require("openai");
const { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiVersion = "2024-04-01-preview";
const deployment = "gpt-35-turbo-instruct"; //The deployment name for your completions API model. The instruct model is the only new model that supports the legacy API.

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

const prompt = ["When was Microsoft founded?"];

async function main() {
  console.log("== Get completions Sample ==");

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

  const result = await client.completions.create({ prompt, model: deployment, max_tokens: 128 });

  for (const choice of result.choices) {
    console.log(choice.text);
  }
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

node.exe Completion.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";
const apiVersion = "2024-04-01-preview";
const deployment = "gpt-35-turbo-instruct"; //The deployment name for your completions API model. The instruct model is the only new model that supports the legacy API.

const prompt = ["When was Microsoft founded?"];

async function main() {
  console.log("== Get completions Sample ==");

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

  const result = await client.completions.create({ prompt, model: deployment, max_tokens: 128 });

  for (const choice of result.choices) {
    console.log(choice.text);
  }
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

node.exe Completion.js

Output

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Übersicht über Azure OpenAI
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Paket (npm) | Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• LTS-Versionen von Node.js
• TypeScript
• Die Azure CLI wird für die kennwortlose Authentifizierung in einer lokalen Entwicklungsumgebung verwendet. Erstellen Sie den erforderlichen Kontext, indem Sie sich mit der Azure CLI anmelden.
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo-instruct. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

Installieren der Clientbibliothek

Installieren Sie die erforderlichen Pakete für JavaScript mit npm aus dem Kontext Ihres neuen Verzeichnisses:

npm install openai @azure/identity

Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.

Erstellen einer Beispielanwendung

Öffnen Sie am Ort, an dem Sie das neue Projekt erstellt haben, eine Eingabeaufforderung, und erstellen Sie eine neue Datei mit dem Namen „Completion.ts“. Kopieren Sie den folgenden Code in die Datei „Completion.ts“.

import { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} from "@azure/identity";
import { AzureOpenAI } from "openai";
import { type Completion } from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-35-turbo-instruct";

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

// Chat prompt and max tokens
const prompt = ["When was Microsoft founded?"];
const maxTokens = 128;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function getCompletion(
  client: AzureOpenAI,
  prompt: string[],
  max_tokens: number
): Promise<Completion> {
  return client.completions.create({
    prompt,
    model: "",
    max_tokens,
  });
}
async function printChoices(completion: Completion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.text);
  }
}
export async function main() {
  console.log("== Get completions Sample ==");

  const client = getClient();
  const completion = await getCompletion(client, prompt, maxTokens);
  await printChoices(completion);
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

tsc

node.exe Completion.js

import { AzureOpenAI } from "openai";
import { type Completion } from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-35-turbo-instruct";

// Chat prompt and max tokens
const prompt = ["When was Microsoft founded?"];
const maxTokens = 128;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function getCompletion(
  client: AzureOpenAI,
  prompt: string[],
  max_tokens: number
): Promise<Completion> {
  return client.completions.create({
    prompt,
    model: "",
    max_tokens,
  });
}
async function printChoices(completion: Completion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.text);
  }
}
export async function main() {
  console.log("== Get completions Sample ==");

  const client = getClient();
  const completion = await getCompletion(client, prompt, maxTokens);
  await printChoices(completion);
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

tsc

node.exe Completion.js

Output

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Übersicht über Azure OpenAI
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode der Bibliothek | Paket (PyPi) |

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Python 3.8 oder eine höhere Version
• Die folgenden Python-Bibliotheken: os, requests, json.
• Eine Azure OpenAI Service-Ressource mit einem bereitgestellten gpt-35-turbo-instruct-Modell. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Installieren Sie die OpenAI Python-Clientbibliothek mit:

pip install openai

pip install openai==0.28.1

Abrufen von Schlüssel und Endpunkt

Um erfolgreich einen Aufruf im Azure OpenAI Service auszuführen, benötigen Sie Folgendes:

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Die Werte für Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer neuen Python-Anwendung

1. Erstellen Sie eine neue Python-Datei namens „quickstart.py“. Öffnen Sie diese anschließend in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

2. Ersetzen Sie den Inhalt von „quickstart.py“ durch den folgenden Code. Bearbeiten Sie den Code, und fügen Sie Ihren Schlüssel, Ihren Endpunkt und den Namen Ihrer Bereitstellung hinzu:

import os
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-02-01",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )
    
deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. Use a gpt-35-turbo-instruct deployment. 
    
# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = client.completions.create(model=deployment_name, prompt=start_phrase, max_tokens=10)
print(start_phrase+response.choices[0].text)

import os
import openai

openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
openai.api_type = 'azure'
openai.api_version = '2024-02-01' # this might change in the future

deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 

# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = openai.Completion.create(engine=deployment_name, prompt=start_phrase, max_tokens=10)
text = response['choices'][0]['text'].replace('\n', '').replace(' .', '.').strip()
print(start_phrase+text)

1. Führen Sie die Anwendung mit dem Befehl python für die Schnellstartdatei aus:

   python quickstart.py
   

Output

Die Ausgabe enthält Antworttext nach der Eingabeaufforderung „Write a tagline for an ice cream shop.“. Azure OpenAI hat in diesem Beispiel The coldest ice cream in town! zurückgegeben.

Sending a test completion job
Write a tagline for an ice cream shop. The coldest ice cream in town!

Führen Sie den Code noch einige Male aus, um festzustellen, welche anderen Arten von Antworten Sie erhalten, da die Antworten nicht immer gleich sind.

Verstehen der Ergebnisse

Da unser Beispiel „Write a tagline for an ice cream shop.“ nur wenig Kontext umfasst, ist es normal, dass das Modell nicht immer die erwarteten Ergebnisse zurückgibt. Sie können die maximale Tokenanzahl anpassen, wenn die Antwort unerwartet oder abgeschnitten erscheint.

Azure OpenAI führt außerdem Inhaltsmoderation für die Eingabeaufforderungen und generierten Ausgaben aus. Die Eingabeaufforderungen oder Antworten können gefiltert werden, wenn schädliche Inhalte erkannt werden. Weitere Informationen finden Sie im Artikel zu Inhaltsfiltern.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource selbst oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• In unserem Leitfaden zu Vervollständigungen erfahren Sie mehr darüber, wie Sie Vervollständigungen am besten generieren.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele.

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Python 3.8 oder eine höhere Version
• Die folgenden Python-Bibliotheken: os, requests, json.
• Eine Azure OpenAI-Ressource mit einem bereitgestellten Modell. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Um erfolgreich einen Aufruf für Azure OpenAI auszuführen, benötigen Sie Folgendes:

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Die Werte für Endpunkt und Schlüssel finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

REST-API

Führen Sie in der Bash-Shell die folgenden Befehle aus. Sie müssen gpt-35-turbo-instruct durch den Bereitstellungsnamen ersetzen, den Sie bei der Bereitstellung des gpt-35-turbo-instruct-Modells ausgewählt haben. Die Eingabe des Modellnamens führt zu einem Fehler, es sei denn, Sie haben einen Bereitstellungsnamen ausgewählt, der mit dem zugrunde liegenden Modellnamen identisch ist.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo-instruct/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d "{\"prompt\": \"Once upon a time\"}"

Das Format Ihrer ersten Befehlszeile mit einem Beispielendpunkt würde wie folgt aussehen: curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/completions?api-version=2024-02-01 \. Wenn Sie auf einen Fehler stoßen, überprüfen Sie, ob möglicherweise ein doppelter / an der Trennung zwischen Ihrem Endpunkt und /openai/deployments vorhanden ist.

Wenn Sie diesen Befehl an einer normalen Windows-Eingabeaufforderung ausführen möchten, müssen Sie den Text ändern, um \ und Zeilenumbrüche zu entfernen.

Ausgabe

Die Ausgabe der Vervollständigungs-API sieht wie folgt aus.

{
    "id": "ID of your call",
    "object": "text_completion",
    "created": 1675444965,
    "model": "gpt-35-turbo-instruct",
    "choices": [
        {
            "text": " there lived in a little village a woman who was known as the meanest",
            "index": 0,
            "finish_reason": "length",
            "logprobs": null
        }
    ],
    "usage": {
        "completion_tokens": 16,
        "prompt_tokens": 3,
        "total_tokens": 19
    }
}

Azure OpenAI Service führt außerdem Inhaltsmoderation für die Eingabeaufforderungen und generierten Ausgaben aus. Die Eingabeaufforderungen oder Antworten können gefiltert werden, wenn schädliche Inhalte erkannt werden. Weitere Informationen finden Sie im Artikel zu Inhaltsfiltern.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource selbst oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

• Azure portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• In unserem Leitfaden zu Vervollständigungen erfahren Sie mehr darüber, wie Sie Vervollständigungen am besten generieren.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele.

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Sie können entweder die neueste Version, PowerShell 7, oder Windows PowerShell 5.1 verwenden.
• Eine Azure OpenAI Service-Ressource mit einem bereitgestellten Modell. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Abrufen von Schlüssel und Endpunkt

Um erfolgreich einen Aufruf im Azure OpenAI Service auszuführen, benötigen Sie Folgendes:

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Die Werte für Endpunkt und Schlüssel finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'

$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Erstellen eines neuen PowerShell-Skripts

1. Erstellen Sie eine neue PowerShell-Datei mit dem Namen „quickstart.ps1“. Öffnen Sie diese anschließend in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

2. Ersetzen Sie den Inhalt von quickstart.ps1 durch den folgenden Code. Bearbeiten Sie den Code, und fügen Sie Ihren Schlüssel, Ihren Endpunkt und den Namen Ihrer Bereitstellung hinzu:

   # Azure OpenAI metadata variables
   $openai = @{
       api_key     = $Env:AZURE_OPENAI_API_KEY
       api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
       api_version = '2024-02-01' # this may change in the future
       name        = 'YOUR-DEPLOYMENT-NAME-HERE' #This will correspond to the custom name you chose for your deployment when you deployed a model.
   }
   
   # Completion text
   $prompt = 'Once upon a time...'
   
   # Header for authentication
   $headers = [ordered]@{
       'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
       prompt      = $prompt
       max_tokens  = 10
       temperature = 2
       top_p       = 0.5
   } | ConvertTo-Json
   
   # Send a completion call to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return "$prompt`n$($response.choices[0].text)"
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie die PowerShell-Geheimnisverwaltung mit Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Führen Sie das Skript mit PowerShell aus:

   ./quickstart.ps1
   

Ausgabe

Die Ausgabe enthält Antworttext nach der Eingabeaufforderung „Once upon a time“. Azure OpenAI hat in diesem Beispiel There was a world beyond the mist...where a zurückgegeben.

Once upon a time...
 There was a world beyond the mist...where a

Führen Sie den Code noch einige Male aus, um festzustellen, welche anderen Arten von Antworten Sie erhalten, da die Antworten nicht immer gleich sind.

Verstehen der Ergebnisse

Da unser Beispiel „Once upon a time...“ nur wenig Kontext umfasst, ist es normal, dass das Modell nicht immer die erwarteten Ergebnisse zurückgibt. Sie können die maximale Tokenanzahl anpassen, wenn die Antwort unerwartet oder abgeschnitten erscheint.

Azure OpenAI führt außerdem Inhaltsmoderation für die Eingabeaufforderungen und generierten Ausgaben aus. Die Eingabeaufforderungen oder Antworten können gefiltert werden, wenn schädliche Inhalte erkannt werden. Weitere Informationen finden Sie im Artikel zu Inhaltsfiltern.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource selbst oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

• Azure portal
• Azure PowerShell

Nächste Schritte

• In unserem Leitfaden zu Vervollständigungen erfahren Sie mehr darüber, wie Sie Vervollständigungen am besten generieren.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele.