Biblioteca de clientes do OpenAI do Azure para JavaScript – versão 1.0.0-beta.12

Artigo
04/04/2024

A biblioteca de clientes openAI do Azure para JavaScript é uma adaptação das APIs REST do OpenAI que fornece uma interface idiomática e uma integração avançada com o restante do ecossistema do SDK do Azure. Ele pode se conectar aos recursos do OpenAI do Azure ou ao ponto de extremidade de inferência do OpenAI não Azure, tornando-o uma ótima opção até mesmo para o desenvolvimento não Azure OpenAI.

Use a biblioteca de clientes do OpenAI do Azure para:

O OpenAI do Azure é um serviço gerenciado que permite que os desenvolvedores implantem, ajustem e gerem conteúdo de modelos OpenAI em recursos do Azure.

Confira os seguintes exemplos:

Várias conclusões
Chatbot
Resumir Texto
Usar ferramentas de chat
Gerar imagens
Analisar dados corporativos
Transcrever e Traduzir arquivos de áudio
Conversar com imagens usando gpt-4-vision-preview

Links principais:

Introdução

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

Ambientes com suporte no momento

Versões LTS do Node.js
Versões mais recentes do Safari, Chrome, Edge e Firefox.

Pré-requisitos

Se você quiser usar um recurso do OpenAI do Azure, deverá ter uma assinatura do Azure e um acesso openAI do Azure. Isso permitirá que você crie um recurso openAI do Azure e obtenha uma URL de conexão, bem como chaves de API. Para obter mais informações, consulte Início Rápido: Introdução à geração de texto usando o Serviço OpenAI do Azure.

Se você quiser usar a biblioteca de clientes do OpenAI JS do Azure para se conectar ao OpenAI não Azure, precisará de uma chave de API de uma conta de desenvolvedor em https://platform.openai.com/.

Instalar o pacote `@azure/openai`

Instale a biblioteca de clientes do Cliente OpenAI do Azure para JavaScript com npm:

npm install @azure/openai

Criar e autenticar um `OpenAIClient`

Para configurar um cliente para uso com o OpenAI do Azure, forneça um URI de ponto de extremidade válido para um recurso do OpenAI do Azure, juntamente com uma credencial de chave correspondente, credencial de token ou credencial de identidade do Azure autorizada a usar o recurso OpenAI do Azure. Para, em vez disso, configurar o cliente para se conectar ao serviço do OpenAI, forneça uma chave de API do portal do desenvolvedor do OpenAI.

Usando uma chave de API do Azure

Use o Portal do Azure para navegar até o recurso OpenAI e recuperar uma chave de API ou usar o snippet da CLI do Azure abaixo:

Nota: Às vezes, a chave de API é chamada de "chave de assinatura" ou "chave de API de assinatura".

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

Depois de ter uma chave de API e um ponto de extremidade, você poderá usar a AzureKeyCredential classe para autenticar o cliente da seguinte maneira:

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

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

Usando uma credencial do Azure Active Directory

A autenticação de chave de API do cliente é usada na maioria dos exemplos, mas você também pode autenticar com o Azure Active Directory usando a biblioteca de identidade do Azure. Para usar o provedor DefaultAzureCredential mostrado abaixo ou outros provedores de credenciais fornecidos com o SDK do Azure, instale o @azure/identity pacote:

npm install @azure/identity

Você também precisará registrar um novo aplicativo do AAD e conceder acesso ao OpenAI atribuindo a "Cognitive Services User" função à entidade de serviço (observação: outras funções, como "Owner" não concederão as permissões necessárias, só "Cognitive Services User" serão suficientes para executar os exemplos e o código de exemplo).

Defina os valores da ID do cliente, da ID do locatário e do segredo do cliente do aplicativo AAD como variáveis de ambiente: 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());

Usando uma chave de API do OpenAI

Para, em vez disso, configurar o cliente para se conectar ao serviço do OpenAI, forneça uma chave de API do portal do desenvolvedor do OpenAI. Depois de ter uma chave de API, você pode usar a OpenAIKeyCredential classe para autenticar o cliente da seguinte maneira:

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

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

Principais conceitos

O conceito main a entender é Conclusões. Brevemente explicado, as conclusões fornecem sua funcionalidade na forma de um prompt de texto, que, usando um modelo específico, tentará corresponder ao contexto e aos padrões, fornecendo um texto de saída. O snippet de código a seguir fornece uma visão geral 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);
});

Exemplos

Você pode se familiarizar com APIs diferentes usando Exemplos.

Gerar resposta do chatbot

Este exemplo autentica usando um DefaultAzureCredential e gera respostas de chat para inserir mensagens e perguntas de chat.

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

Gerar várias conclusões com a chave de assinatura

Este exemplo gera respostas de texto para prompts de entrada usando uma chave de assinatura do 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 com conclusão

Este exemplo gera um resumo do prompt 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);
});

Usar ferramentas de chat

