Guida introduttiva: Introduzione all'uso di GPT-35-Turbo e GPT-4 con il servizio Azure OpenAI

Prerequisiti

• Una sottoscrizione di Azure: crearne una gratuitamente.

• Accesso concesso ad Azure OpenAI nella sottoscrizione di Azure desiderata.

  Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso a OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access. Apri un problema in questo repository per contattare Microsoft in caso di problemi.

• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Passare ad Azure OpenAI Studio

Passare ad Azure OpenAI Studio all'indirizzo https://oai.azure.com/ e accedere con le credenziali che hanno accesso alla risorsa OpenAI. Durante o dopo il flusso di lavoro di accesso, selezionare la directory appropriata, la sottoscrizione di Azure e la risorsa OpenAI di Azure.

Nella pagina di destinazione di Azure OpenAI Studio selezionare Chat playground.From the Azure OpenAI Studio landing page, select Chat playground.

Parco giochi

Iniziare a esplorare le funzionalità OpenAI con un approccio senza codice tramite il playground di Chat di Azure OpenAI Studio. Da questa pagina è possibile eseguire rapidamente l'iterazione e sperimentare le funzionalità.

Configurazione assistente

È possibile usare l'elenco a discesa Configurazione assistente per selezionare alcuni esempi di messaggi di sistema precaricati per iniziare.

I messaggi di sistema forniscono le istruzioni del modello sul comportamento e su qualsiasi contesto a cui deve fare riferimento durante la generazione di una risposta. È possibile descrivere la personalità dell'assistente, dirgli cosa dovrebbe e non deve rispondere e dirgli come formattare le risposte.

Aggiungere esempi di pochi scatti consente di fornire esempi di conversazione usati dal modello per l'apprendimento nel contesto.

In qualsiasi momento, quando si usa il playground chat, è possibile selezionare Visualizza codice per visualizzare esempi di codice Python, curl e json prepopolati in base alle selezioni correnti delle impostazioni e della sessione di chat. È quindi possibile accettare questo codice e scrivere un'applicazione per completare la stessa attività attualmente in esecuzione con il playground.

Sessione chat

Se si seleziona il pulsante Invia , il testo immesso viene inviato all'API dei completamenti e i risultati vengono restituiti alla casella di testo.

Selezionare il pulsante Cancella chat per eliminare la cronologia conversazione corrente.

Impostazione

Mostra pannelli

Per impostazione predefinita sono disponibili tre pannelli: configurazione dell'assistente, sessione di chat e impostazioni. Mostra pannelli consente di aggiungere, rimuovere e riorganizzare i pannelli. Se si chiude un pannello e si deve tornare indietro, usare Mostra pannelli per ripristinare il pannello perso.

Avviare una sessione di chat

1. Nell'elenco a discesa configurazione assistente selezionare Agente di supporto clienti Xbox

2. Verrà chiesto se si vuole aggiornare il messaggio di sistema, selezionare Continua.

3. Nel riquadro sessione di chat immettere la domanda seguente: "Sono interessato all'acquisto di una nuova Xbox" e selezionare Invia.

4. Si riceverà una risposta simile alla seguente:

   

5. Immettere una domanda di completamento, ad esempio: "Quali modelli supportano 4K?"

   

6. Ora che si dispone di una conversazione di base, selezionare Visualizza codice da in Configurazione assistente e si avrà una riproduzione del codice dietro l'intera conversazione fino a questo momento:

