Inicio rápido: chatee con modelos de Azure OpenAI usando sus propios datos

  • Artículo

Código fuente| Código fuente | Ejemplo

Referencia | Código fuente | Paquete (npm) | Muestras

Referencia | Código fuente | Paquete (pypi) | Muestras

Los vínculos anteriores hacen referencia a OpenAI API para Python. No hay ningún SDK de Python de OpenAI específico de Azure. Aprenda a cambiar entre los servicios de OpenAI y los servicios de Azure OpenAI.

Referencia | Código fuente | Paquete (Go) | Muestras

En este inicio rápido puede usar sus propios datos con modelos de Azure OpenAI. Usar modelos de Azure OpenAI con sus los datos puede proporcionarle una potente plataforma de inteligencia artificial conversacional que permita una comunicación más rápida y precisa.

Prerrequisitos

He tenido un problema con los requisitos previos.

Añada datos mediante Azure OpenAI Studio

Sugerencia

Puede usar Azure Developer CLI para desarrolladores de Azure para crear mediante programación los recursos necesarios para Azure OpenAI en sus datos

Vaya a Azure OpenAI Studio e inicie sesión con credenciales que le permitan acceder al recurso de Azure 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.

  1. Seleccione el icono de Bring your own data

    Captura de pantalla de la página de aterrizaje de Azure OpenAI Studio.

  2. En el panel que aparece, seleccione Cargar archivos (versión preliminar) en Seleccionar origen de datos. Azure OpenAI necesita un recurso de almacenamiento y un recurso de búsqueda para acceder a los datos e indexarlos.

    Sugerencia

    1. Para que Azure OpenAI acceda a la cuenta de almacenamiento, deberá activar Uso compartido de recursos entre orígenes (CORS). Si CORS aún no está activado para el recurso de Azure Blob Storage, seleccione Activar CORS.

    2. Seleccione el recurso de búsqueda de Azure AI y confirme que la conexión supondrá el uso de su cuenta. Luego, seleccione Siguiente.

    Captura de pantalla que muestra las opciones para seleccionar un origen de datos en Azure OpenAI Studio.

  3. En el panel Cargar archivos, seleccione Examinar un archivo y seleccione los archivos que ha descargado en la sección de requisitos previos o sus propios datos. A continuación, seleccione Cargar archivos. Seleccione Siguiente.

  4. En el panel Administración de datos, puede elegir si desea habilitar la búsqueda semántica o el vector de búsqueda del índice.

    Importante

    • La búsqueda semántica y el vector de búsqueda están sujetas a precios adicionales. Debe elegir SKU Básico o superior para habilitar la búsqueda semántica o la búsqueda vectorial. Para más información, vea diferencias de planes de tarifa y límites de servicio.
    • Para ayudar a mejorar la calidad de la recuperación de la información y la respuesta del modelo, se recomienda habilitar la búsqueda semántica para los siguientes idiomas de origen de los datos: inglés, francés, español, portugués, italiano, alemán, chino (Zh), japonés, coreano, ruso, y árabe.

  5. Revise los detalles que ingresó y seleccione Guardar y cerrar. Ahora puede chatear con el modelo, que usará la información de sus datos para construir la respuesta.

Tuve un problema al agregar mis datos.

Área de juegos de chat

Comience a explorar las funcionalidades de Azure OpenAI con un enfoque sin código a través del área de juegos de chat. Se trata simplemente de un cuadro de texto donde puede enviar un mensaje para generar una finalización. Desde esta página puede iterar y experimentar rápidamente con las funcionalidades.

Captura de pantalla de la página de inicio de Azure OpenAI Studio con secciones resaltadas.

El área de juegos le ofrece opciones para adaptar su experiencia de chat. A la derecha, puede seleccionar Implementación para determinar qué modelo genera una respuesta mediante los resultados de búsqueda del índice. Usted elige el número de mensajes anteriores que se van a incluir como historial de conversaciones para las respuestas generadas en el futuro. El historial de conversaciones proporciona contexto para generar respuestas relacionadas, pero también consume el uso de tokens. El indicador de progreso del token de entrada realiza un seguimiento del recuento de tokens de la pregunta que envía.

