Avvio rapido: Introduzione all'uso di GPT-35-Turbo e GPT-4 con il Servizio OpenAI di Azure

Articolo
05/22/2024

Leggere questo articolo per iniziare a usare OpenAI di Azure.

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 ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Suggerimento

Provare la nuova soluzione unificata di Azure AI Studio (anteprima) che riunisce le funzionalità tra più servizi di intelligenza artificiale di Azure.

Passa ad Azure OpenAI Studio

Passare a OpenAI Studio di Azure su https://oai.azure.com/ e accedere con le credenziali di 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 Playground chat.

Playground

Iniziare a esplorare le funzionalità OpenAI con un approccio senza codice tramite il playground 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 al modello le istruzioni sul comportamento e su qualsiasi contesto a cui deve fare riferimento durante la generazione di una risposta. È possibile descrivere la personalità dell'assistente, definire cosa deve e non deve rispondere e come formattare le risposte.

Aggiungi alcuni esempi 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 alla sessione di chat corrente e alle impostazioni selezionate. È quindi possibile utilizzare 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 della conversazione corrente.

Impostazione

Nome	Descrizione
Deployments	Nome della distribuzione associata a un modello specifico.
Temperatura	Controlla la casualità. Abbassando la temperatura, il modello produce risposte più ripetitive e deterministiche. Aumentando la temperatura, vengono generate risposte più impreviste o creative. Provare a regolare la temperatura o Top P, ma non entrambi i parametri.
Lunghezza massima (token)	Impostare un limite per il numero di token per risposta al modello. L'API supporta un massimo di 4096 token, tra prompt (inclusi messaggi di sistema, esempi, cronologia dei messaggi e query utente) e risposta del modello. Ogni token consiste approssimativamente in quattro caratteri per il testo tipico in inglese.
Probabilità principali	Analogamente alla temperatura, controlla la casualità, ma usa un metodo diverso. Abbassando Top P, la selezione di token del modello si restringe ai token più probabili. Aumentando Top P, il modello sceglie tra i token con probabilità alta e bassa. Provare a regolare la temperatura o Top P, ma non entrambi i parametri.
Conversazioni a più turni	Selezionare il numero di messaggi precedenti da includere in ogni nuova richiesta API. Ciò consente di fornire il contesto del modello per le nuove query utente. Impostando questo numero a 10, si ottengono cinque query utente e cinque risposte del sistema.
Sequenze di interruzione	La sequenza di interruzione fa in modo che il modello termini la risposta in un punto desiderato. La risposta del modello termina prima della sequenza specificata, quindi non conterrà il testo della sequenza di interruzione. Per GPT-35-Turbo, l'uso di `<\|im_end\|>` garantisce che la risposta del modello non generi una query utente di follow-up. È possibile includere fino a quattro sequenze di interruzione.

Mostra pannelli

Per impostazione predefinita sono disponibili tre pannelli: configurazione assistente, sessione 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

Nell'elenco a discesa configurazione assistente selezionare Agente di supporto clienti Xbox
Verrà chiesto se si vuole aggiornare il messaggio di sistema, selezionare Continua.
Nel riquadro sessione chat immettere la domanda seguente: "Sono interessato all'acquisto di una nuova Xbox" e selezionare Invia.
Si riceverà una risposta simile alla seguente:
Immettere una domanda di follow-up, ad esempio: "Quali modelli supportano 4K?"
Ora che si dispone di una conversazione di base, selezionare Visualizza codice in Configurazione assistente e si avrà una riproduzione del codice alla base dell'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)

Si è verificato un problema con il playground.

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 addestrato all’uso di token speciali per delineare diverse parti del prompt. Il contenuto viene fornito al modello tra i token <|im_start|> e <|im_end|>. Il prompt inizia con un messaggio di sistema che può essere usato per avviare 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 token <|im_start|>assistant e terminerà con <|im_end|>, che indica che l'assistente ha terminato la risposta. È inoltre 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

Una volta soddisfatti dell'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 del suo URL. 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.

Si è verificato un problema con la distribuzione del modello.

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.

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 OpenAI di Azure

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

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Accesso consentito 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.
L’SDK .NET 7
Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

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, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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 in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi 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"

Si è verificato un problema di configurazione.

Creare un’applicazione di esempio

Dalla directory del progetto aprire il file program.cs e sostituirlo 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();

Importante

Per la produzione, usare un metodo sicuro per l'archiviazione e l'accesso alle proprie credenziali, ad esempio Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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 dell'esempio successivo.

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