#Note: The openai-python library support for Azure OpenAI is in preview.
import os
import openai
openai.api_type = "azure"
openai.api_base = "https://docs-test-001.openai.azure.com/"
openai.api_version = "2024-02-01"
openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
  engine="gpt-35-turbo", # replace this value with the deployment name you chose when you deployed the associated model.
  messages = [{"role":"system","content":"You are an Xbox customer support agent whose primary goal is to help users with issues they are experiencing with their Xbox devices. You are friendly and concise. You only provide factual answers to queries, and do not provide answers that are not related to Xbox."},{"role":"user","content":"How much is a PS5?"},{"role":"assistant","content":"I apologize, but I do not have information about the prices of other gaming devices such as the PS5. My primary focus is to assist with issues regarding Xbox devices. Is there a specific issue you are having with your Xbox device that I may be able to help with?"},{"role":"user","content":"I am interested in buying an Xbox?"},{"role":"assistant","content":"Great! There are several Xbox models available in the market, including the Xbox Series X, Xbox Series S, and Xbox One. The Xbox Series X is the latest and most powerful console, while the Xbox Series S is a more affordable option that still offers great performance. The Xbox One is the previous generation console, but it still has a large library of games available to play.\n\nBefore purchasing an Xbox, you may want to consider factors such as your budget, the types of games you want to play, and whether you want to play games in 4K resolution. Once you have decided on a console, you can purchase it from a retailer or directly from the Xbox website. Let me know if you have any other questions or concerns!"},{"role":"user","content":"Which models are 4K?"},{"role":"assistant","content":"Both the Xbox Series X and Xbox One X support 4K resolution gaming. The Xbox Series S, on the other hand, supports up to 1440p resolution gaming, but it can upscale games to 4K. It's worth noting that in order to take advantage of 4K gaming, you'll need a 4K TV or monitor that supports HDR (High Dynamic Range) and HDMI 2.0 or higher."}],
  temperature=0,
  max_tokens=350,
  top_p=0.95,
  frequency_penalty=0,
  presence_penalty=0,
  stop=None)

Informazioni sulla struttura del prompt

Se si esamina l'esempio da Visualizza codice si noteranno alcuni token univoci che non fanno parte di una tipica chiamata di completamento GPT. GPT-35-Turbo è stato sottoposto a training per usare token speciali per delineare diverse parti del prompt. Il contenuto viene fornito al modello tra <|im_start|> i token e <|im_end|> . Il prompt inizia con un messaggio di sistema che può essere usato per prime il modello includendo il contesto o le istruzioni per il modello. Successivamente, il prompt contiene una serie di messaggi tra l'utente e l'assistente.

La risposta dell'assistente alla richiesta verrà quindi restituita sotto il <|im_start|>assistant token e terminerà con <|im_end|> la denotazione che l'assistente ha terminato la risposta. È anche possibile usare l'interruttore Mostra sintassi non elaborata per visualizzare questi token nel pannello della sessione di chat.

La guida pratica GPT-35-Turbo & GPT-4 fornisce un'introduzione approfondita alla nuova struttura dei prompt e come usare il gpt-35-turbo modello in modo efficace.

Distribuire il modello

Dopo aver soddisfatto l'esperienza in Azure OpenAI Studio, è possibile distribuire un'app Web direttamente da Studio selezionando il pulsante Distribuisci in .

In questo modo è possibile eseguire la distribuzione in un'applicazione Web autonoma o un copilota in Copilot Studio (anteprima) se si usano dati personalizzati nel modello.

Ad esempio, se si sceglie di distribuire un'app Web:

La prima volta che si distribuisce un'app Web, è necessario selezionare Crea una nuova app Web. Scegliere un nome per l'app, che diventerà parte dell'URL dell'app. Ad esempio: https://<appname>.azurewebsites.net.

Selezionare la sottoscrizione, il gruppo di risorse, la località e il piano tariffario per l'app pubblicata. Per aggiornare un'app esistente, selezionare Pubblica in un'app Web esistente e scegliere il nome dell'app precedente dal menu a discesa.

Se si sceglie di distribuire un'app Web, vedere le considerazioni importanti per l'uso.

Pulire le risorse

Dopo aver completato il test del playground chat, se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Altre informazioni su come usare il nuovo gpt-35-turbo modello con la guida pratica GPT-35-Turbo & GPT-4.
• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Pacchetto del codice | sorgente (NuGet) | Modelli| di chat aziendale Recupero generazione aumentata (RAG) |

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio Azure OpenAI nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• .NET 7 SDK
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Creare una nuova applicazione .NET Core

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome azure-openai-quickstart. Questo comando crea un semplice progetto "Hello World" con un singolo file di origine C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

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

Installare la libreria client .NET OpenAI con:

dotnet add package Azure.AI.OpenAI --prerelease

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare un'applicazione di esempio