La configuración avanzada de la izquierda consiste de parámetros en tiempo de ejecución, que proporcionan control sobre la recuperación y búsqueda de información relevante de los datos. Un buen caso de uso es cuando desea asegurarse de que las respuestas solo se generan en función de los datos o que el modelo no puede generar una respuesta basada en la información existente de los datos.

  • Rigurosidad determina la agresividad del sistema en el filtrado de los documentos de búsqueda en función de sus puntuaciones de similitud. Establecer un valor de rigurosidad de 5 indica que el sistema filtrará los documentos de forma agresiva, aplicando un umbral de similitud muy alto. La búsqueda semántica puede resultar útil en este escenario porque los modelos de clasificación realizan un mejor trabajo de deducir la intención de la consulta. Los niveles de rigor más bajos producen respuestas más detalladas, pero también podrían incluir información que no está en su índice. Se establece en 3 de manera predeterminada.

  • Documentos recuperados es un entero que se puede establecer en 3, 5, 10 o 20, y controla el número de fragmentos del documento proporcionados al modelo de lenguaje grande para formular la respuesta final. De forma predeterminada, está establecida en 5.

  • Cuando se habilita Limitar respuestas a los datos, el modelo intenta confiar solo en los documentos para las respuestas. Esto se establece en true de forma predeterminada.

Captura de pantalla de la configuración avanzada.

Envíe la primera consulta. Los modelos de chat funcionan mejor en ejercicios de preguntas y respuestas. Por ejemplo, "¿Cuáles son mis planes de salud disponibles?" o "¿Cuál es la opción prémium de salud?".

Es probable que se produzcan errores en las consultas que requieran análisis de datos, como "¿Qué plan de salud es más popular?". Es probable que se produzca un error en las consultas que requieren información sobre todos los datos, como "¿Cuántos documentos he cargado?". Recuerde que el motor de búsqueda busca fragmentos que tengan términos, frases o construcciones exactos o similares a la consulta. Y aunque el modelo puede comprender la pregunta, si los resultados de búsqueda son fragmentos del conjunto de datos, no es la información adecuada para responder a ese tipo de pregunta.

Los chats están restringidos por el número de documentos (fragmentos) devueltos en la respuesta (limitado a 3-20 en el área de juegos de Azure OpenAI Studio). Como puede imaginar, plantear una pregunta sobre "todos los títulos" requiere un examen completo de todo el almacén de vectores.

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.

Captura de pantalla del botón Implantación de modelo en Azure OpenAI Studio.

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.

He tenido un problema con la implementación del modelo.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

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

En el directorio del proyecto, abra el archivo Program.cs y reemplace el contenido con el código siguiente:

Sin transmisión de respuesta

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

string azureOpenAIEndpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string azureOpenAIKey = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
string deploymentName = GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_ID");
string searchEndpoint = GetEnvironmentVariable("AZURE_AI_SEARCH_ENDPOINT");
string searchKey = GetEnvironmentVariable("AZURE_AI_SEARCH_API_KEY");
string searchIndex = GetEnvironmentVariable("AZURE_AI_SEARCH_INDEX");


var client = new OpenAIClient(new Uri(azureOpenAIEndpoint), new AzureKeyCredential(azureOpenAIKey));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    Messages =
    {
        new ChatRequestUserMessage("What are my available health plans?"),
    },
    AzureExtensionsOptions = new AzureChatExtensionsOptions()
    {
        Extensions =
        {
            new AzureCognitiveSearchChatExtensionConfiguration()
            {
                SearchEndpoint = new Uri(searchEndpoint),
                Key = searchKey,
                IndexName = searchIndex,
            },
        }
    },
    DeploymentName = deploymentName
};

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

ChatResponseMessage responseMessage = response.Value.Choices[0].Message;

Console.WriteLine($"Message from {responseMessage.Role}:");
Console.WriteLine("===");
Console.WriteLine(responseMessage.Content);
Console.WriteLine("===");

Console.WriteLine($"Context information (e.g. citations) from chat extensions:");
Console.WriteLine("===");
foreach (ChatResponseMessage contextMessage in responseMessage.AzureExtensionsContext.Messages)
{
    string contextContent = contextMessage.Content;
    try
    {
        var contextMessageJson = JsonDocument.Parse(contextMessage.Content);
        contextContent = JsonSerializer.Serialize(contextMessageJson, new JsonSerializerOptions()
        {
            WriteIndented = true,
        });
    }
    catch (JsonException)
    {}
    Console.WriteLine($"{contextMessage.Role}: {contextContent}");
}
Console.WriteLine("===");

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.