Si è verificato un problema durante l'esecuzione dei codici di esempio.

Pulire le risorse

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

Passaggi successivi

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

Pacchetti di codice | sorgente (Go)Esempi|

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Accesso consentito 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.
Passare alla versione 1.21.0 o successiva installata in locale.
Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo distribuito. Per ulteriori 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, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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

}

Importante

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 ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

Passaggi successivi

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

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

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Accesso consentito 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.

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 ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Impostazione

Recuperare la chiave e l'endpoint

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

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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.

Si è verificato un problema di configurazione.

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

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.

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

Tornare alla cartella radice del progetto e compilare l'app con:
```
gradle build
```
Eseguirlo quindi con il comando gradle run:
```
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.

Si è verificato un problema durante l'esecuzione del codice di esempio.

Pulire le risorse

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

Passaggi successivi

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

Esempio di artefatti del codice | sorgente (Maven) |

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Accesso consentito 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.
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 modello gpt-35-turbo distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Impostazione

Recuperare la chiave e l'endpoint

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

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Variabili di ambiente

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

Nota

Spring AI imposta per impostazione predefinita il nome del modello su gpt-35-turbo. È necessario specificare il SPRING_AI_AZURE_OPENAI_MODEL valore solo se è stato distribuito un modello con un nome diverso.

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"

Si è verificato un problema di configurazione.

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

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>

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

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.

Si è verificato un problema durante l'esecuzione del codice di esempio.

Pulire le risorse

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

Passaggi successivi

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

Codice sorgente | Pacchetto (npm) | Esempi

Nota

Questo articolo è stato aggiornato per usare il pacchetto npm OpenAI più recente che ora supporta completamente Azure OpenAI. Se si stanno cercando esempi di codice per l'SDK JavaScript OpenAI di Azure legacy, attualmente sono ancora 1 disponibili in questo repository.

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Accesso consentito 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.
Versioni LTS di Node.js
Una risorsa del servizio OpenAI di Azure con modelli di serie gpt-35-turbo o gpt-4 distribuiti. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Impostazione

Recuperare la chiave e l'endpoint

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

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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.

Installare la libreria client

Installare i pacchetti necessari per JavaScript con npm dal contesto della nuova directory:

npm install openai dotenv @azure/identity

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

Si è verificato un problema di configurazione.

Creare un’applicazione di esempio

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

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

// Load the .env file if it exists
const dotenv = require("dotenv");
dotenv.config();

// 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-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.
require("dotenv/config");

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, apiVersion, deployment });
  const result = await client.chat.completions.create({
    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?" },
    ],
    model: "",
  });

  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 ==
{
  content: 'Yes, several other Azure AI services also support customer managed keys for enhanced security and control over encryption keys.',
  role: 'assistant'
}

Microsoft Entra ID

Importante

Nell'esempio precedente viene mostrata l'autenticazione basata su chiave. Dopo aver testato correttamente l'autenticazione basata su chiave, è consigliabile usare l'ID Microsoft Entra più sicuro per l'autenticazione, illustrato nell'esempio di codice successivo. Per iniziare a usare [Microsoft Entra ID] sono necessari alcuni prerequisiti aggiuntivi.

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

// Set AZURE_OPENAI_ENDPOINT to the endpoint of your
// OpenAI resource. You can find this in the Azure portal.
// Load the .env file if it exists
require("dotenv/config");

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

  const scope = "https://cognitiveservices.azure.com/.default";
  const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
  const deployment = "gpt-35-turbo";
  const apiVersion = "2024-04-01-preview";
  const client = new AzureOpenAI({ azureADTokenProvider, deployment, apiVersion });
  const result = await client.chat.completions.create({
    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?" },
    ],
    model: "",
  });

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

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

module.exports = { main };

Nota

Se si riceve l'errore: Errore: OpenAIError: gli apiKey argomenti e azureADTokenProvider si escludono a vicenda; è possibile passare solo uno alla volta. Potrebbe essere necessario rimuovere una variabile di ambiente preesistente per la chiave API dal sistema. Anche se l'esempio di codice Microsoft Entra ID non fa riferimento in modo esplicito alla variabile di ambiente della chiave API, se presente nel sistema che esegue questo esempio, questo errore verrà comunque generato.

Si è verificato un problema durante l'esecuzione del codice di esempio.

Pulire le risorse

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

Passaggi successivi

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

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 ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Impostazione

Installare la libreria client Python OpenAI con:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai

Nota

La versione della libreria Python OpenAI 0.28.1 è deprecata. Ti consigliamo di usare 1.x. Vedere la Guida alla migrazione per informazioni sul passaggio da 0.28.1 a 1.x.

pip install openai==0.28.1

Nota

Questa libreria è gestita da OpenAI ed è attualmente in anteprima. Fare riferimento alla cronologia delle versioni o alla cronologia di commit di version.py per tenere traccia degli ultimi aggiornamenti apportati alla libreria.

Recuperare la chiave e l'endpoint

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

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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"

Si è verificato un problema di configurazione.

Creare una nuova applicazione Python

Creare un nuovo file Python denominato quickstart.py. Quindi, aprirlo nell'editor o nell'IDE preferito.
Sostituire il contenuto di quickstart.py con il codice seguente.

OpenAI Python 1.x
OpenAI Python 0.28.1

È necessario impostare la variabile model sul nome della distribuzione scelto quando sono stati distribuiti i modelli GPT-3.5-Turbo o GPT-4. Se si immette il nome del modello, verrà generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante.

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)

È necessario impostare la variabile engine sul nome della distribuzione scelto quando sono stati distribuiti i modelli GPT-3.5-Turbo o GPT-4. Se si immette il nome del modello, verrà generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante.

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

Importante

Eseguire l'applicazione con il comando python nel 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.

Si è verificato un problema durante l'esecuzione del codice di esempio.

Informazioni sulla struttura dei messaggi

I modelli GPT-35-Turbo e GPT-4 sono ottimizzati per lavorare con gli input formattati come conversazione. La variabile messages passa una matrice di dizionari con ruoli diversi nella conversazione delineata da sistema, utente e assistente. Il messaggio di sistema può essere usato per avviare 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 ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

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 OpenAI di Azure

Specifica dell'API REST |

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.
Una risorsa del servizio OpenAI di Azure con o gpt-35-turbo i gpt-4 modelli distribuiti. Per ulteriori 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, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

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"

Si è verificato un problema con la configurazione.

REST API

Nella 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 sia stato scelto un nome di distribuzione identico a quello 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, ricontrollare per assicurarsi che non vi sia un raddoppiamento 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 \.

Importante

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

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

Si è verificato un problema durante l'esecuzione del codice di esempio.

Informazioni sulla struttura dei messaggi

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 ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

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 OpenAI di Azure

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 ulteriori 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 ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Si è verificato un problema con i prerequisiti.

Recuperare la chiave e l'endpoint

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

Nome variabile	Valore
`ENDPOINT`	Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. In alternativa, è possibile trovare il valore in OpenAI Studio di Azure>Playground>Visualizzazione codice. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. Endpoint e Chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi 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

Si è verificato un problema di configurazione.

Creare un nuovo script di PowerShell

Creare un nuovo file di PowerShell denominato quickstart.ps1. Quindi, aprirlo nell'editor o nell'IDE preferito.

Sostituire il contenuto di quickstart.ps1 con il codice seguente. È necessario impostare la variabile engine sul nome della 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 sia stato scelto un nome di distribuzione identico a quello 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.

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

Si è verificato un problema durante l'esecuzione del codice di esempio.

Informazioni sulla struttura dei messaggi

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 ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

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 OpenAI di Azure

Share via

Avvio rapido: Introduzione all'uso di GPT-35-Turbo e GPT-4 con il Servizio OpenAI di Azure

Prerequisiti

Passa ad Azure OpenAI Studio

Playground

Configurazione assistente

Sessione chat

Impostazione

Mostra pannelli

Avviare una sessione di chat

Informazioni sulla struttura del prompt

Distribuire il modello

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Creare una nuova applicazione .NET Core

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare un’applicazione di esempio

Senza flusso di risposta

Output

Asincrono con streaming

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare un’applicazione di esempio

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Java

Installare Java SDK

Creare un’applicazione di esempio

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Spring

Modificare l'applicazione Spring

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare un'applicazione Node

Installare la libreria client

Creare un’applicazione di esempio

Output

Microsoft Entra ID

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Python

Output

Informazioni sulla struttura dei messaggi

Pulire le risorse

Passaggi successivi

Prerequisiti

Impostazione

Recuperare la chiave e l'endpoint

Variabili di ambiente

REST API

Output

Informazioni sulla struttura dei messaggi

Pulire le risorse