Esercizio: Installare .NET SDK per Azure OpenAI e creare la prima app

10 minuti

Dopo aver compreso i completamenti di testo e chat, è possibile creare un'applicazione di base che li usa.

Si lavora per un'organizzazione che aiuta gli escursionisti a esplorare le aree all'aperto consigliando sentieri. Si sta valutando l'aggiunta di un'intelligenza artificiale conversazionale alla funzionalità di raccomandazione e si vuole creare un prototipo.

Si decide di usare l'API Completamento chat fornita dal modello GPT-35-Turbo.

Creare la risorsa OpenAI di Azure

Il primo passaggio consiste nel creare la risorsa OpenAI di Azure e distribuire il modello. In questo esercizio si userà il modello GPT-3 Turbo. Come indicato nella documentazione, GPT-3.5 Turbo usa l'API Completamento chat ed è ideale per il nostro caso d'uso.

Prerequisiti

Una sottoscrizione di Azure
Accesso concesso a OpenAI di Azure nella sottoscrizione 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.
Interfaccia della riga di comando di Azure installata

Creare una risorsa e distribuire un modello

La creazione della risorsa e la distribuzione del modello sono un processo in più passaggi. Usare l'interfaccia della riga di comando di Azure perché può essere più veloce rispetto al portale di Azure. Si noti tuttavia che è possibile usare il portale di Azure, se lo si desidera.

Eseguire il comando az login per accedere se non è già stato fatto.
Quando si crea una nuova risorsa di Azure, è possibile usare un gruppo di risorse esistente o crearne uno nuovo. Questo comando illustra come creare un nuovo gruppo di risorse. Usare il nome HikingConversations-RG, ma è possibile sostituire il nome desiderato o usare il nome di un gruppo esistente.
```
az group create \
--name HikingConversations-RG \
--location eastus
```
```
az group create `
--name HikingConversations-RG `
--location eastus
```

Eseguire il comando seguente per creare una risorsa OpenAI nel gruppo di risorse HikingConversations-RG. Denominare la risorsa OpenAI HikingConversationsAI.

az cognitiveservices account create \
-n HikingConversationsAI \
-g HikingConversations-RG \
-l eastus \
--kind OpenAI \
--sku s0

az cognitiveservices account create `
-n HikingConversationsAI `
-g HikingConversations-RG `
-l eastus `
--kind OpenAI `
--sku s0

Si vuole quindi distribuire il modello GPT-35-Turbo nella risorsa OpenAI creata. Chiamare la distribuzione del modello HikingRecommendationTurbo. Si noti che si usano HikingConversations-RG come nome del gruppo di risorse e HikingConversationsAI come nome della risorsa OpenAI. Se sono stati usati valori diversi, assicurarsi di sostituire tali valori.

az cognitiveservices account deployment create \
-g HikingConversations-RG \
-n HikingConversationsAI \
--deployment-name HikingRecommendationTurbo \
--model-name gpt-35-turbo \
--model-version "0301" \
--model-format OpenAI \
--scale-settings-scale-type "Standard"

az cognitiveservices account deployment create `
-g HikingConversations-RG `
-n HikingConversationsAI `
--deployment-name HikingRecommendationTurbo `
--model-name gpt-35-turbo `
--model-version "0301" `
--model-format OpenAI `
--scale-settings-scale-type "Standard"

Dopo aver creato la risorsa e il modello, è necessario ottenere l'URL di base e le chiavi di accesso in modo che .NET SDK possa accedere alla risorsa OpenAI di Azure. Usare questi comandi per ottenere l'endpoint e le chiavi API primarie e prenderne nota per usarli in un secondo momento:

L'endpoint

az cognitiveservices account show \
-g HikingConversations-RG \
-n HikingConversationsAI \
--query "properties.endpoint"

az cognitiveservices account show `
-g HikingConversations-RG `
-n HikingConversationsAI `
--query "properties.endpoint"

La chiave API primaria

az cognitiveservices account keys list \
-g HikingConversations-RG \
-n HikingConversationsAI \
--query "key1"

az cognitiveservices account keys list `
-g HikingConversations-RG `
-n HikingConversationsAI `
--query "key1"

Creare l'applicazione console e aggiungere l'SDK di OpenAI

Successivamente si vuole creare un'applicazione console .NET essenziale e aggiungere Azure OpenAI SDK.

Eseguire quanto segue per creare una nuova applicazione.NET denominata HikingConversationsAI.
```
dotnet new console -n HikingConversationsAI
```
Passare alla directory HikingConversationsAI appena creata.
```
cd HikingConversationsAI
```

Aggiungere quindi l'SDK di OpenAI di Azure.

dotnet add package Azure.AI.OpenAI --prerelease

Aprire il progetto in Visual Studio Code o Visual Studio.
Nel file Program.cs eliminare tutto il codice esistente.
Aggiungere using Azure.AI.OpenAI; all'inizio del file Program.cs.
Aggiungere using Azure; all'inizio del file Program.cs.
Aggiungere tre variabili a livello di classe che contengono riferimenti all'endpoint della risorsa OpenAI di Azure, alla chiave API primaria e al nome del modello distribuito.
```
string openAIEndpoint = "<YOUR ENDPOINT URL VALUE>";
string openAIAPIKey = "<YOUR PRIMARY API KEY VALUE>";
string openAIDeploymentName = "HikingRecommendationTurbo";
```
Nei passaggi precedenti è stata denominata la distribuzione HikingRecommendationTurbo, se è stato usato un valore diverso, assicurarsi di usare quello al suo posto.