Dalla directory del progetto aprire il file program.cs e sostituire con il codice seguente:

Senza flusso di risposta

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

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

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

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

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

Console.WriteLine(response.Value.Choices[0].Message.Content);

Console.WriteLine();

dotnet run program.cs

Output

Yes, many of the Azure AI services support customer managed keys. Some examples include Text Analytics, Speech Services, and Translator. However, it's important to note that not all services support customer managed keys, so it's best to check the documentation for each individual service to see if it is supported.

Questa operazione attenderà fino a quando il modello non ha generato l'intera risposta prima di stampare i risultati. In alternativa, se si desidera trasmettere in modo asincrono la risposta e stampare i risultati, è possibile sostituire il contenuto di program.cs con il codice nell'esempio successivo.

Asincrona con streaming

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

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

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

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName= "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

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

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Pacchetti di codice | sorgente (Go)Esempi|

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio Azure OpenAI nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• Passare alla versione 1.21.0 o successiva installata in locale.
• Una risorsa del servizio OpenAI di Azure con il gpt-35-turbo modello distribuito. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare un'applicazione di esempio

Creare un nuovo file denominato chat_completions.go. Copiare il codice seguente nel file chat_completions.go .

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/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
    //modelDeploymentID = deployment name, if model name and deployment name do not match change this value to name chosen when you deployed the model.
	modelDeploymentID := "gpt-35-turbo" 

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

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

	keyCredential, err := azopenai.NewKeyCredential(azureOpenAIKey)

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

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

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

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatMessage{
		// You set the tone and rules of the conversation with a prompt as the system role.
		{Role: to.Ptr(azopenai.ChatRoleSystem), Content: to.Ptr("You are a helpful assistant.")},

		// The user asks a question
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Does Azure OpenAI support customer managed keys?")},

		// The reply would come back from the Azure OpenAI model. You'd add it to the conversation so we can maintain context.
		{Role: to.Ptr(azopenai.ChatRoleAssistant), Content: to.Ptr("Yes, customer managed keys are supported by Azure OpenAI")},

		// The user answers the question based on the latest reply.
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Do other Azure AI services support this too?")},

		// from here you'd keep iterating, sending responses back from the chat completions API
	}

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

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

	for _, choice := range resp.Choices {
		fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
	}

}

Aprire ora un prompt dei comandi ed eseguire:

go mod init chat_completions.go

Esecuzione successiva:

go mod tidy
go run chat_completions.go

Output

Content[0]: Yes, many Azure AI services also support customer managed keys. These services enable you to bring your own encryption keys for data at rest, which provides you with more control over the security of your data.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Codice sorgente Artifact (Maven) | Samples | Retrieval Generation (RAG) enterprise chat template | IntelliJ IDEA |

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio Azure OpenAI nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.

• La versione più recente di Java Development Kit (JDK)

• Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Java

Creare un nuovo progetto Gradle.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Installare Java SDK

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare la configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe OpenAIQuickstart. Importa la libreria di Visione artificiale di Azure.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
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")
}

Creare un'applicazione di esempio

1. Creare un file Java.

   Dalla directory di lavoro eseguire il comando seguente per creare una cartella di origine del progetto:

   mkdir -p src/main/java
   

   Passare alla nuova cartella e creare un file denominato OpenAIQuickstart.java.

