Início rápido: Começar a usar o GPT-35-Turbo e o GPT-4 com o Serviço OpenAI do Azure

Artigo
10/29/2024

Use este artigo para começar a usar o OpenAI do Azure.

Pré-requisitos

Uma assinatura do Azure – Crie uma gratuitamente.
Um recurso do Serviço OpenAI do Azure com gpt-4o ou gpt-4o-mini modelos implantados. Recomendamos usar o modelo padrão ou global tipos de implantação para exploração inicial. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Vá para o Estúdio OpenAI do Azure

Navegue até o Estúdio OpenAI do Azure em https://oai.azure.com/ e entre com as credenciais que têm acesso ao recurso do OpenAI do Azure. Durante o fluxo de trabalho de entrada, selecione o diretório apropriado, a assinatura do Azure e o recurso OpenAI do Azure.

Na página de aterrissagem do Estúdio OpenAI do Azure, selecione Playground do chat.

Playground

Comece a explorar as funcionalidades do OpenAI com uma abordagem sem código por meio do Playground do chat do Estúdio OpenAI do Azure. Nesta página, você pode iterar e experimentar as funcionalidades rapidamente.

Instalação

Você pode usar o menu suspenso *Exemplos de prompt para selecionar alguns exemplos de Mensagens do sistema pré-carregados para começar.

As Mensagens do sistema fornecem ao modelo instruções sobre como ele deve se comportar e qualquer contexto que ele deve referenciar ao gerar uma resposta. Você pode descrever a personalidade do assistente, dizer a ele o que ele deve ou não responder e como formatar as respostas.

A qualquer momento, ao usar o Playground do chat, você pode selecionar Exibir código para ver exemplos de código Python, curl e json pré-preenchidos com base em suas seleções de configurações e sessão de chat atual. Em seguida, você pode pegar esse código e escrever um aplicativo para concluir a mesma tarefa que está executando atualmente com o playground.

Sessão de chat

Selecionar o botão Enter ou selecionar o ícone de seta para a direita envia o texto inserido para a API de conclusões de chat e os resultados são retornados para a caixa de texto.

Selecione o botão Limpar chat para excluir o histórico da conversa atual.

Configurações de chave

Nome	Descrição
Implantações	O nome da implantação associado a um modelo específico.
Adicionar seus dados
Parâmetros	Parâmetros personalizados que alteram as respostas do modelo. Quando você estiver começando, recomendamos usar os padrões para a maioria dos parâmetros
Temperatura	Controla a aleatoriedade. Reduzir a temperatura significa que o modelo produz respostas mais repetitivas e determinísticas. Aumentar a temperatura resulta em respostas mais inesperadas ou criativas. Tente ajustar a temperatura ou o Top P, mas não ambos.
Resposta máxima (tokens)	Defina um limite no número de tokens por resposta de modelo. A API nos modelos mais recentes suporta um máximo de 128.000 tokens compartilhados entre o prompt (incluindo mensagem do sistema, exemplos, histórico de mensagens e consulta do usuário) e a resposta do modelo. Um token tem aproximadamente quatro caracteres para um texto típico em inglês.
Topo p	Semelhante à temperatura, isso controla a aleatoriedade, mas usa um método diferente. A redução do Top P restringe a seleção de token do modelo a tokens mais prováveis. O Aumento do Top P permite que o modelo escolha entre tokens com alta e baixa probabilidade. Tente ajustar a temperatura ou o Top P, mas não ambos.
Parar sequências	Parar sequência faz com que o modelo encerre a resposta em um ponto desejado. A resposta do modelo termina antes da sequência especificada, portanto, não conterá o texto da sequência de parada. Para o GPT-35-Turbo, usar `<\|im_end\|>` garante que a resposta do modelo não gere uma consulta de acompanhamento do usuário. Você pode incluir até quatro sequências de parada.

Exibir Código

Depois de experimentar conversar com o modelo, selecione o botão </> Exibir código. Isso lhe dará uma repetição do código por trás de toda a sua conversa até agora:

Noções básicas sobre a estrutura do prompt

Se você examinar o exemplo de Exibir código, notará que a conversa é dividida em três funções distintas system, user, assistant. Cada vez que você envia uma mensagem para a modelo, todo o histórico de conversas até aquele momento é reenviado. Ao usar a API de conclusões de chat, o modelo não tem nenhuma memória real do que você enviou a ele no passado, então você fornece o histórico da conversa para contextualizar e permitir que o modelo responda corretamente.

O Guia prático de conclusões de chat fornece uma introdução detalhada à nova estrutura de prompts e como usar modelos de conclusões de bate-papo de forma eficaz.

Implantar o seu modelo

Quando estiver satisfeito com a experiência no Estúdio do de OpenAI do Azure, você poderá implantar um aplicativo Web diretamente do Estúdio, selecionando o botão Implantar em.

Isso oferece a opção de implantar em um aplicativo web autônomo ou em um copiloto no Copilot Studio (versão prévia) se você estiver usando seus próprios dados no modelo.

Por exemplo, se você optar por implantar um aplicativo Web:

Na primeira vez que implantar um aplicativo Web, selecione Criar um novo aplicativo Web . Escolha um nome para o aplicativo, que se tornará parte da URL do aplicativo. Por exemplo, https://<appname>.azurewebsites.net.

Selecione sua assinatura, grupo de recursos, local e plano de preços para o aplicativo publicado. Para atualizar um aplicativo existente, selecione Publicar em um aplicativo Web existente e escolha o nome do aplicativo anterior no menu suspenso.

Se você optar por implantar um aplicativo Web, confira as considerações importantes para usá-lo.

Tive um problema com a implantação do modelo.

Limpar os recursos

Depois de terminar de testar o Playground do chat, caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Saiba mais sobre como trabalhar com o novo modelo gpt-35-turbo com o Guia de instruções do GPT-35-Turbo e do GPT-4.
Para mais exemplos, confira o repositório do GitHub de amostras do OpenAI do Azure

Código-fonte | Pacote (NuGet) | Amostras| Modelo de chat empresarial de Recuperação de Geração Aumentada (RAG) |

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
O SDK do .NET 7
Um recurso do Serviço OpenAI do Azure com os modelos do gpt-35-turbo ou gpt-4 implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Configuração

Criar um aplicativo .NET Core

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando dotnet new para criar um novo aplicativo do console com o nome azure-openai-quickstart. Este comando cria um projeto "Olá, Mundo" simples com um único arquivo de origem C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Altere o diretório para a pasta do aplicativo recém-criado. É possível criar o aplicativo com:

dotnet build

A saída de compilação não deve conter nenhum aviso ou erro.

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

Instalar a biblioteca de clientes do OpenAI .NET com:

dotnet add package Azure.AI.OpenAI --prerelease

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Encontrei um problema com a configuração.

Criar um aplicativo de exemplo

No diretório do projeto, abra o arquivo program.cs e substitua pelo seguinte código:

Sem streaming de resposta

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

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

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

ChatCompletion completion = chatClient.CompleteChat(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");

Importante

Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações sobre segurança de credenciais, consulte o artigo segurança dos serviços de IA do Azure.

dotnet run program.cs

Saída

Assistant : Yes, many other Azure AI services also support customer managed keys, including Azure Cognitive Services, Azure Machine Learning, and Azure Databricks. By using customer managed keys, you can retain complete control over your encryption keys and provide an additional layer of security for your AI assets.

Isso aguardará até que o modelo tenha gerado toda a resposta antes de imprimir os resultados. Como alternativa, se você quiser transmitir a resposta de forma assíncrona e imprimir os resultados, poderá substituir o conteúdo de program.cs pelo código no próximo exemplo.

Assíncrono com streaming

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

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

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

var chatUpdates = chatClient.CompleteChatStreamingAsync(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

await foreach(var chatUpdate in chatUpdates)
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role} : ");
    }
    
    foreach(var contentPart in chatUpdate.ContentUpdate)
    {
        Console.Write(contentPart.Text);
    }
}

Encontrei um problema ao executar os exemplos de código.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte | Pacote (Go)| Amostras

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Go 1.21.0 ou superior instalado localmente.
Um recurso do Serviço OpenAI do Azure com o modelo implantado gpt-35-turbo. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Criar um aplicativo de exemplo

Crie um arquivo chamado chat_completions.go. Copie o código a seguir no arquivo 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"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
	modelDeploymentID := os.Getenv("YOUR_MODEL_DEPLOYMENT_NAME")
    maxTokens:= int32(400)


	// 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 := azcore.NewKeyCredential(azureOpenAIKey)

	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

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

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

		// The user asks a question
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Does Azure OpenAI support customer managed keys?")},

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

		// The user answers the question based on the latest reply.
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What other Azure Services support customer managed keys?")},

		// from here you'd keep iterating, sending responses back from ChatGPT
	}

	gotReply := false

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

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

	for _, choice := range resp.Choices {
		gotReply = true

		if choice.ContentFilterResults != nil {
			fmt.Fprintf(os.Stderr, "Content filter results\n")

			if choice.ContentFilterResults.Error != nil {
				fmt.Fprintf(os.Stderr, "  Error:%v\n", choice.ContentFilterResults.Error)
			}

			fmt.Fprintf(os.Stderr, "  Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
			fmt.Fprintf(os.Stderr, "  SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
			fmt.Fprintf(os.Stderr, "  Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
			fmt.Fprintf(os.Stderr, "  Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
		}

		if choice.Message != nil && choice.Message.Content != nil {
			fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
		}

		if choice.FinishReason != nil {
			// this choice's conversation is complete.
			fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
		}
	}

	if gotReply {
		fmt.Fprintf(os.Stderr, "Received chat completions reply\n")
	}

}

Importante

Abra um prompt de comando e execute:

go mod init chat_completions.go

Próxima execução:

go mod tidy
go run chat_completions.go

Saída

Content filter results
  Hate: sev: safe, filtered: false
  SelfHarm: sev: safe, filtered: false
  Sexual: sev: safe, filtered: false
  Violence: sev: safe, filtered: false
Content[0]: As of my last update in early 2023, in Azure, several AI services support the use of customer-managed keys (CMKs) through Azure Key Vault. This allows customers to have control over the encryption keys used to secure their data at rest. The services that support this feature typically fall under Azure's range of cognitive services and might include:

1. Azure Cognitive Search: It supports using customer-managed keys to encrypt the index data.
2. Azure Form Recognizer: For data at rest, you can use customer-managed keys for added security.
3. Azure Text Analytics: CMKs can be used for encrypting your data at rest.
4. Azure Blob Storage: While not exclusively an AI service, it's often used in conjunction with AI services to store data, and it supports customer-managed keys for encrypting blob data.

Note that the support for CMKs can vary by service and sometimes even by the specific feature within the service. Additionally, the landscape of cloud services is fast evolving, and new features, including security capabilities, are frequently added. Therefore, it's recommended to check the latest Azure documentation or contact Azure support for the most current information about CMK support for any specific Azure AI service.
Finish reason[0]: stop
Received chat completions reply

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte | Artefato (Maven) | Exemplos | Modelo de chat empresarial da Recuperação de Geração Aumentada (RAG) | IntelliJ IDEA

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente

A versão atual do JDK (Java Development Kit)

A ferramenta de build Gradle ou outro gerenciador de dependência.
Um recurso do Serviço OpenAI do Azure com os modelos do gpt-35-turbo ou gpt-4 implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Criar um aplicativo Java

Criar um novo projeto Gradle.

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Encontrei um problema com a configuração.

Instalar o SDK do Java

Este início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca de clientes e informações para outros gerenciadores de dependência no Repositório Central do Maven.

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Esta configuração define o projeto como um aplicativo Java cujo ponto de entrada é a classe OpenAIQuickstart. Isso importa a biblioteca da Visão de IA do Azure.

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

Criar um aplicativo de exemplo

Criar um arquivo Java.

Em seu diretório de trabalho, execute o comando a seguir para criar uma pasta de origem do projeto:
```
mkdir -p src/main/java
```
Navegue até a nova pasta e crie um arquivo chamado OpenAIQuickstart.java.

Abra OpenAIQuickstart.java em seu editor ou IDE de preferência e cole o código a seguir.

package com.azure.ai.openai.usage;

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.ChatRequestAssistantMessage;
import com.azure.ai.openai.models.ChatRequestMessage;
import com.azure.ai.openai.models.ChatRequestSystemMessage;
import com.azure.ai.openai.models.ChatRequestUserMessage;
import com.azure.ai.openai.models.ChatResponseMessage;
import com.azure.ai.openai.models.CompletionsUsage;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.Configuration;

import java.util.ArrayList;
import java.util.List;


public class OpenAIQuickstart {

    public static void main(String[] args) {
        String azureOpenaiKey = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_API_KEY");
        String endpoint = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_ENDPOINT");
        String deploymentOrModelId = "{azure-open-ai-deployment-model-id}";

        OpenAIClient client = new OpenAIClientBuilder()
            .endpoint(endpoint)
            .credential(new AzureKeyCredential(azureOpenaiKey))
            .buildClient();

        List<ChatRequestMessage> chatMessages = new ArrayList<>();
        chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant."));
        chatMessages.add(new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"));
        chatMessages.add(new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI?"));
        chatMessages.add(new ChatRequestUserMessage("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()) {
            ChatResponseMessage 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

Navegue de volta para a pasta raiz do projeto e compile o aplicativo com:
```
gradle build
```
Em seguida, execute-o com o comando gradle run:
```
gradle run
```

Saída

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.

Encontrei um problema ao executar o exemplo de código.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte | Artefatos (Maven) | Amostra

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
A versão atual do JDK (Java Development Kit)
A ferramenta CLI do Spring Boot
Um recurso do Serviço OpenAI do Azure com o modelo implantado gpt-35-turbo. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos. Este exemplo pressupõe que o nome da sua implantação corresponde ao nome do modelo gpt-35-turbo

Encontrei um problema com os pré-requisitos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Observação

A IA do Spring define o nome do modelo como padrão para gpt-35-turbo. Só é necessário fornecer o valor SPRING_AI_AZURE_OPENAI_MODEL se você implantou um modelo com um nome diferente.

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"

Encontrei um problema com a configuração.

Criar um aplicativo Spring

Crie um projeto Spring.

Em uma janela do Bash, crie um diretório para seu aplicativo e navegue até ele.

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

Execute o comando spring init em seu diretório de trabalho. Esse comando criará uma estrutura de diretório padrão para o projeto Spring, incluindo o arquivo de origem da classe Java principal e o arquivo pom.xml usado para gerenciar projetos baseados em Maven.

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

Os arquivos e as pastas geradas se assemelham à seguinte estrutura:

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

Editar o aplicativo Spring

Edite o arquivo pom.xml.

Na raiz do diretório do projeto, abra o arquivo pom.xml no seu editor ou IDE preferido e substitua o arquivo pelo seguinte conteúdo:

<?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>

Na pasta src/main/java/com/example/aichatdemo, abra AiChatApplication.java no seu editor ou IDE preferido e cole o seguinte código:

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

Navegue de volta para a pasta raiz do projeto e execute o aplicativo usando o seguinte comando:
```
./mvnw spring-boot:run
```

Saída

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: 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.

Encontrei um problema ao executar o exemplo de código.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte | Pacote (npm) | Amostras

Observação

Este artigo foi atualizado para usar o pacote npm do OpenAI mais recente que agora dá suporte total ao OpenAI do Azure. Caso você esteja procurando exemplos de código para o SDK do JavaScript do OpenAI do Azure herdado, eles ainda estão 1available neste repositório.

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Versões LTS do Node.js
A CLI do Azure usada para autenticação sem senha em um ambiente de desenvolvimento local, crie o contexto necessário entrando com a CLI do Azure.
Um recurso do Serviço OpenAI do Azure com um gpt-35-turbo ou gpt-4 modelos de série implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Criar um aplicativo Node

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

Instalar a biblioteca de clientes

Instale os pacotes necessários para JavaScript com npm no contexto do seu novo diretório:

npm install openai @azure/identity

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Encontrei um problema com a configuração.

Criar um aplicativo de exemplo

Abra um prompt de comando onde você deseja criar o projeto e crie um arquivo chamado ChatCompletion.js. Copie o código a seguir no arquivo ChatCompletion.js.

Microsoft Entra ID
Chave de API

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

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.


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

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, azureADTokenProvider, 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 };

Execute o script com o seguinte comando:

node.exe ChatCompletion.js

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

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.

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

Execute o script com o seguinte comando:

node.exe ChatCompletion.js

Saída

== 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'
}

Observação

Se você receber o erro: Ocorreu um erro: OpenAIError: Os argumentos apiKey e azureADTokenProvider são mutuamente exclusivos; apenas um pode ser passado de cada vez. Talvez seja necessário remover uma variável de ambiente pré-existente para a chave de API do seu sistema. Mesmo que o exemplo de código do Microsoft Entra ID não faça referência explícita à variável de ambiente da chave de API, se houver uma presente no sistema que executa esse exemplo, esse erro ainda será gerado.

Encontrei um problema ao executar o exemplo de código.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Visão geral do Azure OpenAI
Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte | Pacote (npm) | Amostras

Observação

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Versões LTS do Node.js
TypeScript
A CLI do Azure usada para autenticação sem senha em um ambiente de desenvolvimento local, crie o contexto necessário entrando com a CLI do Azure.
Um recurso do Serviço OpenAI do Azure com uma gpt-35-turbo ou gpt-4 mais séries de modelos implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Criar um aplicativo Node

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

Instalar a biblioteca de clientes

Instale os pacotes necessários para JavaScript com npm no contexto do seu novo diretório:

npm install openai @azure/identity

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Encontrei um problema com a configuração.

Criar um aplicativo de exemplo

Abra um prompt de comando onde você deseja criar o projeto e crie um arquivo chamado ChatCompletion.ts. Copie o código a seguir no arquivo ChatCompletion.ts.

Microsoft Entra ID
Chave de API

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

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

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

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

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    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: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

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

Crie o script com o seguinte comando:

tsc

Execute o script com o seguinte comando:

node.exe ChatCompletion.js

import { AzureOpenAI } from "openai";
import type {
  ChatCompletion,
  ChatCompletionCreateParamsNonStreaming,
} from "openai/resources/index";

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

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    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: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

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

Crie o script com o seguinte comando:

tsc

Execute o script com o seguinte comando:

node.exe ChatCompletion.js

Saída

== 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'
}

Observação

Encontrei um problema ao executar o exemplo de código.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Visão geral do Azure OpenAI
Para obter mais exemplos, confira o repositório do GitHub de Exemplos do OpenAI do Azure

Código-fonte de biblioteca | Pacote (PyPi) | Modelo de chat empresarial de Recuperação de Geração Aumentada (RAG) |

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Python 3.8 ou versão posterior.
As seguintes bibliotecas do Python: os.
Um recurso do Serviço OpenAI do Azure com os modelos do gpt-35-turbo ou gpt-4 implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Configuração

Instalar a biblioteca de clientes do OpenAI Python com:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai

Observação

A versão da biblioteca OpenAI Python 0.28.1 foi preterida. Recomendamos usar 1.x. Consulte nosso guia de migração para obter informações sobre como mudar de 0.28.1 para 1.x.

pip install openai==0.28.1

Observação

Essa biblioteca é mantida pelo OpenAI. Consulte o histórico de lançamentos para acompanhar as atualizações mais recentes na biblioteca.

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Encontrei um problema com a configuração.

Criar um novo aplicativo Python

Criar um arquivo Python chamado quickstart.py. Depois, abra-o no editor ou IDE de sua preferência.
Substitua o conteúdo do arquivo quickstart.py pelo código a seguir.

OpenAI Python 1.x
OpenAI Python 0.28.1

Você precisa definir a variável model para o nome da implantação que você escolheu quando implantou os modelos do GPT-3.5-Turbo ou do GPT-4. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

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)

Você precisa definir a variável engine para o nome da implantação que você escolheu quando implantou os modelos do GPT-3.5-Turbo ou do GPT-4. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

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

Execute o aplicativo com o comando python no seu arquivo de início rápido:
```
python quickstart.py
```

Saída

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

Encontrei um problema ao executar o exemplo de código.

Como entender a estrutura da mensagem

Os modelos GPT-35-Turbo e o GPT-4 são otimizados para funcionarem com entradas formatadas como uma conversa. A variável messages aprova uma matriz de dicionários com diferentes funções na conversa, delineadas pelo sistema, pelo usuário e pelo assistente. A mensagem do sistema pode ser usada para preparar o modelo incluindo contexto ou instruções sobre como o modelo deve responder.

O Guia de instruções do GPT-35-Turbo e do GPT-4 fornece uma introdução detalhada sobre as opções de comunicação com esses novos modelos.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Saiba mais sobre como trabalhar com os modelos do GPT-35-Turbo e do GPT-4 com nosso guia de instruções.
Para obter mais exemplos, confira o repositório de amostras do OpenAI do Azure no GitHub

Especificação da API REST |

Pré-requisitos

Uma assinatura do Azure – Crie uma gratuitamente.
Um recurso do Serviço OpenAI do Azure com os modelos do gpt-35-turbo ou gpt-4 implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Configuração

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, confira Autenticar solicitações para serviços de IA do Azure.

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"

Encontrei um problema com a configuração.

API REST

Em um shell Bash, execute o comando a seguir. Você precisará substituir gpt-35-turbo pelo nome da implantação que você escolheu quando implantou os modelos do GPT-35-Turbo ou do GPT-4. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

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?"}]}'

O formato da sua primeira linha do comando com um exemplo de ponto de extremidade aparecerá da seguinte maneira: curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \. Se encontrar um erro, faça uma segunda verificação para garantir que você não tenha uma duplicação do / na separação entre o seu ponto de extremidade e as /openai/deployments.

Se quiser executar esse comando em um prompt de comando normal do Windows, você precisará alterar o texto para remover o \ e as quebras de linha.

Importante

Saída

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

Formatação de saída ajustada para facilidade de leitura. A saída real é um único bloco de texto sem quebras de linha.

Encontrei um problema ao executar o exemplo de código.

Como entender a estrutura da mensagem

O Guia de instruções do GPT-35-Turbo e do GPT-4 fornece uma introdução detalhada sobre as opções de comunicação com esses novos modelos.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Saiba mais sobre como trabalhar com os modelos do GPT-35-Turbo e do GPT-4 com nosso guia de instruções.
Para obter mais exemplos, confira o repositório de amostras do OpenAI do Azure no GitHub

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Você pode usar a versão mais recente, o PowerShell 7 ou o Windows PowerShell 5.1.
Um recurso do Serviço OpenAI do Azure com um modelo implantado. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.
Um recurso do Serviço OpenAI do Azure com os modelos do gpt-35-turbo ou gpt-4 implantados. Para obter mais informações sobre a implantação do modelo, consulte o Guia de implantação de recursos.

Encontrei um problema com os pré-requisitos.

Recuperar chave e ponto de extremidade

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.

Nome da variável	Valor
`ENDPOINT`	O ponto de extremidade de serviço pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Como alternativa, você pode encontrar o ponto de extremidade na página Implantações no Estúdio de IA do Azure. Um ponto de extremidade de exemplo é: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. O Ponto de extremidade e as Chaves podem ser encontrados na seção Gerenciamento de recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Variáveis de ambiente

Crie e atribua variáveis de ambiente persistentes para sua chave e ponto de extremidade.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

$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

Encontrei um problema com a configuração.

Criar um novo script do PowerShell

Criar um novo arquivo do PowerShell denominado quickstart.ps1. Depois, abra-o no editor ou IDE de sua preferência.

Substitua o conteúdo de quickstart.ps1 pelo código a seguir. Você precisa definir a variável engine para o nome da implantação que você escolheu quando implantou os modelos do GPT-35-Turbo ou do GPT-4. Inserir o nome do modelo resultará em um erro, a menos que você escolha um nome de implantação que seja idêntico ao nome do modelo subjacente.

# 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

Para produção, use um modo seguro de armazenar e acessar suas credenciais, como o Gerenciamento de Segredo do PowerShell com o Azure Key Vault. Para obter mais informações sobre segurança de credenciais, consulte o artigo segurança dos serviços de IA do Azure.

Execute o script usando o PowerShell:
```
./quickstart.ps1
```

Saída

# 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

Encontrei um problema ao executar o exemplo de código.

Como entender a estrutura da mensagem

O Guia de instruções do GPT-35-Turbo e do GPT-4 fornece uma introdução detalhada sobre as opções de comunicação com esses novos modelos.

Limpar os recursos

Caso queria limpar e remover um recurso OpenAI do Azure, é possível excluir o recurso. Antes de excluir o recurso, você deve primeiro excluir todos os modelos implantados.

Próximas etapas

Saiba mais sobre como trabalhar com os modelos do GPT-35-Turbo e do GPT-4 com nosso guia de instruções.
Para obter mais exemplos, confira o repositório de amostras do OpenAI do Azure no GitHub

Compartilhar via

Início rápido: Começar a usar o GPT-35-Turbo e o GPT-4 com o Serviço OpenAI do Azure

Pré-requisitos

Vá para o Estúdio OpenAI do Azure

Playground

Instalação

Sessão de chat

Configurações de chave

Exibir Código

Noções básicas sobre a estrutura do prompt

Implantar o seu modelo

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Criar um aplicativo .NET Core

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo de exemplo

Sem streaming de resposta

Saída

Assíncrono com streaming

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo de exemplo

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Java

Instalar o SDK do Java

Criar um aplicativo de exemplo

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Spring

Editar o aplicativo Spring

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Node

Instalar a biblioteca de clientes

Criar um aplicativo de exemplo

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um aplicativo Node

Instalar a biblioteca de clientes

Criar um aplicativo de exemplo

Saída

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Recuperar chave e ponto de extremidade

Variáveis de ambiente

Criar um novo aplicativo Python

Saída

Como entender a estrutura da mensagem

Limpar os recursos

Próximas etapas