Compartir a través de

Biblioteca cliente de Azure OpenAI para JavaScript: versión 1.0.0-beta.12

  • Artículo

La biblioteca cliente de Azure OpenAI para JavaScript es una adaptación de las API REST de OpenAI que proporciona una interfaz idiomática e integración enriquecida con el resto del ecosistema del SDK de Azure. Puede conectarse a recursos de Azure OpenAI o al punto de conexión de inferencia de OpenAI que no es de Azure, lo que lo convierte en una excelente opción para el desarrollo de OpenAI que no sea de Azure.

Use la biblioteca cliente de Azure OpenAI para:

Azure OpenAI es un servicio administrado que permite a los desarrolladores implementar, optimizar y generar contenido a partir de modelos de OpenAI en recursos de Azure.

Consulte los ejemplos siguientes:

Vínculos principales:

Introducción

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

const client = new OpenAIClient(
  "https://<resource name>.openai.azure.com/", 
  new AzureKeyCredential("<Azure API key>")
);
const { id, created, choices, usage } = await client.getCompletions("<deployment ID>", ["YOUR PROMPT HERE"]);

Entornos admitidos actualmente

Requisitos previos

Si desea usar un recurso de Azure OpenAI, debe tener una suscripción de Azure y acceso a Azure OpenAI. Esto le permitirá crear un recurso de Azure OpenAI y obtener una dirección URL de conexión, así como claves de API. Para más información, consulte Inicio rápido: Introducción a la generación de texto mediante el servicio Azure OpenAI.

Si quiere usar la biblioteca cliente de JS de Azure OpenAI para conectarse a openAI que no es de Azure, necesitará una clave de API de una cuenta de desarrollador en https://platform.openai.com/.

Instalar el paquete @azure/openai

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

npm install @azure/openai

Crear y autenticar una OpenAIClient

Para configurar un cliente para su uso con Azure OpenAI, proporcione un URI de punto de conexión válido a un recurso de Azure OpenAI junto con una credencial de clave, credenciales de token o credenciales de identidad de Azure autorizadas para usar el recurso de Azure OpenAI. Para configurar el cliente para conectarse al servicio de OpenAI, proporcione una clave de API desde el portal para desarrolladores de OpenAI.

Uso de una clave de API de Azure

Use Azure Portal para ir al recurso de OpenAI y recuperar una clave de API, o bien use el fragmento de código de la CLI de Azure siguiente:

Nota: A veces, la clave de API se conoce como "clave de suscripción" o "clave de API de suscripción".

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Una vez que tenga una clave de API y un punto de conexión, puede usar la AzureKeyCredential clase para autenticar el cliente de la siguiente manera:

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

const client = new OpenAIClient("<endpoint>", new AzureKeyCredential("<API key>"));

Uso de una credencial de Azure Active Directory

La autenticación de clave de API de cliente se usa en la mayoría de los ejemplos, pero también puede autenticarse con Azure Active Directory mediante la biblioteca de identidades de Azure. Para usar el proveedor DefaultAzureCredential que se muestra a continuación u otros proveedores de credenciales proporcionados con el SDK de Azure, instale el paquete @azure/identity:

npm install @azure/identity

También tendrá que registrar una nueva aplicación de AAD y conceder acceso a OpenAI mediante la asignación del "Cognitive Services User" rol a la entidad de servicio (tenga en cuenta que otros roles como "Owner" no concederán los permisos necesarios, solo "Cognitive Services User" serán suficientes para ejecutar los ejemplos y el código de ejemplo).

Establezca los valores del identificador de cliente, el identificador de inquilino y el secreto de cliente de la aplicación de AAD como variables de entorno: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

const { OpenAIClient } = require("@azure/openai");
const { DefaultAzureCredential } = require("@azure/identity");

const client = new OpenAIClient("<endpoint>", new DefaultAzureCredential());

Uso de una clave de API de OpenAI

Para configurar el cliente para conectarse al servicio de OpenAI, proporcione una clave de API desde el portal para desarrolladores de OpenAI. Una vez que tenga una clave de API, puede usar la OpenAIKeyCredential clase para autenticar el cliente de la siguiente manera:

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

const client = new OpenAIClient(new OpenAIKeyCredential("<API key>"));

Conceptos clave

El concepto principal que se debe comprender es Finalizaciones. Brevemente explicado, las finalizaciones proporcionan su funcionalidad en forma de mensaje de texto, que mediante un modelo específico, intentarán coincidir con el contexto y los patrones, proporcionando un texto de salida. El siguiente fragmento de código proporciona información general aproximada:

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