2. Aprire OpenAIQuickstart.java nell'editor o nell'IDE preferito e incollare il codice seguente.

   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.ChatChoice;
   import com.azure.ai.openai.models.ChatCompletions;
   import com.azure.ai.openai.models.ChatCompletionsOptions;
   import com.azure.ai.openai.models.ChatMessage;
   import com.azure.ai.openai.models.ChatRole;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GetChatCompletionsSample {
   
       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";
   
         OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<ChatMessage> chatMessages = new ArrayList<>();
           chatMessages.add(new ChatMessage(ChatRole.SYSTEM, "You are a helpful assistant"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Does Azure OpenAI support customer managed keys?"));
           chatMessages.add(new ChatMessage(ChatRole.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Do other Azure AI services support this too?"));
   
           ChatCompletions chatCompletions = client.getChatCompletions(deploymentOrModelId, new ChatCompletionsOptions(chatMessages));
   
           System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
           for (ChatChoice choice : chatCompletions.getChoices()) {
               ChatMessage 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());
           }
   
           System.out.println();
           CompletionsUsage usage = chatCompletions.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());
       }
   }  
   

   Importante

   Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

3. Tornare alla cartella radice del progetto e compilare l'app con:

   gradle build
   

   Eseguirlo quindi con il gradle run comando :

   gradle run
   

Output

Model ID=chatcmpl-7JYnyE4zpd5gaIfTRH7hNpeVsvAw4 is created at 1684896378.
Index: 0, Chat Role: assistant.
Message:
Yes, most of the Azure AI services support customer managed keys. However, there may be some exceptions, so it is best to check the documentation of each specific service to confirm.

Usage: number of prompt token is 59, number of completion token is 36, and number of total tokens in request and response is 95.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Esempio di artefatti del codice | sorgente (Maven) |

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio Azure OpenAI nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• La versione più recente di Java Development Kit (JDK)
• Strumento dell'interfaccia della riga di comando di Spring Boot
• Una risorsa del servizio OpenAI di Azure con il gpt-35-turbo modello distribuito. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Spring

Creare un nuovo progetto Spring.

In una finestra Bash creare una nuova directory per l'app e passare a essa.

mkdir ai-chat-demo && cd ai-chat-demo

Eseguire il comando spring init dalla directory di lavoro. Questo comando crea una struttura di directory standard per il progetto Spring, incluso il file di origine della classe Java principale e il file di pom.xml usato per la gestione dei progetti basati su Maven.

spring init -a ai-chat-demo -n AIChat --force --build maven -x

I file e le cartelle generati sono simili alla struttura seguente:

ai-chat-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aichatdemo/
    |                   |-- AiChatApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aichatdemo/
                        |-- AiChatApplicationTests.java

Modificare l'applicazione Spring

1. Modificare il file pom.xml.

   Dalla radice della directory del progetto aprire il file pom.xml nell'editor o nell'IDE preferito e sovrascrivere il file con il contenuto seguente:

   <?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-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</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. Dalla cartella src/main/java/com/example/aichatdemo aprire AiChatApplication.java nell'editor o nell'IDE preferito e incollare il codice seguente:

   package com.example.aichatdemo;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.ChatMessage;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   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 AiChatApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiChatApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending chat prompts to AI service. One moment please...\r\n"));
   
           final List<Message> msgs = new ArrayList<>();
   
           msgs.add(new ChatMessage(MessageType.SYSTEM, "You are a helpful assistant"));
           msgs.add(new ChatMessage(MessageType.USER, "Does Azure OpenAI support customer managed keys?"));
           msgs.add(new ChatMessage(MessageType.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           msgs.add(new ChatMessage(MessageType.USER, "Do other Azure AI services support this too?"));
   
           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()));
             });
       }
   
   }
   

   Importante

   Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

3. Tornare alla cartella radice del progetto ed eseguire l'app usando il comando seguente:

   ./mvnw spring-boot:run
   

Output

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

2023-11-07T13:31:10.884-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : No active profile set, falling back to 1 default profile: "default"
2023-11-07T13:31:11.595-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : Started AiChatApplication in 0.994 seconds (process running for 1.28)
Sending chat prompts to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Yes, other Azure AI services also support customer managed keys. Azure AI Services, Azure Machine Learning, and other AI services in Azure provide options for customers to manage and control their encryption keys. This allows customers to have greater control over their data and security.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Pacchetto del codice | sorgente (npm) | Modello | di chat aziendale Recupero generazione aumentata (RAG)|

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio Azure OpenAI nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• Versioni LTS di Node.js
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare un'applicazione Node

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app. Eseguire quindi il npm init comando per creare un'applicazione node con un file package.json .

npm init

Installare la libreria client

Installare la libreria client OpenAI di Azure per JavaScript con npm:

npm install @azure/openai

Il file di package.json dell'app verrà aggiornato con le dipendenze.

Creare un'applicazione di esempio