dotnet run program.cs

Output

Answer from assistant:
===
The available health plans in the Contoso Electronics plan and benefit packages are the Northwind Health Plus and Northwind Standard plans [^1^].
===
Context information (e.g. citations) from chat extensions:
===
tool: {
  "citations": [
    {
      "content": "...",
      "id": null,
      "title": "...",
      "filepath": "...",
      "url": "...",
      "metadata": {
        "chunking": "orignal document size=1011. Scores=3.6390076 and None.Org Highlight count=38."
      },
      "chunk_id": "2"
    },
    ...
  ],
  "intent": "[\u0022What are my available health plans?\u0022]"
}
===

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 System.Text.Json;
using static System.Environment;

string azureOpenAIEndpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string azureOpenAIKey = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
string deploymentName = GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_ID");
string searchEndpoint = GetEnvironmentVariable("AZURE_AI_SEARCH_ENDPOINT");
string searchKey = GetEnvironmentVariable("AZURE_AI_SEARCH_API_KEY");
string searchIndex = GetEnvironmentVariable("AZURE_AI_SEARCH_INDEX");


var client = new OpenAIClient(new Uri(azureOpenAIEndpoint), new AzureKeyCredential(azureOpenAIKey));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = deploymentName,
    Messages =
    {
        new ChatRequestUserMessage("What are my available health plans?"),
    },
    AzureExtensionsOptions = new AzureChatExtensionsOptions()
    {
        Extensions =
        {
            new AzureCognitiveSearchChatExtensionConfiguration()
            {
                SearchEndpoint = new Uri(searchEndpoint),
                Key = searchKey,
                IndexName = searchIndex,
            },
        }
    }
};
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);
    }
}

He tenido un problema al ejecutar los códigos de muestra.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Para más información, consulte Incorporación de datos mediante Azure AI Studio.

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Puede encontrar este valor en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI desde Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resource.openai.azure.com.
AZURE_OPENAI_API_KEY Puede encontrar este valor en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPEN_AI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien, en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Puede encontrar este valor en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.
AZURE_AI_SEARCH_API_KEY Puede encontrar este valor en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

Nota:

Spring AI tiene como valor predeterminado el nombre del modelo en gpt-35-turbo. Solo es necesario proporcionar el valor SPRING_AI_AZURE_OPENAI_MODEL si ha implementado un modelo con otro nombre.

export SPRING_AI_AZURE_OPENAI_ENDPOINT=REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE
export SPRING_AI_AZURE_OPENAI_API_KEY=REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE
export SPRING_AI_AZURE_COGNITIVE_SEARCH_ENDPOINT=REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE
export SPRING_AI_AZURE_COGNITIVE_SEARCH_API_KEY=REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE
export SPRING_AI_AZURE_COGNITIVE_SEARCH_INDEX=REPLACE_WITH_YOUR_INDEX_NAME_HERE
export SPRING_AI_AZURE_OPENAI_MODEL=REPLACE_WITH_YOUR_MODEL_NAME_HERE

He tenido un problema con la configuración.

Creación de una nueva aplicación de Spring

Actualmente, Spring AI no admite las opciones AzureCognitiveSearchChatExtensionConfiguration que permiten que una consulta de Azure AI encapsule el método de Generación aumentada de recuperación (RAG), y oculta los detalles del usuario. Como alternativa, todavía puede invocar el método RAG directamente en la aplicación para consultar datos en el índice de Búsqueda de Azure AI y usar documentos recuperados para aumentar la consulta.

Spring AI admite una abstracción de VectorStore y puede encapsular Búsqueda de Azure AI en una implementación de Spring AI VectorStore para consultar los datos personalizados. El siguiente proyecto implementa un VectorStore personalizado respaldado por Búsqueda de Azure AI y ejecuta directamente operaciones RAG.

En una ventana de Bash, cree un directorio para la aplicación y vaya a ese directorio.

mkdir ai-custom-data-demo && cd ai-custom-data-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-custom-data-demo -n AICustomData --force --build maven -x

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

ai-custom-data-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aicustomdatademo/
    |                   |-- AiCustomDataApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aicustomdatademo/
                        |-- AiCustomDataApplicationTests.java