Creare infine un'istanza della classe necessaria per comunicare con la risorsa OpenAI di Azure.

var endpoint = new Uri(openAIEndpoint);
var credentials = new AzureKeyCredential(openAIAPIKey);
var openAIClient = new AzureOpenAIClient(endpoint, credentials);

Creare il prompt di sistema

Verrà ora creato il prompt iniziale del ruolo di sistema che fornirà le istruzioni iniziali al modello.

Creare prima di tutto la richiesta che indica al modello come si vuole che agisca durante la conversazione quando si consigliano escursioni.

var systemPrompt = 
"""
You are a hiking enthusiast who helps people discover fun hikes. You are upbeat and friendly. 
You ask people what type of hikes they like to take and then suggest some.
""";

Creare quindi un oggetto List<ChatMessage> per contenere tutti i messaggi che verranno inviati da e verso il modello.
```
List<ChatMessage> chatHistory = new();
```
Creare quindi un nuovo oggetto SystemChatMessage e aggiungerlo all'elenco chatHistory. Verrà impostato l'oggetto ChatMessage con provenienza dal ruolo Sistema.
```
SystemChatMessage systemMessage = ChatMessage.CreateSystemMessage(systemPrompt);

chatHistory.Add(systemMessage);
```

Avviare la conversazione

Successivamente si invierà il primo messaggio al modello, avviando la conversazione.

Creare una richiesta per l'utente e aggiungerla a chatHistory come messaggio utente.

string userGreeting = """
Hi there hiking recommendation bot! 
Can't wait to hear what you have in store for me!
""";

UserChatMessage userGreetingMessage = ChatMessage.CreateUserMessage(userGreeting);
chatHistory.Add(userGreetingMessage);

Console.WriteLine($"User >>> {userGreeting}");

È ora necessario ottenere un riferimento all'oggetto ChatClient. Questo oggetto è responsabile della facilitazione delle conversazioni di chat con il modello. Di conseguenza, è necessario indicare all'oggetto client Azure OpenAI quale modello distribuito si vuole usare.
```
var chatClient = openAIClient.GetChatClient(openAIDeploymentName);
```
Chiamare quindi la funzione CompleteChatAsync della classe ChatClient passando chatHistory.
```
var response = await chatClient.CompleteChatAsync(chatHistory);
```

Infine, leggere il valore restituito dal modello.

Console.WriteLine($"AI >>> {response.Value.Content.Last().Text}");

Vediamo cosa abbiamo finora, è possibile eseguire l'applicazione immettendo dotnet run nel terminale.
Sperimentare modificando il valore di userGreetingMessage per vedere come il modello può rispondere in modo diverso.

In un'esecuzione di esempio è stato ricevuto quanto segue:

Hello! Great to hear from you. What type of hikes are you interested in? Do you enjoy easy scenic walks, challenging trails, or something in between? Do you prefer hikes with waterfalls, mountain views, or unique geological formations?

È possibile ricevere qualcosa di diverso perché il modello non è deterministico o può produrre un output diverso anche con lo stesso input.

Continuare la conversazione

Continuare rispondendo alla conversazione e quindi inviando la risposta.

Assicurarsi di mantenere il contesto della conversazione, quindi aggiungere la risposta restituita direttamente all'elenco chatHistory.

var assistantMessage = ChatMessage.CreateAssistantMessage(response.Value.Content.Last().Text);

chatHistory.Add(assistantMessage);

Creare quindi un'altra richiesta utente e inviarla al modello.

var hikeRequest = 
"""
I would like a strenuous hike near where I live that ends with
a view that is amazing.
""";

Console.WriteLine($"User >>> {hikeRequest}");

UserChatMessage hikeMessage = ChatMessage.CreateUserMessage(hikeRequest);

chatHistory.Add(hikeMessage);

response = await chatClient.CompleteChatAsync(chatHistory); 

Console.WriteLine($"AI >>> {response.Value.Content.Last().Text}");

È possibile sperimentare modificando la variabile hikeRequest per richiedere diversi tipi di escursioni. In un'esecuzione di esempio è stato ricevuto:

Great choice! If you're up for a challenge, I recommend checking out the hike to Poo Poo Point in Issaquah, Washington. The hike is 7.2 miles roundtrip, with an elevation gain of 1,858 feet, so it's definitely a workout. But the stunning views of Mount Rainier and the Cascade Mountains make it all worthwhile. Plus, you'll get to see paragliders taking off from Poo Poo Point. It's a popular hike, so I recommend going early to avoid crowds. Let me know if you need more information!

Riepilogo

È ora possibile usare Azure OpenAI SDK insieme al modello gpt-35-turbo per creare conversazioni che consentono di fornire consigli per l'escursionismo. Verrà ora illustrato come migliorare le richieste inviate al modello.

Continua