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

Artigo
04/02/2024

A biblioteca de cliente do Azure OpenAI para JavaScript é uma adaptação das APIs REST da OpenAI que fornece uma interface idiomática e uma integração avançada com o resto do ecossistema do SDK do Azure. Pode ligar-se aos recursos do Azure OpenAI ou ao ponto final de inferência não Azure OpenAI, tornando-o uma ótima opção para o desenvolvimento não Azure OpenAI.

Utilize a biblioteca de cliente do Azure OpenAI para:

O Azure OpenAI é um serviço gerido que permite aos programadores implementar, otimizar e gerar conteúdo a partir de modelos OpenAI em recursos do Azure.

Veja os seguintes exemplos:

Múltiplas Conclusões
Chatbot
Resumir Texto
Utilizar Ferramentas de Chat
Gerar Imagens
Analisar Dados de Negócio
Transcrever e Traduzir ficheiros de áudio
Conversar com imagens com gpt-4-vision-preview

Ligações 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 atualmente suportados

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

Pré-requisitos

Se quiser utilizar um recurso do Azure OpenAI, tem de ter uma subscrição do Azure e acesso openAI do Azure. Isto permite-lhe criar um recurso do Azure OpenAI e obter um URL de ligação, bem como chaves de API. Para obter mais informações, veja Início Rápido: Começar a gerar texto com o Serviço OpenAI do Azure.

Se quiser utilizar a biblioteca de cliente do Azure OpenAI JS para ligar ao OpenAI não Azure, precisará de uma chave de API de uma conta de programador em https://platform.openai.com/.

Instalar o pacote `@azure/openai`

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

npm install @azure/openai

Criar e autenticar um `OpenAIClient`

Para configurar um cliente para utilização com o Azure OpenAI, forneça um URI de ponto final válido a um recurso do Azure OpenAI juntamente com uma credencial de chave correspondente, credencial de token ou credencial de identidade do Azure autorizada a utilizar o recurso do Azure OpenAI. Para, em vez disso, configurar o cliente para ligar ao serviço do OpenAI, forneça uma chave de API a partir do portal de programador da OpenAI.

Utilizar uma Chave de API do Azure

Utilize o Portal do Azure para navegar para o recurso OpenAI e obter uma chave de API ou utilize o fragmento da CLI do Azure abaixo:

Nota: Por vezes, a chave de API é referida como uma "chave de subscrição" ou "chave de API de subscrição".

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

Assim que tiver uma chave de API e um ponto final, pode utilizar a AzureKeyCredential classe para autenticar o cliente da seguinte forma:

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

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

Utilizar uma Credencial do Azure Active Directory

A autenticação da chave de API de cliente é utilizada na maioria dos exemplos, mas também pode autenticar com o Azure Active Directory com a biblioteca de Identidade do Azure. Para utilizar o fornecedor DefaultAzureCredential apresentado abaixo ou outros fornecedores de credenciais fornecidos com o SDK do Azure, instale o @azure/identity pacote:

npm install @azure/identity

Também terá de registar uma nova aplicação do AAD e conceder acesso ao OpenAI ao atribuir a "Cognitive Services User" função ao principal de serviço (nota: outras funções como "Owner" não concederão as permissões necessárias, apenas "Cognitive Services User" serão suficientes para executar os exemplos e o código de exemplo).

Defina os valores do ID do cliente, do ID do inquilino e do segredo do cliente da aplicação do 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());

Utilizar uma Chave de API do OpenAI

Para, em vez disso, configurar o cliente para ligar ao serviço do OpenAI, forneça uma chave de API a partir do portal de programador da OpenAI. Assim que tiver uma chave de API, pode utilizar a OpenAIKeyCredential classe para autenticar o cliente da seguinte forma:

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

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

Conceitos-chave

O principal conceito a compreender é Conclusãos. Resumidamente, as conclusões fornecem a respetiva funcionalidade na forma de uma linha de texto que, ao utilizar um modelo específico, tentará, em seguida, corresponder ao contexto e aos padrões, fornecendo um texto de saída. O fragmento de código seguinte fornece uma descriçã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

Pode familiarizar-se com diferentes APIs com Exemplos.

Gerar Resposta do Chatbot

Este exemplo autentica-se com um DefaultAzureCredential e, em seguida, gera respostas de chat para introduzir 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 Múltiplas Conclusões Com Chave de Subscrição

Este exemplo gera respostas de texto a pedidos de entrada com uma chave de subscrição 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 pedido 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);
});