Aprire un prompt dei comandi in cui si vuole il nuovo progetto e creare un nuovo file denominato ChatCompletion.js. Copiare il codice seguente nel file ChatCompletion.js.

const { OpenAIClient, AzureKeyCredential } = require("@azure/openai");
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] ;
const azureApiKey = process.env["AZURE_OPENAI_API_KEY"] ;

const messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
  { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI" },
  { role: "user", content: "Do other Azure AI services support this too" },
];

async function main() {
  console.log("== Chat Completions Sample ==");

  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));
  const deploymentId = "gpt-35-turbo";
  const result = await client.getChatCompletions(deploymentId, messages);

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

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

Eseguire lo script con il comando seguente:

node.exe ChatCompletion.js

Output

== Chat Completions Sample ==
{
  role: 'assistant',
  content: 'Yes, most Azure AI services support customer managed keys. It is always best to check the specific service documentation to confirm this.'
}

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Panoramica di Azure OpenAI
• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Pacchetto del codice | sorgente della libreria (PyPi) | Recupero del modello di chat aziendale (RAG) |

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio OpenAI di Azure nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• Python 3.8 o versione successiva.
• Le librerie Python seguenti: os.
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Installare la libreria client Python OpenAI con:

pip install openai

pip install openai==0.28.1

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Python

1. Creare un nuovo file Python denominato quickstart.py. Aprirlo quindi nell'editor o nell'IDE preferito.

2. Sostituire il contenuto di quickstart.py con il codice seguente.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

3. Eseguire l'applicazione con il comando nel python file di avvio rapido:

   python quickstart.py
   

Output

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.",
        "role": "assistant"
      }
    }
  ],
  "created": 1679001781,
  "id": "chatcmpl-6upLpNYYOx2AhoOYxl9UgJvF4aPpR",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 39,
    "prompt_tokens": 58,
    "total_tokens": 97
  }
}
Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.

Informazioni sulla struttura dei messaggi

I modelli GPT-35-Turbo e GPT-4 sono ottimizzati per lavorare con gli input formattati come conversazione. La messages variabile passa una matrice di dizionari con ruoli diversi nella conversazione delineata da sistema, utente e assistente. Il messaggio di sistema può essere usato per prime il modello includendo il contesto o le istruzioni su come deve rispondere il modello.

La guida pratica GPT-35-Turbo & GPT-4 fornisce un'introduzione approfondita alle opzioni per la comunicazione con questi nuovi modelli.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Altre informazioni su come usare i modelli GPT-35-Turbo e GPT-4 con la guida pratica.
• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Specifica dell'API REST |

Prerequisiti

• Una sottoscrizione di Azure: crearne una gratuitamente.
• Accesso concesso al servizio OpenAI di Azure nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, è necessario un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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

In una shell bash eseguire il comando seguente. Sarà necessario sostituire gpt-35-turbo con il nome di distribuzione scelto quando sono stati distribuiti i modelli GPT-35-Turbo o GPT-4. Se si immette il nome del modello, verrà generato un errore, a meno che non si sia scelto un nome di distribuzione identico al nome del modello sottostante.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo/chat/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{"messages":[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},{"role": "user", "content": "Do other Azure AI services support this too?"}]}'

Il formato della prima riga del comando con un endpoint di esempio viene visualizzato come indicato di seguito curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \ Se si verifica un errore double check per assicurarsi di non disporre di un raddoppio di in corrispondenza della / separazione tra l'endpoint e /openai/deployments.

Se si desidera eseguire questo comando in un normale prompt dei comandi di Windows, è necessario modificare il testo per rimuovere le interruzioni di \ riga e .

Output

{"id":"chatcmpl-6v7mkQj980V1yBec6ETrKPRqFjNw9",
"object":"chat.completion","created":1679072642,
"model":"gpt-35-turbo",
"usage":{"prompt_tokens":58,
"completion_tokens":68,
"total_tokens":126},
"choices":[{"message":{"role":"assistant",
"content":"Yes, other Azure AI services also support customer managed keys. Azure AI services offer multiple options for customers to manage keys, such as using Azure Key Vault, customer-managed keys in Azure Key Vault or customer-managed keys through Azure Storage service. This helps customers ensure that their data is secure and access to their services is controlled."},"finish_reason":"stop","index":0}]}