async function main(){
  const client = new OpenAIClient(
  "https://your-azure-openai-resource.com/",
  new AzureKeyCredential("your-azure-openai-resource-api-key"));

  const { choices } = await client.getCompletions(
    "text-davinci-003", // assumes a matching model deployment or model name
    ["Hello, world!"]);

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

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

Ejemplos

Puede familiarizarse con diferentes API mediante ejemplos.

Generar respuesta de bot de chat

En este ejemplo se autentica mediante defaultAzureCredential y, a continuación, se generan respuestas de chat a preguntas y mensajes de chat de entrada.

const { OpenAIClient } = require("@azure/openai");
const { DefaultAzureCredential } = require("@azure/identity");

async function main(){
  const endpoint = "https://myaccount.openai.azure.com/";
  const client = new OpenAIClient(endpoint, new DefaultAzureCredential());

  const deploymentId = "gpt-35-turbo";

  const messages = [
    { role: "system", content: "You are a helpful assistant. You will talk like a pirate." },
    { role: "user", content: "Can you help me?" },
    { role: "assistant", content: "Arrrr! Of course, me hearty! What can I do for ye?" },
    { role: "user", content: "What's the best way to train a parrot?" },
  ];

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

  const events = await client.streamChatCompletions(deploymentId, messages, { maxTokens: 128 });
  for await (const event of events) {
    for (const choice of event.choices) {
      const delta = choice.delta?.content;
      if (delta !== undefined) {
        console.log(`Chatbot: ${delta}`);
      }
    }
  }
}

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

Generación de varias finalizaciones con clave de suscripción

En este ejemplo se generan respuestas de texto a mensajes de entrada mediante una clave de suscripción de Azure.

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

async function main(){
  // Replace with your Azure OpenAI key
  const key = "YOUR_AZURE_OPENAI_KEY";
  const endpoint = "https://myaccount.openai.azure.com/";
  const client = new OpenAIClient(endpoint, new AzureKeyCredential(key));

  const examplePrompts = [
    "How are you today?",
    "What is Azure OpenAI?",
    "Why do children love dinosaurs?",
    "Generate a proof of Euler's identity",
    "Describe in single words only the good things that come into your mind about your mother.",
  ];

  const deploymentName = "text-davinci-003";

  let promptIndex = 0;
  const { choices } = await client.getCompletions(deploymentName, examplePrompts);
  for (const choice of choices) {
    const completion = choice.text;
    console.log(`Input: ${examplePrompts[promptIndex++]}`);
    console.log(`Chatbot: ${completion}`);
  }
}

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

Resumir texto con finalización

En este ejemplo se genera un resumen del símbolo del sistema de entrada especificado.

const { OpenAIClient } = require("@azure/openai");
const { DefaultAzureCredential } = require("@azure/identity")

async function main(){
  const endpoint = "https://myaccount.openai.azure.com/";
  const client = new OpenAIClient(endpoint, new DefaultAzureCredential());

  const textToSummarize = `
    Two independent experiments reported their results this morning at CERN, Europe's high-energy physics laboratory near Geneva in Switzerland. Both show convincing evidence of a new boson particle weighing around 125 gigaelectronvolts, which so far fits predictions of the Higgs previously made by theoretical physicists.

    ""As a layman I would say: 'I think we have it'. Would you agree?"" Rolf-Dieter Heuer, CERN's director-general, asked the packed auditorium. The physicists assembled there burst into applause.
  :`;

  const summarizationPrompt = [`
    Summarize the following text.

    Text:
    """"""
    ${textToSummarize}
    """"""

    Summary:
  `];

  console.log(`Input: ${summarizationPrompt}`);

  const deploymentName = "text-davinci-003";

  const { choices } = await client.getCompletions(deploymentName, summarizationPrompt, {
    maxTokens: 64
  });
  const completion = choices[0].text;
  console.log(`Summarization: ${completion}`);
}

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

Uso de herramientas de chat

Las herramientas amplían las finalizaciones de chat al permitir que un asistente invoque funciones definidas y otras funcionalidades en el proceso de completar una solicitud de finalizaciones de chat. Para usar herramientas de chat, empiece por definir una herramienta de función:

const getCurrentWeather = {
    name: "get_current_weather",
    description: "Get the current weather in a given location",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "The city and state, e.g. San Francisco, CA",
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
        },
      },
      required: ["location"],
    },
  };

Con la herramienta definida, incluya esa nueva definición en las opciones de una solicitud de finalización de chat:

const deploymentName = "gpt-35-turbo-1106";
const messages = [{ role: "user", content: "What is the weather like in Boston?" }];
const options = {
    tools: [
      {
        type: "function",
        function: getCurrentWeather,
      },
    ],
  };
const events = client.getChatCompletions(deploymentId, messages, options);

Cuando el asistente decide que se deben usar una o varias herramientas, el mensaje de respuesta incluye una o varias "llamadas a herramientas" que deben resolverse a través de "mensajes de herramientas" en la solicitud posterior. Esta resolución de llamadas de herramienta a nuevos mensajes de solicitud se puede considerar como una especie de "devolución de llamada" para finalizaciones de chat.

// Purely for convenience and clarity, this function handles tool call responses.
function applyToolCall({ function: call, id }) {
    if (call.name === "get_current_weather") {
      const { location, unit } = JSON.parse(call.arguments);
      // In a real application, this would be a call to a weather API with location and unit parameters
      return {
        role: "tool",
        content: `The weather in ${location} is 72 degrees ${unit} and sunny.`,
        toolCallId: id,
      }
    }
    throw new Error(`Unknown tool call: ${call.name}`);
}

Para proporcionar resoluciones de llamada de herramienta al asistente para permitir que la solicitud continúe, proporcione todo el contexto histórico anterior, incluidos los mensajes originales del sistema y del usuario, la respuesta del asistente que incluía las llamadas a la herramienta y los mensajes de herramienta que resolvieron cada una de esas herramientas, al realizar una solicitud posterior.

const choice = result.choices[0];
const responseMessage = choice.message;
if (responseMessage?.role === "assistant") {
  const requestedToolCalls = responseMessage?.toolCalls;
  if (requestedToolCalls?.length) {
    const toolCallResolutionMessages = [
      ...messages,
      responseMessage,
      ...requestedToolCalls.map(applyToolCall),
    ];
    const result = await client.getChatCompletions(deploymentName, toolCallResolutionMessages);
    // continue handling the response as normal
  }
}

Generación de imágenes con modelos de generación de imágenes DALL-E

En este ejemplo se generan imágenes por lotes a partir de un mensaje de entrada determinado.

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

async function main() {
  const endpoint = "https://myaccount.openai.azure.com/";
  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));

  const deploymentName = "dalle-3";
  const prompt = "a monkey eating a banana";
  const size = "1024x1024";
  const n = 1;
  
  const results = await client.getImages(deploymentName, prompt, { n, size });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

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

Análisis de datos profesionales

En este ejemplo se generan respuestas de chat a preguntas de chat de entrada sobre los datos empresariales. Los datos empresariales se proporcionan a través de un índice de Azure Cognitive Search. Para más información sobre cómo configurar un índice de Azure Cognitive Search como origen de datos, consulte Inicio rápido: Chatear con modelos de Azure OpenAI mediante sus propios datos.

const { OpenAIClient } = require("@azure/openai");
const { DefaultAzureCredential } = require("@azure/identity");

async function main(){
  const endpoint = "https://myaccount.openai.azure.com/";
  const client = new OpenAIClient(endpoint, new DefaultAzureCredential());

  const deploymentId = "gpt-35-turbo";

  const messages = [
    { role: "user", content: "What's the most common customer feedback about our product?" },
  ];

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

  const events = await client.streamChatCompletions(deploymentId, messages, { 
    maxTokens: 128,
    azureExtensionOptions: {
      extensions: [
        {
          type: "AzureCognitiveSearch",
          endpoint: "<Azure Cognitive Search endpoint>",
          key: "<Azure Cognitive Search admin key>",
          indexName: "<Azure Cognitive Search index name>",
        },
      ],
    },
  });
  for await (const event of events) {
    for (const choice of event.choices) {
      const delta = choice.delta?.content;
      if (delta !== undefined) {
        console.log(`Chatbot: ${delta}`);
      }
    }
  }
}

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

Transcripción y traducción de archivos de audio

Las funcionalidades de conversión de voz en texto y traducción de Azure OpenAI se pueden usar para transcribir y traducir una amplia variedad de formatos de archivo de audio. En el ejemplo siguiente se muestra cómo usar el getAudioTranscription método para transcribir audio en el idioma en el que se encuentra el audio. También puede traducir y transcribir el audio en inglés mediante el getAudioTranslation método .

El archivo de audio se puede cargar en la memoria mediante las API del sistema de archivos nodeJS. En el explorador, el archivo se puede cargar mediante la FileReader API y la salida del método de arrayBuffer instancia se puede pasar al getAudioTranscription método .

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

async function main() {
  console.log("== Transcribe Audio Sample ==");

  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));
  const deploymentName = "whisper";
  const audio = await fs.readFile("< path to an audio file >");
  const result = await client.getAudioTranscription(deploymentName, audio);

  console.log(`Transcription: ${result.text}`);
}

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

Chatear con imágenes mediante gpt-4-vision-preview

El gpt-4-vision-preview modelo permite usar imágenes como componentes de entrada en finalizaciones de chat.

Para ello, proporcione elementos de contenido distintos en los mensajes de usuario para la solicitud de finalizaciones de chat:

const url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
const deploymentName = "gpt-4-1106-preview";
const messages: ChatRequestMessage[] = [{role: "user", content: [{
  type: "image_url",
  imageUrl: {
    url,
    detail: "auto"
  }
}]}];

Las finalizaciones de chat continuarán como de costumbre, aunque el modelo puede informar de lo más informativo finish_details en lugar de finish_reason:

const result = await client.getChatCompletions(deploymentName, messages);
console.log(`Chatbot: ${result.choices[0].message?.content}`);

Solución de problemas

Registro

La habilitación del registro puede ayudar a descubrir información útil sobre los errores. Para ver un registro de solicitudes y respuestas HTTP, establezca la variable de entorno AZURE_LOG_LEVEL en info. Como alternativa, el registro se puede habilitar en tiempo de ejecución llamando a setLogLevel en @azure/logger:

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

Para obtener instrucciones más detalladas sobre cómo habilitar los registros, consulte los documentos del paquete @azure/logger.