Edición de la aplicación de Spring

  1. Edite el archivo pom.xml.

    Desde 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-custom-data-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>AICustomData</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>com.azure</groupId>
            <artifactId>azure-search-documents</artifactId>
            <version>11.6.0-beta.10</version>
            <exclusions>
                <!-- exclude this to avoid changing the default serializer and the null-value behavior -->
                <exclusion>
                    <groupId>com.azure</groupId>
                    <artifactId>azure-core-serializer-json-jackson</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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/aicustomdatademo, abra AiCustomDataApplication.java en el editor o IDE preferido, y pegue el código siguiente:

    package com.example.aicustomdatademo;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import org.springframework.ai.client.AiClient;
import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.prompt.Prompt;
import org.springframework.ai.prompt.SystemPromptTemplate;
import org.springframework.ai.prompt.messages.MessageType;
import org.springframework.ai.prompt.messages.UserMessage;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.Context;
import com.azure.search.documents.SearchClient;
import com.azure.search.documents.SearchClientBuilder;
import com.azure.search.documents.models.IndexingResult;
import com.azure.search.documents.models.SearchOptions;
import com.azure.search.documents.models.RawVectorQuery;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.extern.jackson.Jacksonized;

@SpringBootApplication
public class AiCustomDataApplication implements CommandLineRunner
{
    private static final String ROLE_INFO_KEY = "role";

    private static final String template = """
            You are a helpful assistant. Use the information from the DOCUMENTS section to augment answers.

            DOCUMENTS:
            {documents}
            """;

    @Value("${spring.ai.azure.cognitive-search.endpoint}")
    private String acsEndpoint;

    @Value("${spring.ai.azure.cognitive-search.api-key}")
    private String acsApiKey;

    @Value("${spring.ai.azure.cognitive-search.index}")
    private String acsIndexName;

    @Autowired
    private AiClient aiClient;

    @Autowired
    private EmbeddingClient embeddingClient;

    public static void main(String[] args) {
        SpringApplication.run(AiCustomDataApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception
    {
        System.out.println(String.format("Sending custom data prompt to AI service. One moment please...\r\n"));

        final var store = vectorStore(embeddingClient);

        final String question = "What are my available health plans?";

        final var candidateDocs = store.similaritySearch(question);

        final var userMessage = new UserMessage(question);

        final String docPrompts =
                candidateDocs.stream().map(entry -> entry.getContent()).collect(Collectors.joining("\n"));

        final SystemPromptTemplate promptTemplate = new SystemPromptTemplate(template);
        final var systemMessage = promptTemplate.createMessage(Map.of("documents", docPrompts));

        final var prompt = new Prompt(List.of(systemMessage, userMessage));

        final var resps = aiClient.generate(prompt);

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

    }

    @Bean
    public VectorStore vectorStore(EmbeddingClient embeddingClient)
    {
        final SearchClient searchClient = new SearchClientBuilder()
                .endpoint(acsEndpoint)
                .credential(new AzureKeyCredential(acsApiKey))
                .indexName(acsIndexName)
                .buildClient();
        return new AzureCognitiveSearchVectorStore(searchClient, embeddingClient);
    }

    public static class AzureCognitiveSearchVectorStore implements VectorStore
    {
        private static final int DEFAULT_TOP_K = 4;

        private static final Double DEFAULT_SIMILARITY_THRESHOLD = 0.0;

        private SearchClient searchClient;

        private final EmbeddingClient embeddingClient;

        public AzureCognitiveSearchVectorStore(SearchClient searchClient, EmbeddingClient embeddingClient)
        {
            this.searchClient = searchClient;
            this.embeddingClient = embeddingClient;
        }

        @Override
        public void add(List<Document> documents)
        {
            final var docs = documents.stream().map(document -> {

                final var embeddings = embeddingClient.embed(document);

                return new DocEntry(document.getId(), "", document.getContent(), embeddings);

            }).toList();

            searchClient.uploadDocuments(docs);
        }

        @Override
        public Optional<Boolean> delete(List<String> idList)
        {
            final List<DocEntry> docIds = idList.stream().map(id -> DocEntry.builder().id(id).build())
                .toList();

            var results = searchClient.deleteDocuments(docIds);

            boolean resSuccess = true;

            for (IndexingResult result : results.getResults())
                if (!result.isSucceeded()) {
                    resSuccess = false;
                    break;
                }

            return Optional.of(resSuccess);
        }

        @Override
        public List<Document> similaritySearch(String query)
        {
            return similaritySearch(query, DEFAULT_TOP_K);
        }

        @Override
        public List<Document> similaritySearch(String query, int k)
        {
            return similaritySearch(query, k, DEFAULT_SIMILARITY_THRESHOLD);
        }

        @Override
        public List<Document> similaritySearch(String query, int k, double threshold)
        {
            final var searchQueryVector = new RawVectorQuery()
                    .setVector(toFloatList(embeddingClient.embed(query)))
                    .setKNearestNeighborsCount(k)
                    .setFields("contentVector");

            final var searchResults = searchClient.search(null,
                    new SearchOptions().setVectorQueries(searchQueryVector), Context.NONE);

            return searchResults.stream()
                    .filter(r -> r.getScore() >= threshold)
                    .map(r -> {

                        final DocEntry entry = r.getDocument(DocEntry.class);

                        final Document doc = new Document(entry.getId(), entry.getContent(), Collections.emptyMap());
                        doc.setEmbedding(entry.getContentVector());

                        return doc;
                    })
                    .collect(Collectors.toList());
        }

        private List<Float> toFloatList(List<Double> doubleList)
        {
            return doubleList.stream().map(Double::floatValue).toList();
        }

    }

    @Data
    @Builder
    @Jacksonized
    @AllArgsConstructor
    @NoArgsConstructor
    static class DocEntry
    {
        private String id;

        private String hash;

        private String content;

        private List<Double> contentVector;
    }

}

    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-07T14:40:45.250-06:00  INFO 18557 --- [           main] c.e.a.AiCustomDataApplication            : No active profile set, falling back to 1 default profile: "default"
2023-11-07T14:40:46.035-06:00  INFO 18557 --- [           main] c.e.a.AiCustomDataApplication            : Started AiCustomDataApplication in 1.095 seconds (process running for 1.397)
Sending custom data prompt to AI service. One moment please...

Prompt created 1 generated response(s).
Generated response from "assistant": The available health plans in the Contoso Electronics plan and benefit packages are the Northwind Health Plus and Northwind Standard plans.

He tenido un problema al ejecutar los códigos de muestra.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

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 el cliente de Azure OpenAI y las bibliotecas de Identidad de Azure para JavaScript con npm:

npm install @azure/openai @azure/identity

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 desee el nuevo proyecto y cree un nuevo archivo llamado ChatWithOwnData.js. Copie el siguiente código en el archivo ChatWithOwnData.js.

const { OpenAIClient, AzureKeyCredential } = require("@azure/openai");

// Set the Azure and AI Search values from environment variables
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
const azureApiKey = process.env["AZURE_OPENAI_API_KEY"];
const deploymentId = process.env["AZURE_OPENAI_DEPLOYMENT_ID"];
const searchEndpoint = process.env["AZURE_AI_SEARCH_ENDPOINT"];
const searchKey = process.env["AZURE_AI_SEARCH_API_KEY"];
const searchIndex = process.env["AZURE_AI_SEARCH_INDEX"];


async function main(){
  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));

  const messages = [
    { role: "user", content: "What are my available health plans?" },
  ];

  console.log(`Message: ${messages.map((m) => m.content).join("\n")}`);

  const events = await client.streamChatCompletions(deploymentId, messages, { 
    maxTokens: 128,
    azureExtensionOptions: {
      extensions: [
        {
          type: "AzureCognitiveSearch",
          endpoint: searchEndpoint,
          key: searchKey,
          indexName: searchIndex,
        },
      ],
    },
  });
  let response = "";
  for await (const event of events) {
    for (const choice of event.choices) {
      const newText = choice.delta?.content;
      if (!!newText) {
        response += newText;
        // To see streaming results as they arrive, uncomment line below
        // console.log(newText);
      }
    }
  }
  console.log(response);
}

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



module.exports = { main };

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.

node.exe ChatWithOwnData.js

Resultados

Message: What are my available health plans?
The available health plans in the Contoso Electronics plan and benefit packages are the Northwind Health Plus and Northwind Standard plans.

He tenido un problema al ejecutar el código de muestra.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