La formattazione dell'output regolata per facilitare la lettura, l'output effettivo è un singolo blocco di testo senza interruzioni di riga.

Informazioni sulla struttura dei messaggi

I modelli GPT-35-Turbo e GPT-4 sono ottimizzati per lavorare con gli input formattati come conversazione. La messages variabile passa una matrice di dizionari con ruoli diversi nella conversazione delineata da sistema, utente e assistente. Il messaggio di sistema può essere usato per prime il modello includendo il contesto o le istruzioni su come deve rispondere il modello.

La guida pratica GPT-35-Turbo & GPT-4 fornisce un'introduzione approfondita alle opzioni per la comunicazione con questi nuovi modelli.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Altre informazioni su come usare i modelli GPT-35-Turbo e GPT-4 con la guida pratica.
• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Accesso concesso al servizio OpenAI di Azure nella sottoscrizione di Azure desiderata. Attualmente, l'accesso a questo servizio viene concesso solo dall'applicazione. È possibile richiedere l'accesso al servizio OpenAI di Azure completando il modulo all'indirizzo https://aka.ms/oai/access.
• È possibile usare la versione più recente, PowerShell 7 o Windows PowerShell 5.1.
• Una risorsa del servizio OpenAI di Azure con un modello distribuito. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.
• Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per altre informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. L'endpoint e le chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso perché saranno necessari entrambi per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Variabili di ambiente

$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

Creare un nuovo script di PowerShell

1. Creare un nuovo file di PowerShell denominato quickstart.ps1. Aprirlo quindi nell'editor o nell'IDE preferito.

2. Sostituire il contenuto di quickstart.ps1 con il codice seguente. È necessario impostare la engine variabile sul nome della distribuzione scelto durante la distribuzione dei modelli GPT-35-Turbo o GPT-4. Se si immette il nome del modello, verrà generato un errore, a meno che non si sia scelto un nome di distribuzione identico al nome del modello sottostante.

   # 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
   $messages = @()
   $messages += @{
     role = 'system'
     content = 'You are a helpful assistant.'
   }
   $messages += @{
     role = 'user'
     content = 'Does Azure OpenAI support customer managed keys?'
   }
   $messages += @{
     role = 'assistant'
     content = 'Yes, customer managed keys are supported by Azure OpenAI.'
   }
   $messages += @{
     role = 'user'
     content = 'Do other Azure AI services support this too?'
   }
   
   # Header for authentication
   $headers = [ordered]@{
      'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
      messages = $messages
   } | ConvertTo-Json
   
   # Send a request to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/chat/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response
   

   Importante

   Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio La gestione dei segreti di PowerShell con Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

3. Eseguire lo script con PowerShell:

   ./quickstart.ps1
   

Output

# the output of the script will be a .NET object containing the response
id      : chatcmpl-7sdJJRC6fDNGnfHMdfHXvPkYFbaVc
object  : chat.completion
created : 1693255177
model   : gpt-35-turbo
choices : {@{index=0; finish_reason=stop; message=}}
usage   : @{completion_tokens=67; prompt_tokens=55; total_tokens=122}

# convert the output to JSON
./quickstart.ps1 | ConvertTo-Json -Depth 3

# or to view the text returned, select the specific object property
$reponse = ./quickstart.ps1
$response.choices.message.content

Informazioni sulla struttura dei messaggi

I modelli GPT-35-Turbo e GPT-4 sono ottimizzati per lavorare con gli input formattati come conversazione. La messages variabile passa una matrice di dizionari con ruoli diversi nella conversazione delineata da sistema, utente e assistente. Il messaggio di sistema può essere usato per prime il modello includendo il contesto o le istruzioni su come deve rispondere il modello.

La guida pratica GPT-35-Turbo & GPT-4 fornisce un'introduzione approfondita alle opzioni per la comunicazione con questi nuovi modelli.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Portale
• Azure PowerShell

Passaggi successivi

• Altre informazioni su come usare i modelli GPT-35-Turbo e GPT-4 con la guida pratica.
• Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI