Inicio rápido: empezar a utilizar GPT-35-Turbo y GPT-4 con Azure OpenAI Service

Prerrequisitos

• Una suscripción a Azure (cree una cuenta gratuita).

• Acceso concedido a Azure OpenAl en la suscripción de Azure que quiera.

  Actualmente, solo la aplicación concede acceso a este servicio. Para solicitar acceso a Azure OpenAI, rellene el formulario en https://aka.ms/oai/access. Si tiene algún problema, abra una incidencia en este repositorio para ponerse en contacto con nosotros.

• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Ir a Azure OpenAI Studio

Vaya a Azure OpenAI Studio en https://oai.azure.com/ e inicie sesión con las credenciales que le permitan obtener acceso al recurso de OpenAI. Durante o después del flujo de trabajo de inicio de sesión, seleccione el directorio, la suscripción de Azure y el recurso de Azure OpenAI adecuados.

En la página de inicio de Azure OpenAI Studio, seleccione Área de juegos Chat.

Área de juegos

Comience a explorar las funcionalidades de OpenAI con un enfoque sin código a través del área de juegos de Chat de Azure OpenAI Studio. Desde esta página puede iterar y experimentar rápidamente con las funcionalidades.

Configuración del asistente

Puede usar la lista desplegable Configuración del asistente para seleccionar algunos ejemplos de Mensajes del sistema cargados previamente para empezar.

Los mensajes del sistema proporcionan las instrucciones del modelo sobre cómo debe comportarse y cualquier contexto al que debe hacer referencia al generar una respuesta. Puede describir la personalidad del asistente, indicarle lo que debe y lo que no debe responder y cómo formatear las respuestas.

Agregar algunos ejemplos de capturas le permite proporcionar ejemplos conversacionales que usa el modelo para el aprendizaje en contexto.

En cualquier momento mientras usa el Chat del área de juegos, puede seleccionar Ver código para ver ejemplos de código Python, curl y json rellenados previamente en función de sus selecciones de configuración y sesión de chat actuales. Luego puede usar este código y escribir una aplicación para realizar la misma tarea que está llevando a cabo con el área de juegos.

Sesión de chat

Al seleccionar el botón Enviar, se enviará el texto especificado a la API de finalizaciones y se transmitirán los resultados de vuelta al cuadro de texto.

Seleccione el botón Borrar chat para eliminar el historial de conversaciones actual.

Configuración

Mostrar paneles

De forma predeterminada, hay tres paneles: configuración del asistente, sesión de chat y configuraciones. Mostrar paneles permite agregar, quitar y reorganizar los paneles. Si alguna vez cierra un panel y necesita recuperarlo, use Mostrar paneles para restaurar el panel perdido.

Iniciar una sesión de chat

1. En el menú desplegable de configuración del asistente, seleccione Agente de asistencia al cliente de Xbox

2. Se le pedirá que le pregunte si desea actualizar el mensaje del sistema, seleccione Continuar.

3. En el panel de sesión de chat, escriba la siguiente pregunta: "Estoy interesado en comprar una nueva Xbox" y seleccione Enviar.

4. Recibirá una respuesta similar a este ejemplo de código.

   

5. Escriba una pregunta de seguimiento como: "¿Qué modelos admiten 4K?"

   

6. Ahora que tiene una conversación básica, seleccione Ver código desde la Configuración del Asistente y tendrá una reproducción del código detrás de toda la conversación hasta ahora:

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

Descripción de la estructura del símbolo del sistema

Si examina el ejemplo de Ver código, observará algunos tokens únicos que no formaron parte de una llamada de finalización de GPT típica. GPT-35-Turbo fue entrenado para utilizar tokens especiales para delimitar las diferentes partes de la solicitud. El contenido se proporciona al modelo entre los tokens <|im_start|> y <|im_end|>. La solicitud comienza con un mensaje del sistema que puede servir para preparar el modelo incluido el contexto o las instrucciones para el mismo. A continuación, la solicitud contiene una serie de mensajes entre el usuario y el asistente.

La respuesta del asistente al símbolo del sistema se devolverá debajo del <|im_start|>assistant token asistente y terminará con <|im_end|> indicando que el asistente ha terminado su respuesta. También puede usar el botón de alternancia Mostrar sintaxis sin formato para mostrar estos tokens en el panel de sesión de chat.

La guía paso a paso de GPT-35-Turbo y GPT-4 proporciona una introducción detallada a la nueva estructura de consultas y cómo usar el modelo gpt-35-turbo de manera eficaz.

Implementación del modelo

Una vez que esté satisfecho con la experiencia de Azure OpenAI Studio, podría implementar una aplicación web directamente desde Studio seleccionando el botón Implementar en.

Esto le ofrece la opción de implementar en una aplicación web independiente o un copiloto en Copilot Studio (versión preliminar) si está usando sus propios datos en el modelo.

Por ejemplo, si decide implementar una aplicación web:

La primera vez que implemente una aplicación web, debería seleccionar Crear una nueva aplicación web. Elija un nombre para la aplicación, que pasará a formar parte de la dirección URL de la aplicación. Por ejemplo, https://<appname>.azurewebsites.net.

Seleccione la suscripción, el grupo de recursos, la ubicación y el plan de precios de la aplicación publicada. Para actualizar una aplicación existente, seleccione Publicar en una aplicación web existente y elija el nombre de la aplicación anterior en el menú desplegable.

Si decide implementar una aplicación web, vea las consideraciones importantes para usarla.

Limpieza de recursos

Una vez que haya terminado de probar el área de juegos de Chat, si desea limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso o el grupo de recursos. Al eliminar el grupo de recursos, también se elimina cualquier otro recurso que esté asociado a él.

• Portal
• CLI de Azure

Pasos siguientes

• Obtenga más información sobre cómo trabajar con el nuevo modelo gpt-35-turbo con la guía paso a paso de GPT-35-Turbo y GPT-4.
• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl.

Código fuente | Paquete (NuGet) | Ejemplos| Plantilla de chat empresarial de la técnica generación aumentada de recuperación (RAG) |

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido al servicio Azure OpenAI en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• SDK de .NET 7
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configurar

Creación de una aplicación de .NET Core

En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando dotnet new para crear una nueva aplicación de consola con el nombre azure-openai-quickstart. Este comando crea un sencillo proyecto "Hola mundo" con un solo archivo de origen de C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Cambie el directorio a la carpeta de aplicaciones recién creada. Para compilar la aplicación:

dotnet build

La salida de la compilación no debe contener advertencias ni errores.

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

Instalar la biblioteca cliente de OpenAl .NET con:

dotnet add package Azure.AI.OpenAI --prerelease

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Crear una aplicación de ejemplo

En el directorio del proyecto, abra el archivo program.cs y reemplácelo con el código siguiente:

Sin transmisión de respuesta

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

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

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

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

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

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

Console.WriteLine();

dotnet run program.cs

Output

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

Esto esperará hasta que el modelo haya generado toda su respuesta antes de imprimir los resultados. Como alternativa, si desea transmitir de forma asincrónica la respuesta e imprimir los resultados, puede reemplazar el contenido de program.cs por el código del ejemplo siguiente.

Asincrónico con transmisión

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

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Código fuente | Paquete (Go)| Muestras

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido al servicio Azure OpenAI en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• Go 1.21.0 o posterior instalado localmente.
• Un recurso de Azure OpenAI Service con el modelo gpt-35-turbo implementado. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configuración

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Crear una aplicación de ejemplo

Cree un nuevo archivo llamado chat_completions.go. Copie el código siguiente en el archivo 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)
	}

}

Ahora abra un símbolo del sistema y ejecute:

go mod init chat_completions.go

Próxima ejecución:

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.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Código fuente | Artefacto (Maven) | Muestras | Plantilla de chat empresarial de la técnica generación aumentada de recuperación (RAG) | IntelliJ IDEA

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido al servicio Azure OpenAI en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.

• La última versión de Java Development Kit (JDK)

• La herramienta de compilación de Gradle u otro administrador de dependencias.
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configurar

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Creación de una aplicación Java

Cree un proyecto de Gradle.

En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

mkdir myapp && cd myapp

Ejecute el comando gradle init desde el directorio de trabajo. Este comando creará archivos de compilación esenciales para Gradle, como build.gradle.kts, que se usa en tiempo de ejecución para crear y configurar la aplicación.

gradle init --type basic

Cuando se le solicite que elija un DSL, seleccione Kotlin.

Instalación del SDK de Java

En este inicio rápido se usa el administrador de dependencias Gradle. Puede encontrar la biblioteca de cliente y la información de otros administradores de dependencias en el repositorio central de Maven.

Busque build.gradle.kts y ábralo con el IDE o el editor de texto que prefiera. A continuación, cópielo en la siguiente configuración de compilación. Esta configuración define el proyecto como una aplicación Java cuyo punto de entrada es la clase OpenAIQuickstart. Importa la biblioteca de Visión de Azure AI.

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

Crear una aplicación de ejemplo

1. Cree un archivo de Java.

   En el directorio de trabajo, ejecute el siguiente comando para crear una carpeta de origen del proyecto:

   mkdir -p src/main/java
   

   Vaya a la nueva carpeta y cree un archivo denominado OpenAIQuickstart.java.

2. Abra OpenAIQuickstart.java en el editor o IDE que prefiera y pegue el código siguiente.

   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

   En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para obtener más información sobre la seguridad de las credenciales, consulte el artículo Seguridad de servicios de Azure AI.

3. Vuelva a la carpeta raíz del proyecto y compile la aplicación con:

   gradle build
   

   A continuación, ejecútela con el comando gradle run:

   gradle run
   

Salida

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.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Código fuente | Artifacts (Maven) | Muestra

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido al servicio Azure OpenAI en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• La última versión de Java Development Kit (JDK)
• Herramienta de la CLI de Spring Boot
• Un recurso de Azure OpenAI Service con el modelo gpt-35-turbo implementado. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configurar

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Creación de una nueva aplicación de Spring

Cree un nuevo proyecto de Spring.

En una ventana de Bash, cree un nuevo directorio para la aplicación y diríjase a él.

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

Ejecute el comando spring init desde el directorio de trabajo. Este comando crea una estructura de directorio estándar para el proyecto de Spring, incluido el archivo de origen de la clase Java principal y el archivo pom.xml que se usa para administrar proyectos basados en Maven.

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

Los archivos y carpetas generados son similares a la estructura siguiente:

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

Edición de la aplicación de Spring

1. Edite el archivo pom.xml.

   En la raíz del directorio del proyecto, abra el archivo pom.xml en su editor o IDE preferido y sobrescriba el archivo con el siguiente contenido:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.2.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>ai-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.experimental.ai</groupId>
               <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
               <version>0.7.0-SNAPSHOT</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
       <repositories>
           <repository>
               <id>spring-snapshots</id>
               <name>Spring Snapshots</name>
               <url>https://repo.spring.io/snapshot</url>
               <releases>
                   <enabled>false</enabled>
               </releases>
           </repository>
       </repositories>
   </project>
   

2. En la carpeta src/main/java/com/example/aichatdemo, abra AiChatApplication.java en el editor o IDE preferido y pegue el código siguiente:

   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

   En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para obtener más información sobre la seguridad de las credenciales, consulte el artículo Seguridad de servicios de Azure AI.

3. Vuelva a la carpeta raíz del proyecto y ejecute la aplicación mediante el comando siguiente:

   ./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.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Código fuente | Paquete (npm) | Ejemplos | Plantilla de chat empresarial de la técnica generación aumentada de recuperación (RAG)|

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido al servicio Azure OpenAI en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• Versiones de LTS de Node.js
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configurar

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Creación de una aplicación Node

En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él. Ejecute el comando npm init para crear una aplicación de nodo con un archivo package.json.

npm init

Instalación de la biblioteca cliente

Instale la biblioteca cliente de Azure OpenAI para JavaScript con npm:

npm install @azure/openai

El archivo package.json de la aplicación se actualizará con las dependencias.

Crear una aplicación de ejemplo

Abra un símbolo del sistema donde quiera el nuevo proyecto y cree un archivo llamado ChatCompletion.js. Copie el código siguiente en el archivo ChatCompletion.js file.

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

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

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

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

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

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

module.exports = { main };

Ejecute el script con el siguiente comando:

node.exe ChatCompletion.js

Salida

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

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

• Introducción a Azure OpenAI
• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Código fuente de biblioteca | Paquete (PyPi) | Plantilla de chat empresarial de la técnica generación aumentada de recuperación (RAG) |

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido a Azure OpenAI Service en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• Python 3.8 o una versión posterior.
• Las siguientes bibliotecas de Python: os.
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configurar

Instalar la biblioteca cliente de OpenAl Python con:

pip install openai

pip install openai==0.28.1

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

Creación de una nueva aplicación de Python

1. Cree un nuevo archivo de Python denominado quickstart.py. A continuación, ábralo en el editor o IDE preferidos.

2. Reemplace el contenido de quickstart-file.py por el código siguiente.

import os
from openai import AzureOpenAI

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

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

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

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

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

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

3. Ejecute la aplicación con el comando python en el archivo de inicio rápido:

   python quickstart.py
   

Resultados

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

Descripción de la estructura del mensaje

Los modelos GPT-35-Turbo y GPT-4 están optimizados para trabajar con entradas con formato de conversación. La variable messages pasa una matriz de diccionarios con distintos roles en la conversación delineada por el sistema, el usuario y el asistente. El mensaje del sistema se puede usar para preparar el modelo incluyendo contexto o instrucciones sobre cómo debería responder el modelo.

La guía paso a paso de GPT-35-Turbo y GPT-4 proporciona una introducción detallada a las opciones para comunicarse con estos nuevos modelos.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

• Obtenga más información sobre cómo trabajar con GPT-35-Turbo y los modelos GPT-4 con nuestra guía paso a paso.
• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Especificación de la API de REST |

Prerrequisitos

• Una suscripción a Azure (cree una cuenta gratuita).
• Acceso concedido a Azure OpenAI Service en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Configuración

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión y una clave.

Vaya al recurso en Azure Portal. La sección Claves y puntos de conexión se puede encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Variables de entorno

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

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"

API DE REST

En un shell de Bash, ejecute el siguiente comando. Necesitará reemplazar gpt-35-turbo en el nombre de implementación que eligió al implementar los modelos GPT-35-Turbo o GPT-4. Si escribe el nombre del modelo, se producirá un error a menos que elija un nombre de implementación idéntico al nombre del modelo subyacente.

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

El formato de la primera línea del comando con un punto de conexión de ejemplo aparecería de la siguiente manera curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \ Si encontrase una comprobación de error doble para asegurarse de que no tiene una duplicación de / en la separación entre el punto de conexión y /openai/deployments.

Si desea ejecutar este comando en un símbolo del sistema normal de Windows, tendría que modificar el texto para quitar \ y los saltos de línea.

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

El formato de salida ajustado para la facilidad de lectura, la salida real, es un único bloque de texto sin saltos de línea.

Descripción de la estructura del mensaje

Los modelos GPT-35-Turbo y GPT-4 están optimizados para trabajar con entradas con formato de conversación. La variable messages pasa una matriz de diccionarios con distintos roles en la conversación delineada por el sistema, el usuario y el asistente. El mensaje del sistema se puede usar para preparar el modelo incluyendo contexto o instrucciones sobre cómo debería responder el modelo.

La guía paso a paso de GPT-35-Turbo y GPT-4 proporciona una introducción detallada a las opciones para comunicarse con estos nuevos modelos.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• CLI de Azure

Pasos siguientes

• Obtenga más información sobre cómo trabajar con GPT-35-Turbo y los modelos GPT-4 con nuestra guía paso a paso.
• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.
• Acceso concedido a Azure OpenAI Service en la suscripción de Azure deseada. Actualmente, solo la aplicación concede acceso a este servicio. Puede solicitar acceso a Azure OpenAI Service rellenando el formulario de https://aka.ms/oai/access.
• Puede utilizar la versión más reciente, PowerShell 7 o Windows PowerShell 5.1.
• Un recurso de Azure OpenAI Service con un modelo implementado. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.
• Un recurso de Azure OpenAI Service con los modelos gpt-35-turbo o gpt-4 implementados. Para obtener más información sobre la implementación de modelos, consulte la guía de implementación de recursos.

Recuperación de la clave y el punto de conexión

Para realizar correctamente una llamada en Azure OpenAI, necesitará un punto de conexión y una clave.

Vaya al recurso en Azure Portal. El punto de conexión y las claves se pueden encontrar en la sección Administración de recursos. Copie el punto de conexión y la clave de acceso, ya que los necesitará para autenticar las llamadas API. Puede usar KEY1 o KEY2. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.

Cree y asigne variables de entorno persistentes para la clave y el punto de conexión.

Variables de entorno

$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

Creación de un script de PowerShell

1. Cree un nuevo archivo de PowerShell denominado quickstart.ps1. A continuación, ábralo en el editor o IDE preferidos.

2. Reemplace el contenido de quickstart.ps1 por el código siguiente. Deberá establecer la variable engine en el nombre de implementación que eligió al implementar los modelos GPT-35-Turbo o GPT-4. Si escribe el nombre del modelo, se producirá un error a menos que elija un nombre de implementación idéntico al nombre del modelo subyacente.

   # 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

   En entornos de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como PowerShell Secret Management con Azure Key Vault. Para obtener más información sobre la seguridad de las credenciales, consulte el artículo Seguridad de servicios de Azure AI.

3. Ejecute el script con PowerShell:

   ./quickstart.ps1
   

Salida

# 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

Descripción de la estructura del mensaje

Los modelos GPT-35-Turbo y GPT-4 están optimizados para trabajar con entradas con formato de conversación. La variable messages pasa una matriz de diccionarios con distintos roles en la conversación delineada por el sistema, el usuario y el asistente. El mensaje del sistema se puede usar para preparar el modelo incluyendo contexto o instrucciones sobre cómo debería responder el modelo.

La guía paso a paso de GPT-35-Turbo y GPT-4 proporciona una introducción detallada a las opciones para comunicarse con estos nuevos modelos.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI, puede eliminar el recurso. Antes de eliminar el recurso, primero deberá eliminar los modelos implementados.

• Portal
• Azure PowerShell

Pasos siguientes

• Obtenga más información sobre cómo trabajar con GPT-35-Turbo y los modelos GPT-4 con nuestra guía paso a paso.
• Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure OpenAl