Crear un entorno de Python

  1. Cree una carpeta denominada openai-python para el proyecto y un nuevo archivo de código de Python denominado main.py. Cambie a ese directorio:
mkdir openai-python
cd openai-python
  1. Instale las siguientes bibliotecas de Python:
pip install openai
pip install python-dotenv

Crear la aplicación de Python

  1. En el directorio del proyecto, abra el archivo main.py y agregue el código siguiente:
import os
import openai
import dotenv

dotenv.load_dotenv()

endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
api_key = os.environ.get("AZURE_OPENAI_API_KEY")
deployment = os.environ.get("AZURE_OPENAI_DEPLOYMENT_ID")

client = openai.AzureOpenAI(
    azure_endpoint=endpoint,
    api_key=api_key,
    api_version="2024-02-01",
)

completion = client.chat.completions.create(
    model=deployment,
    messages=[
        {
            "role": "user",
            "content": "What are my available health plans?",
        },
    ],
    extra_body={
        "data_sources":[
            {
                "type": "azure_search",
                "parameters": {
                    "endpoint": os.environ["AZURE_AI_SEARCH_ENDPOINT"],
                    "index_name": os.environ["AZURE_AI_SEARCH_INDEX"],
                    "authentication": {
                        "type": "api_key",
                        "key": os.environ["AZURE_AI_SEARCH_API_KEY"],
                    }
                }
            }
        ],
    }
)

print(completion.model_dump_json(indent=2))

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.

  1. Ejecute el siguiente comando:
python main.py

La aplicación imprime la respuesta en un formato JSON adecuado para su uso en muchos escenarios. Incluye tanto respuestas a su consulta como citas de los archivos cargados.

He tenido un problema al ejecutar los códigos de muestra.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

Comandos de PowerShell de ejemplo

Los modelos de chat de Azure OpenAI 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 sistemas, usuarios y asistentes. La variable dataSources se conecta al índice de Azure Cognitive Search y permite a los modelos de Azure OpenAI responder usando sus datos.

Para desencadenar una respuesta del modelo, debe terminar con un mensaje de usuario indicando que es el turno de responder del asistente.

Sugerencia

Hay varios parámetros que puede usar para cambiar la respuesta del modelo, como temperature o top_p. Vea la documentación de referencia para más información.

# 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 = '2023-07-01-preview' # 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.
   }

   $acs = @{
       search_endpoint     = 'YOUR ACS ENDPOINT' # your endpoint should look like the following https://YOUR_RESOURCE_NAME.search.windows.net/
       search_key    = 'YOUR-ACS-KEY-HERE' # or use the Get-Secret cmdlet to retrieve the value
       search_index = 'YOUR-INDEX-NAME-HERE' # the name of your ACS index
   }

   # Completion text
   $body = @{
    dataSources = @(
        @{
            type = 'AzureCognitiveSearch'
            parameters = @{
                    endpoint = $acs.search_endpoint
                    key = $acs.search_key
                    indexName = $acs.search_index
                }
        }
    )
    messages = @(
            @{
                role = 'user'
                content = 'What are my available health plans?'
            }
    )
   } | convertto-json -depth 5

   # Header for authentication
   $headers = [ordered]@{
       'api-key' = $openai.api_key
   }

   # Send a completion call to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/extensions/chat/completions?api-version=$($openai.api_version)"

   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response.choices.messages[1].content

Salida de ejemplo

The available health plans in the Contoso Electronics plan and benefit packages are the Northwind Health Plus and Northwind Standard plans.

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.

Tuve un problema al enviar la solicitud.

Chatee con el modelo a través de una aplicación web

Para empezar a chatear con el modelo de Azure OpenAI que usa sus datos, podría implementar una aplicación web mediante Azure OpenAI Studio o el código de ejemplo que proporcionamos en GitHub. Esta aplicación se implementa con Azure App Service y proporciona una interfaz de usuario para enviar consultas. Esta aplicación se puede usar por modelos de Azure OpenAI que usen sus datos o modelos que no los usen. Consulte el archivo Léame del repositorio para obtener instrucciones sobre los requisitos, la configuración y la implementación. Opcionalmente, puede personalizar la lógica de front-end y back-end de la aplicación web realizando cambios en el código fuente.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

Crear un entorno de Go

  1. Crear una nueva carpeta denominada openai-go para el proyecto y un nuevo archivo de código de Go denominado sample.go. Cambie a ese directorio:

    mkdir openai-go
cd openai-go

  2. Instale los siguientes paquetes de Go:

    go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai

  3. Habilite el seguimiento de dependencias para el código.

    go mod init example/azure-openai

Crear la aplicación Go

  1. En el directorio del proyecto, abra el archivo sample.go y agregue el código siguiente:

    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("AZURE_OPENAI_DEPLOYMENT_ID")

 // Ex: "https://<your-azure-openai-host>.openai.azure.com"
 azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

 // Azure AI Search configuration
 searchIndex := os.Getenv("AZURE_AI_SEARCH_INDEX")
 searchEndpoint := os.Getenv("AZURE_AI_SEARCH_ENDPOINT")
 searchAPIKey := os.Getenv("AZURE_AI_SEARCH_API_KEY")

 if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" || searchIndex == "" || searchEndpoint == "" || searchAPIKey == "" {
 	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.Fatalf("ERROR: %s", err)
 }

 resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
 	Messages: []azopenai.ChatRequestMessageClassification{
 		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What are my available health plans?")},
 	},
 	MaxTokens: to.Ptr[int32](512),
 	AzureExtensionsOptions: []azopenai.AzureChatExtensionConfigurationClassification{
 		&azopenai.AzureCognitiveSearchChatExtensionConfiguration{
 			// This allows Azure OpenAI to use an Azure AI Search index.
 			//
 			// > Because the model has access to, and can reference specific sources to support its responses, answers are not only based on its pretrained knowledge
 			// > but also on the latest information available in the designated data source. This grounding data also helps the model avoid generating responses
 			// > based on outdated or incorrect information.
 			//
 			// Quote from here: https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/use-your-data
 			Parameters: &azopenai.AzureCognitiveSearchChatExtensionParameters{
 				Endpoint:  &searchEndpoint,
 				IndexName: &searchIndex,
 				Authentication: &azopenai.OnYourDataAPIKeyAuthenticationOptions{
 					Key: &searchAPIKey,
 				},
 			},
 		},
 	},
 	DeploymentName: &modelDeploymentID,
 }, nil)

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

 // Contains contextual information from your Azure chat completion extensions, configured above in `AzureExtensionsOptions`
 msgContext := resp.Choices[0].Message.Context

 fmt.Fprintf(os.Stderr, "Extensions Context Role: %s\nExtensions Context (length): %d\n",
 	*msgContext.Messages[0].Role,
 	len(*msgContext.Messages[0].Content))

 fmt.Fprintf(os.Stderr, "ChatRole: %s\nChat content: %s\n",
 	*resp.Choices[0].Message.Role,
 	*resp.Choices[0].Message.Content,
 )
}

    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.

  2. Ejecute el siguiente comando:

    go run sample.go

    La aplicación imprime la respuesta, que incluye tanto las respuestas a la consulta como las citas de los archivos cargados.

He tenido un problema al ejecutar los códigos de muestra.

Recuperación de variables necesarias

Para realizar correctamente una llamada a Azure OpenAI, necesitará las siguientes variables. Este inicio rápido supone que cargó los datos en una cuenta de Azure Blob Storage y que creó un índice de Azure AI Search. Consulte Añada sus datos mediante Azure AI Studio

Nombre de la variable Value
AZURE_OPENAI_ENDPOINT Este valor se puede encontrar en la sección Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. Como alternativa, puede encontrar el valor en Azure AI Studio>Área de juegos de chat>Vista Código. Punto de conexión de ejemplo: https://my-resoruce.openai.azure.com.
AZURE_OPENAI_API_KEY Este valor se puede encontrar en la sección Administración de recursos>Claves y Punto de conexión al examinar su recurso de Azure OpenAI en Azure Portal. 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.
AZURE_OPENAI_DEPLOYMENT_ID Este valor se corresponde con el nombre personalizado que eligió para la implementación al implementar un modelo. Este valor se puede encontrar en Administración de recursos>Implementaciones en Azure Portal, o bien en Administración>Implementaciones en Azure AI Studio.
AZURE_AI_SEARCH_ENDPOINT Este valor se puede encontrar en la sección Información general al examinar su recurso de Azure AI Search de Azure Portal.
AZURE_AI_SEARCH_API_KEY Este valor se puede encontrar en la sección Configuración>Claves al examinar su recurso de Azure AI Search en Azure Portal. Puede usar la clave de administrador principal o la clave de administrador secundaria. Tener siempre dos claves permite rotar y regenerar las claves de forma segura sin provocar una interrupción del servicio.
AZURE_AI_SEARCH_INDEX Este valor se corresponde con el nombre del índice que creó para almacenar los datos. Puede encontrarlo en la sección Información general, al examinar el recurso de Azure AI Search desde Azure Portal.

Variables de entorno

setx AZURE_OPENAI_ENDPOINT REPLACE_WITH_YOUR_AOAI_ENDPOINT_VALUE_HERE

setx AZURE_OPENAI_API_KEY REPLACE_WITH_YOUR_AOAI_KEY_VALUE_HERE

setx AZURE_OPENAI_DEPLOYMENT_ID REPLACE_WITH_YOUR_AOAI_DEPLOYMENT_VALUE_HERE

setx AZURE_AI_SEARCH_ENDPOINT REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_VALUE_HERE

setx AZURE_AI_SEARCH_API_KEY REPLACE_WITH_YOUR_AZURE_SEARCH_RESOURCE_KEY_VALUE_HERE

setx AZURE_AI_SEARCH_INDEX REPLACE_WITH_YOUR_INDEX_NAME_HERE

He tenido un problema con la configuración.

Comandos cURL de ejemplo

Los modelos de chat de Azure OpenAI 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 sistemas, usuarios y asistentes. La variable dataSources se conecta al índice de Azure AI Search y permite a los modelos de Azure OpenAI responder usando sus datos.

Para desencadenar una respuesta del modelo, debe terminar con un mensaje de usuario indicando que es el turno de responder del asistente.

Sugerencia

Hay varios parámetros que puede usar para cambiar la respuesta del modelo, como temperature o top_p. Vea la documentación de referencia para más información.

curl -i -X POST $AZURE_OPENAI_ENDPOINT/openai/deployments/$AZURE_OPENAI_DEPLOYMENT_ID/chat/completions?api-version=2024-02-15-preview \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d \
'
{
    "data_sources": [
        {
            "type": "AzureCognitiveSearch",
            "parameters": {
                "endpoint": "'$AZURE_AI_SEARCH_ENDPOINT'",
                "key": "'$AZURE_AI_SEARCH_API_KEY'",
                "index_name": "'$AZURE_AI_SEARCH_INDEX'"
            }
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "What are my available health plans?"
        }
    ]
}
'

Salida de ejemplo

{
    "id": "12345678-1a2b-3c4e5f-a123-12345678abcd",
    "model": "gpt-4",
    "created": 1709835345,
    "object": "extensions.chat.completion",
    "choices": [
        {
            "index": 0,
            "finish_reason": "stop",
            "message": {
                "role": "assistant",
                "content": "The available health plans in the Contoso Electronics plan and benefit packages are the Northwind Health Plus and Northwind Standard plans. [doc1].",
                "end_turn": true,
                "context": {
                    "citations": [
                        {
                            "content": "...",
                            "title": "...",
                            "url": "https://mysearch.blob.core.windows.net/xyz/001.txt",
                            "filepath": "001.txt",
                            "chunk_id": "0"
                        }
                    ],
                    "intent": "[\"Available health plans\"]"
                }
            }
        }
    ],
    "usage": {
        "prompt_tokens": 3779,
        "completion_tokens": 105,
        "total_tokens": 3884
    }
}

Tuve un problema al enviar la solicitud.

Chatee con el modelo a través de una aplicación web

Para empezar a chatear con el modelo de Azure OpenAI que usa sus datos, podría implementar una aplicación web mediante Azure OpenAI Studio o el código de ejemplo que proporcionamos en GitHub. Esta aplicación se implementa con Azure App Service y proporciona una interfaz de usuario para enviar consultas. Esta aplicación se puede usar por modelos de Azure OpenAI que usen sus datos o modelos que no los usen. Consulte el archivo Léame del repositorio para obtener instrucciones sobre los requisitos, la configuración y la implementación. Opcionalmente, puede personalizar la lógica de front-end y back-end de la aplicación web realizando cambios en el código fuente.

Limpieza de recursos

Si quiere limpiar y quitar un recurso de Azure OpenAI o Azure AI Search, 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.

Pasos siguientes