Delen via

Azure OpenAI-clientbibliotheek voor JavaScript - versie 1.0.0-beta.12

  • Artikel

De Azure OpenAI-clientbibliotheek voor JavaScript is een aanpassing van de REST API's van OpenAI die een idiomatische interface en uitgebreide integratie met de rest van het Azure SDK-ecosysteem biedt. Het kan verbinding maken met Azure OpenAI-resources of met het niet-Azure OpenAI-deductieeindpunt, waardoor het een uitstekende keuze is voor zelfs niet-Azure OpenAI-ontwikkeling.

Gebruik de clientbibliotheek voor Azure OpenAI om het volgende te doen:

Azure OpenAI is een beheerde service waarmee ontwikkelaars inhoud van OpenAI-modellen op Azure-resources kunnen implementeren, afstemmen en genereren.

Bekijk de volgende voorbeelden:

Belangrijke koppelingen:

Aan de slag

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

Momenteel ondersteunde omgevingen

Vereisten

Als u een Azure OpenAI-resource wilt gebruiken, moet u een Azure-abonnement en Azure OpenAI-toegang hebben. Hiermee kunt u een Azure OpenAI-resource maken en zowel een verbindings-URL als API-sleutels ophalen. Zie Quickstart: Aan de slag met het genereren van tekst met behulp van Azure OpenAI Service voor meer informatie.

Als u de Azure OpenAI JS-clientbibliotheek wilt gebruiken om verbinding te maken met niet-Azure OpenAI, hebt u een API-sleutel nodig van een ontwikkelaarsaccount op https://platform.openai.com/.

Installeer het pakket @azure/openai

Installeer de Azure OpenAI-clientclientbibliotheek voor JavaScript met npm:

npm install @azure/openai

Een maken en verifiëren OpenAIClient

Als u een client wilt configureren voor gebruik met Azure OpenAI, geeft u een geldige eindpunt-URI op voor een Azure OpenAI-resource, samen met een bijbehorende sleutelreferentie, tokenreferentie of Azure-identiteitsreferentie die is geautoriseerd voor het gebruik van de Azure OpenAI-resource. Als u in plaats daarvan de client wilt configureren om verbinding te maken met de service van OpenAI, geeft u een API-sleutel op vanuit de ontwikkelaarsportal van OpenAI.

Een API-sleutel van Azure gebruiken

Gebruik de Azure-portal om naar uw OpenAI-resource te bladeren en een API-sleutel op te halen, of gebruik het onderstaande Azure CLI-fragment :

Opmerking: Soms wordt de API-sleutel een 'abonnementssleutel' of 'abonnements-API-sleutel' genoemd.

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

Zodra u een API-sleutel en eindpunt hebt, kunt u de AzureKeyCredential klasse als volgt gebruiken om de client te verifiëren:

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

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

Een Azure Active Directory-referentie gebruiken

Verificatie van client-API-sleutels wordt in de meeste voorbeelden gebruikt, maar u kunt zich ook verifiëren met Azure Active Directory met behulp van de Azure Identity-bibliotheek. Als u de hieronder weergegeven DefaultAzureCredential-provider of andere referentieproviders wilt gebruiken die bij de Azure SDK worden geleverd, installeert u het @azure/identity pakket:

npm install @azure/identity

U moet ook een nieuwe AAD-toepassing registreren en toegang verlenen tot OpenAI door de "Cognitive Services User" rol toe te wijzen aan uw service-principal (opmerking: andere rollen, zoals "Owner" die niet de benodigde machtigingen verlenen, zijn alleen "Cognitive Services User" voldoende om de voorbeelden en de voorbeeldcode uit te voeren).

Stel de waarden van de client-id, tenant-id en clientgeheim van de AAD-toepassing in als omgevingsvariabelen: 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());

Een API-sleutel van OpenAI gebruiken

Als u in plaats daarvan de client wilt configureren om verbinding te maken met de service van OpenAI, geeft u een API-sleutel op vanuit de ontwikkelaarsportal van OpenAI. Zodra u een API-sleutel hebt, kunt u de OpenAIKeyCredential klasse als volgt gebruiken om de client te verifiëren:

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

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

Belangrijkste concepten

Het belangrijkste concept dat u moet begrijpen, is Voltooiingen. Kort uitgelegd: voltooiingen biedt de functionaliteit ervan in de vorm van een tekstprompt, die met behulp van een specifiek model vervolgens probeert de context en patronen aan te passen, waardoor een uitvoertekst wordt weergegeven. Het volgende codefragment biedt een globaal overzicht:

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