As ferramentas estendem as conclusões de chat permitindo que um assistente invoque funções definidas e outros recursos no processo de atender a uma solicitação de conclusão de chat. Para usar ferramentas de chat, comece definindo uma ferramenta de função:

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"],
    },
  };

Com a ferramenta definida, inclua essa nova definição nas opções para uma solicitação de conclusão 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);

Quando o assistente decide que uma ou mais ferramentas devem ser usadas, a mensagem de resposta inclui uma ou mais "chamadas de ferramenta" que devem ser resolvidas por meio de "mensagens de ferramenta" na solicitação subsequente. Essa resolução de chamadas de ferramenta para novas mensagens de solicitação pode ser considerada como uma espécie de "retorno de chamada" para conclusões 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 fornecer resoluções de chamada de ferramenta ao assistente para permitir que a solicitação continue, forneça todo o contexto histórico anterior , incluindo o sistema original e mensagens de usuário, a resposta do assistente que incluiu as chamadas de ferramenta e as mensagens de ferramenta que resolveram cada uma dessas ferramentas -- ao fazer uma solicitação subsequente.

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

Gerar imagens com modelos de geração de imagem DALL-E

Este exemplo gera imagens em lote de um determinado prompt de entrada.

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

Analisar dados corporativos

Este exemplo gera respostas de chat para perguntas de chat de entrada sobre seus dados comerciais. Os dados corporativos são fornecidos por meio de um índice Azure Cognitive Search. Para saber mais sobre como configurar um índice de Azure Cognitive Search como uma fonte de dados, consulte Início Rápido: Conversar com modelos do OpenAI do Azure usando seus próprios dados.

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

Transcrever e traduzir arquivos de áudio

Os recursos de conversão de fala em texto e tradução do OpenAI do Azure podem ser usados para transcrever e traduzir uma ampla variedade de formatos de arquivo de áudio. O exemplo a seguir mostra como usar o getAudioTranscription método para transcrever áudio no idioma em que o áudio está. Você também pode traduzir e transcrever o áudio em inglês usando o getAudioTranslation método .

O arquivo de áudio pode ser carregado na memória usando as APIs do sistema de arquivos NodeJS. No navegador, o arquivo pode ser carregado usando a FileReader API e a saída do método de arrayBuffer instância pode ser passada para o 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);
});

Conversar com imagens usando gpt-4-vision-preview

O gpt-4-vision-preview modelo permite que você use imagens como componentes de entrada em conclusões de chat.

Para fazer isso, forneça itens de conteúdo distintos nas mensagens do usuário para a solicitação de conclusões 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"
  }
}]}];

As conclusões de chat continuarão como de costume, embora o modelo possa relatar o mais informativo finish_details em vez de finish_reason:

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

Solução de problemas

Registro em log

A habilitação do log pode ajudar a descobrir informações úteis sobre falhas. Para ver um log de solicitações e respostas HTTP, defina a variável de ambiente AZURE_LOG_LEVEL como info. Como alternativa, o log pode ser habilitado no runtime chamando setLogLevel em @azure/logger:

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

setLogLevel("info");

Para obter instruções mais detalhadas sobre como habilitar logs, veja os documentos do pacote @azure/logger.

Compartilhar via

Biblioteca de clientes do OpenAI do Azure para JavaScript – versão 1.0.0-beta.12

Introdução

Ambientes com suporte no momento

Pré-requisitos

Instalar o pacote `@azure/openai`

Criar e autenticar um `OpenAIClient`

Usando uma chave de API do Azure

Usando uma credencial do Azure Active Directory

Usando uma chave de API do OpenAI

Principais conceitos

Exemplos

Gerar resposta do chatbot

Gerar várias conclusões com a chave de assinatura

Resumir texto com conclusão

Usar ferramentas de chat

Gerar imagens com modelos de geração de imagem DALL-E

Analisar dados corporativos

Transcrever e traduzir arquivos de áudio

Conversar com imagens usando gpt-4-vision-preview

Solução de problemas

Registro em log

Recursos adicionais

Compartilhar via

Biblioteca de clientes do OpenAI do Azure para JavaScript – versão 1.0.0-beta.12

Introdução

Ambientes com suporte no momento

Pré-requisitos

Instalar o pacote @azure/openai

Criar e autenticar um OpenAIClient

Usando uma chave de API do Azure

Usando uma credencial do Azure Active Directory

Usando uma chave de API do OpenAI

Principais conceitos

Exemplos

Gerar resposta do chatbot

Gerar várias conclusões com a chave de assinatura

Resumir texto com conclusão

Usar ferramentas de chat

Gerar imagens com modelos de geração de imagem DALL-E

Analisar dados corporativos

Transcrever e traduzir arquivos de áudio

Conversar com imagens usando gpt-4-vision-preview

Solução de problemas

Registro em log

Recursos adicionais

Instalar o pacote `@azure/openai`

Criar e autenticar um `OpenAIClient`