Exercício: Instalar o SDK do .NET para o OpenAI do Azure e criar seu primeiro aplicativo

10 minutos

Agora que conseguimos entender os preenchimentos de texto e chat, vamos criar um aplicativo básico que usa esse recurso.

Você trabalha para uma organização que ajuda praticantes de caminhadas a explorar o ar livre recomendando trilhas. Você está pensando em adicionar uma IA de conversação ao recurso de recomendação e gostaria de criar um protótipo.

Você decidiu que precisa usar a API de Preenchimento de Chat fornecida pelo modelo GPT-35-Turbo.

Criar um recurso do OpenAI do Azure

A primeira etapa é criar o recurso do OpenAI do Azure e implantar o modelo. Nesse exercício vamos usar o modelo GPT-3 Turbo. Conforme observado na documentação, o GPT-3.5 Turbo usa uma API de Preenchimentos de Chat e é excelente para o nosso caso de uso.

Pré-requisitos

Uma assinatura do Azure
Acesso concedido ao OpenAI do Azure na assinatura pretendida

Atualmente, você pode obter acesso a esse serviço somente por aplicativo. Você pode solicitar acesso ao Serviço OpenAI do Azure preenchendo o formulário em https://aka.ms/oai/access.
CLI do Azure instalada

Criar um recurso e implementar um modelo

Criar o recurso e implantar o modelo é um processo de várias etapas. Use a CLI do Azure, já que isso pode ser mais rápido do que usar o portal do Azure. Mas observe que você pode usar o portal do Azure, se quiser.

Execute o comando az login para entrar, caso ainda não o tenha feito.
Ao criar um novo recurso do Azure, você tem a opção de criar um novo grupo de recursos ou usar um grupo existente. Esse comando mostra como criar um novo grupo de recursos. Use o nome HikingConversations-RG, substitua o nome de sua escolha ou use o nome de um grupo existente.
```
az group create \
--name HikingConversations-RG \
--location eastus
```
```
az group create `
--name HikingConversations-RG `
--location eastus
```

Execute o comando a seguir para criar um recurso do OpenAI no novo grupo de recursos HikingConversations-RG. Dê ao recurso do OpenAI o nome 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

Em seguida, queremos implantar o modelo GPT-35-Turbo no recurso do OpenAI que criamos. Chame a implantação de modelo HikingRecommendationTurbo. Observe que estamos usando HikingConversations-RG como o nome do grupo de recursos e HikingConversationsAI como o nome do recurso OpenAI. Se você usou valores diferentes, substitua esses valores.

az cognitiveservices account deployment create \
-g HikingConversations-RG \
-n HikingConversationsAI \
--deployment-name HikingRecommendationTurbo \
--model-name gpt-35-turbo \
--model-version "0125" \
--model-format OpenAI \
--sku-capacity 1
--sku-name "Standard"

az cognitiveservices account deployment create `
-g HikingConversations-RG `
-n HikingConversationsAI `
--deployment-name HikingRecommendationTurbo `
--model-name gpt-35-turbo `
--model-version "0125"
--model-format OpenAI `
--sku-capacity 1
--sku-name "Standard"

Após o recurso e o modelo terem sido criados, precisamos obter o URL básico e as chaves de acesso para que o SDK do .NET possa acessar o recurso do OpenAI do Azure. Use estes comandos para obter o ponto de extremidade e as chaves de API primárias e anote-os para uso posterior:

O ponto de extremidade

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

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

A chave de API primária

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

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

Criar o aplicativo de console e adicionar o SDK do OpenAI

Em seguida, vamos querer criar um aplicativo de console .NET despojado e adicionar o SDK do OpenAI do Azure.

Execute o seguinte para criar um novo aplicativo .NET chamado HikingConversationsAI.
```
dotnet new console -n HikingConversationsAI
```
Alterne para o diretório do HikingConversationsAI recém-criado.
```
cd HikingConversationsAI
```