Voorbeelden

U kunt uzelf vertrouwd maken met verschillende API's met behulp van voorbeelden.

Chatbot-antwoord genereren

In dit voorbeeld wordt geverifieerd met behulp van een DefaultAzureCredential en worden vervolgens chatreacties gegenereerd om chatvragen en -berichten in te voeren.

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

Meerdere voltooiingen genereren met abonnementssleutel

In dit voorbeeld worden tekstantwoorden gegenereerd op invoerprompts met behulp van een Azure-abonnementssleutel

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

Tekst samenvatten met voltooiing

In dit voorbeeld wordt een samenvatting van de opgegeven invoerprompt gegenereerd.

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

Chathulpprogramma's gebruiken

Hulpprogramma's breiden de voltooiing van chats uit door een assistent toe te staan gedefinieerde functies en andere mogelijkheden aan te roepen in het proces van het voltooien van een chataanvraag. Als u chathulpprogramma's wilt gebruiken, definieert u eerst een functiehulpprogramma:

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

Als het hulpprogramma is gedefinieerd, neemt u die nieuwe definitie op in de opties voor een aanvraag voor het voltooien van een 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);

Wanneer de assistent besluit dat een of meer hulpprogramma's moeten worden gebruikt, bevat het antwoordbericht een of meer 'hulpprogramma-aanroepen' die allemaal moeten worden opgelost via 'hulpprogrammaberichten' bij de volgende aanvraag. Deze oplossing van hulpprogrammaaanroepen in nieuwe aanvraagberichten kan worden beschouwd als een soort 'callback' voor het voltooien van chats.

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

Als u oplossingen voor hulpprogrammaaanroepen wilt bieden aan de assistent zodat de aanvraag kan worden voortgezet, geeft u alle eerdere historische context op, inclusief de oorspronkelijke systeem- en gebruikersberichten, het antwoord van de assistent met de hulpprogramma-aanroepen en de hulpprogrammaberichten waarmee elk van deze hulpprogramma's is opgelost, bij het indienen van een volgende aanvraag.

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

Afbeeldingen genereren met DALL-E modellen voor het genereren van installatiekopieën

In dit voorbeeld worden batchinstallatiekopieën gegenereerd op basis van een opgegeven invoerprompt.

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

Zakelijke gegevens analyseren

In dit voorbeeld worden chatreacties gegenereerd om chatvragen over uw bedrijfsgegevens in te voeren. De bedrijfsgegevens worden verstrekt via een Azure Cognitive Search-index. Zie Quickstart: Chatten met Azure OpenAI-modellen met behulp van uw eigen gegevens voor meer informatie over het instellen van een Azure Cognitive Search-index als gegevensbron.

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

Audiobestanden transcriberen en vertalen

De spraak-naar-tekst- en vertaalmogelijkheden van Azure OpenAI kunnen worden gebruikt om een breed scala aan audiobestandsindelingen te transcriberen en te vertalen. In het volgende voorbeeld ziet u hoe u de getAudioTranscription methode gebruikt om audio te transcriberen in de taal waarin de audio zich bevindt. U kunt de audio ook vertalen en transcriberen in het Engels met behulp van de getAudioTranslation methode.

Het audiobestand kan in het geheugen worden geladen met behulp van de NodeJS-bestandssysteem-API's. In de browser kan het bestand worden geladen met behulp van de FileReader API en kan de uitvoer van arrayBuffer de instantiemethode worden doorgegeven aan de getAudioTranscription methode.

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

Chatten met afbeeldingen met behulp van gpt-4-vision-preview

Met gpt-4-vision-preview het model kunt u afbeeldingen gebruiken als invoeronderdelen in chat-voltooiingen.

Hiertoe geeft u afzonderlijke inhoudsitems op voor de gebruikersberichten voor de chat-voltooiingsaanvraag:

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

Voltooiingen van chats gaan vervolgens gewoon door, hoewel het model mogelijk de meer informatieve informatie rapporteert finish_details in plaats van finish_reason:

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

Problemen oplossen

Logboekregistratie

Het inschakelen van logboekregistratie kan helpen bij het ontdekken van nuttige informatie over fouten. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de AZURE_LOG_LEVEL omgevingsvariabele in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door aan te roepen setLogLevel in de @azure/logger:

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

setLogLevel("info");

Voor meer gedetailleerde instructies over het inschakelen van logboeken kunt u de @azure-/loggerpakketdocumenten bekijken.