Utilizar ferramentas de chat

As ferramentas expandem as conclusões de chat ao permitir que um assistente invoque funções definidas e outras capacidades no processo de cumprimento de um pedido de conclusão de chat. Para utilizar ferramentas de chat, comece por definir 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 um pedido 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 decidir que uma ou mais ferramentas devem ser utilizadas, a mensagem de resposta inclui uma ou mais "chamadas de ferramentas" que têm de ser resolvidas através de "mensagens de ferramentas" no pedido subsequente. Esta resolução de chamadas de ferramentas para novas mensagens de pedido pode ser considerada uma espécie de "chamada de retorno" para conclusão 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 chamadas de ferramentas ao assistente para permitir que o pedido continue, forneça todo o contexto histórico anterior , incluindo o sistema original e as mensagens de utilizador, a resposta do assistente que incluía as chamadas de ferramentas e as mensagens de ferramentas que resolveram cada uma dessas ferramentas ao fazer um pedido 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 imagens DALL-E

Este exemplo gera imagens em lote a partir de um determinado pedido 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 de Negócio

Este exemplo gera respostas de chat para perguntas de chat de entrada sobre os seus dados empresariais. Os dados empresariais são fornecidos através de um índice de Azure Cognitive Search. Para saber mais sobre como configurar um índice de Azure Cognitive Search como uma origem de dados, veja Início Rápido: Conversar com modelos openAI do Azure com os 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);
});

Transcreva e traduza ficheiros de áudio

As capacidades de conversão e conversão de voz para texto do Azure OpenAI podem ser utilizadas para transcrever e traduzir uma grande variedade de formatos de ficheiro de áudio. O exemplo seguinte mostra como utilizar o getAudioTranscription método para transcrever áudio para o idioma em que o áudio se encontra. Também pode traduzir e transcrever o áudio para inglês com o getAudioTranslation método .

O ficheiro de áudio pode ser carregado para a memória com as APIs do sistema de ficheiros NodeJS. No browser, o ficheiro pode ser carregado com a FileReader API e a saída do método de arrayBuffer instância pode ser transmitida 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 com gpt-4-vision-preview

O gpt-4-vision-preview modelo permite-lhe utilizar imagens como componentes de entrada nas conclusões de chat.

Para tal, forneça itens de conteúdo distintos nas mensagens de utilizador para o pedido de conclusão 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 do Chat continuarão como de costume, embora o modelo possa comunicar 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}`);

Resolução de problemas

Registo

Ativar o registo pode ajudar a descobrir informações úteis sobre falhas. Para ver um registo de pedidos HTTP e respostas, defina a variável de AZURE_LOG_LEVEL ambiente como info. Em alternativa, o registo pode ser ativado no runtime ao chamar setLogLevel no @azure/logger:

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

setLogLevel("info");

Para obter instruções mais detalhadas sobre como ativar registos, pode ver os documentos do pacote de @azure/logger.

Partilhar via

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

Introdução

Ambientes atualmente suportados

Pré-requisitos

Instalar o pacote `@azure/openai`

Criar e autenticar um `OpenAIClient`

Utilizar uma Chave de API do Azure

Utilizar uma Credencial do Azure Active Directory

Utilizar uma Chave de API do OpenAI

Conceitos-chave

Exemplos

Gerar Resposta do Chatbot

Gerar Múltiplas Conclusões Com Chave de Subscrição

Resumir Texto com Conclusão

Utilizar ferramentas de chat

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

Analisar Dados de Negócio

Transcreva e traduza ficheiros de áudio

Conversar com imagens com gpt-4-vision-preview

Resolução de problemas

Registo

Recursos adicionais

Partilhar via

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

Introdução

Ambientes atualmente suportados

Pré-requisitos

Instalar o pacote @azure/openai

Criar e autenticar um OpenAIClient

Utilizar uma Chave de API do Azure

Utilizar uma Credencial do Azure Active Directory

Utilizar uma Chave de API do OpenAI

Conceitos-chave

Exemplos

Gerar Resposta do Chatbot

Gerar Múltiplas Conclusões Com Chave de Subscrição

Resumir Texto com Conclusão

Utilizar ferramentas de chat

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

Analisar Dados de Negócio

Transcreva e traduza ficheiros de áudio

Conversar com imagens com gpt-4-vision-preview

Resolução de problemas

Registo

Recursos adicionais

Instalar o pacote `@azure/openai`

Criar e autenticar um `OpenAIClient`