Em seguida, adicione o SDK do Azure OpenAI.

dotnet add package Azure.AI.OpenAI --prerelease

Abra o projeto no VS Code ou no Visual Studio.
No arquivo Program.cs, apague todo o código existente.
Adicione using Azure.AI.OpenAI; na parte superior do Program.cs.
Adicione using Azure; na parte superior do Program.cs.
Adicione três variáveis de nível de classe que contenham referências ao ponto de extremidade do recurso do OpenAI do Azure, à chave de API primária e ao nome do modelo que você implantou.
```
string openAIEndpoint = "<YOUR ENDPOINT URL VALUE>";
string openAIAPIKey = "<YOUR PRIMARY API KEY VALUE>";
string openAIDeploymentName = "HikingRecommendationTurbo";
```
Nas etapas anteriores, nomeamos a implantação HikingRecommendationTurbo. Se você usou um valor diferente, certifique-se de usá-lo em vez disso.

Para terminar, crie uma instância da classe necessária para se comunicar com o recurso do OpenAI do Azure.

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

Criar o prompt do sistema

Vamos criar o prompt de função inicial do sistema, que fornecerá as instruções iniciais para o modelo.

Primeiro, crie um prompt que ensine ao modelo como você gostaria que ele atuasse durante a conversa ao recomendar caminhadas.

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.
""";

Em seguida, crie uma List<ChatMessage> para armazenar todas as mensagens que serão trocadas com o modelo.
```
List<ChatMessage> chatHistory = new();
```
Em seguida, crie um novo SystemChatMessage objeto e adicione-o à chatHistory lista. Vamos configurar a ChatMessage para ser proveniente da função do Sistema.
```
SystemChatMessage systemMessage = ChatMessage.CreateSystemMessage(systemPrompt);

chatHistory.Add(systemMessage);
```

Iniciar a conversa

Em seguida, vamos enviar a primeira mensagem para o modelo, iniciando a conversa.

Crie um prompt para o usuário e adicione-o chatHistory à mensagem como um usuário.

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

Agora você precisará obter uma referência ao ChatClient objeto. Esse objeto é responsável por facilitar as conversas de chat com o modelo. Assim, você vai precisar informar ao objeto Cliente do OpenAI do Azure qual modelo implantado por você gostaria de usar.
```
var chatClient = openAIClient.GetChatClient(openAIDeploymentName);
```
Em seguida, chame a função CompleteChatAsync da classe ChatClient sendo repassada no chatHistory.
```
var response = await chatClient.CompleteChatAsync(chatHistory);
```

Para terminar, leia em voz alta o valor retornado pelo modelo.

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

Vamos ver o que temos até agora. Você pode executar o aplicativo entrando dotnet run no terminal.
Experimente alterar o valor da userGreetingMessage para ver como o modelo poderá responder de forma diferente.

Em um exemplo de execução, recebemos o seguinte:

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?

Você pode receber algo diferente, pois o modelo não é determinístico ou pode produzir uma saída diferente mesmo com a mesma entrada.

Continuando a conversa

Vamos continuar respondendo à conversa e, em seguida, gerando a resposta.

Certifique-se de manter o contexto da conversa; para isso, adicione a resposta que voltou diretamente para a lista de chatHistory.

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

chatHistory.Add(assistantMessage);

Em seguida, crie outro prompt de usuário e envie-o para o modelo.

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

Você pode experimentar alterar a variável hikeRequest para solicitar tipos diferentes de caminhadas. Em um exemplo de execução, recebemos o seguinte:

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!

Resumo

Agora podemos usar o SDK do OpenAI do Azure junto com o modelo do gpt-35-turbo para criar conversas que ajudem a fornecer recomendações de caminhadas. Em seguida, vamos ver o que podemos fazer para aprimorar os prompts que enviamos para o modelo.

Comentários

Esta página foi útil?