Rychlý start: Začínáme používat GPT-35-Turbo a GPT-4 se službou Azure OpenAI Service

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Prostředek služby Azure OpenAI s gpt-4o nasazenými modely.gpt-4o-mini Pro počáteční průzkum doporučujeme použít standardní nebo globální standardní typy nasazení modelu. Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Přechod na Azure OpenAI Studio

Přejděte na Azure OpenAI Studio https://oai.azure.com/ a přihlaste se pomocí přihlašovacích údajů, které mají přístup k vašemu prostředku Azure OpenAI. Během nebo po přihlášení vyberte příslušný adresář, předplatné Azure a prostředek Azure OpenAI.

Na cílové stránce Azure OpenAI Studio vyberte Chat playground.

Hřiště

Začněte zkoumat možnosti OpenAI pomocí přístupu bez kódu prostřednictvím chatovacího hřiště Azure OpenAI Studio. Na této stránce můžete rychle iterovat a experimentovat s možnostmi.

Nastavení

Pomocí rozevíracího seznamu *Prompt samples (Ukázky výzvy ) můžete vybrat několik předem načtených příkladů systémových zpráv , které vám pomůžou začít.

Systémové zprávy poskytují modelu pokyny, jak by se měl chovat, a jakýkoli kontext, na který by měl odkazovat při generování odpovědi. Můžete popsat osobnost asistenta, sdělit, co by měl a neměl odpovídat, a sdělit, jak formátovat odpovědi.

Kdykoliv při používání chatovacího hřiště můžete vybrat Zobrazit kód a zobrazit ukázky kódu Python, curl a json předem vyplněné na základě aktuální relace chatu a nastavení. Pak můžete tento kód vzít a napsat aplikaci, aby dokončila stejnou úlohu, kterou právě provádíte s hřištěm.

Relace chatu

Když vyberete tlačítko Enter nebo vyberete ikonu šipky vpravo, odešle se zadaný text do rozhraní API pro dokončování chatu a výsledky se vrátí zpět do textového pole.

Pokud chcete odstranit aktuální historii konverzací, vyberte tlačítko Vymazat chat.

Nastavení klíče

Zobrazit kód

Jakmile budete experimentovat s chatováním s modelem, vyberte <tlačítko /> Zobrazit kód . Tím získáte přehrání kódu za celou konverzací doposud:

Principy struktury výzvy

Pokud si prohlédnete ukázku z kódu View, všimnete si, že konverzace je rozdělená do tří různých rolí system, , userassistant. Pokaždé, když pošlete modelu zprávu o celé historii konverzací až do tohoto okamžiku, bude znovu. Při použití rozhraní API pro dokončování chatu nemá model žádnou skutečnou paměť na to, co jste do něj v minulosti odeslali, abyste zadali historii konverzací, aby model mohl správně reagovat.

Průvodce postupy pro dokončování chatu poskytuje podrobný úvod do nové struktury výzvy a efektivní používání modelů dokončování chatu.

Nasazení modelu

Jakmile budete spokojeni s prostředím v nástroji Azure OpenAI Studio, můžete webovou aplikaci nasadit přímo ze studia výběrem tlačítka Nasadit do .

To vám dává možnost buď nasadit do samostatné webové aplikace, nebo kopírovat v copilot Studiu (Preview), pokud používáte vlastní data v modelu.

Pokud se například rozhodnete nasadit webovou aplikaci:

Při prvním nasazení webové aplikace byste měli vybrat Vytvořit novou webovou aplikaci. Zvolte název aplikace, který se stane součástí adresy URL aplikace. Například https://<appname>.azurewebsites.net.

Vyberte předplatné, skupinu prostředků, umístění a cenový plán publikované aplikace. Pokud chcete aktualizovat existující aplikaci, vyberte Publikovat do existující webové aplikace a v rozevírací nabídce zvolte název předchozí aplikace.

Pokud se rozhodnete nasadit webovou aplikaci, podívejte se na důležité aspekty jeho použití.

Vyčištění prostředků

Jakmile dokončíte testování chatovacího hřiště, můžete prostředek nebo skupinu prostředků Azure OpenAI vyčistit a odebrat. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

• Přečtěte si další informace o tom, jak pracovat s novým gpt-35-turbo modelem pomocí návodu GPT-35-Turbo &GPT-4.
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Šablona podnikového chatu Načtení rozšířené generace (RAG) balíčku zdrojového kódu | (NuGet) | Samples| Retrieval Augmented Generation (RAG) |

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Sada .NET 7 SDK
• Prostředek služby Azure OpenAI s gpt-35-turbo nasazenými modely gpt-4 Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Vytvoření nové aplikace .NET Core

V okně konzoly (například cmd, PowerShell nebo Bash) pomocí dotnet new příkazu vytvořte novou konzolovou aplikaci s názvem azure-openai-quickstart. Tento příkaz vytvoří jednoduchý projekt Hello World s jedním zdrojovým souborem jazyka C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Změňte adresář na nově vytvořenou složku aplikace. Aplikaci můžete sestavit pomocí následujících:

dotnet build

Výstup sestavení by neměl obsahovat žádná upozornění ani chyby.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Nainstalujte klientskou knihovnu OpenAI .NET pomocí:

dotnet add package Azure.AI.OpenAI --prerelease

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření ukázkové aplikace

V adresáři projektu otevřete soubor program.cs a nahraďte následujícím kódem:

Bez streamování odpovědí

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

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

ChatCompletion completion = chatClient.CompleteChat(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");

dotnet run program.cs

Výstup

Assistant : Yes, many other Azure AI services also support customer managed keys, including Azure Cognitive Services, Azure Machine Learning, and Azure Databricks. By using customer managed keys, you can retain complete control over your encryption keys and provide an additional layer of security for your AI assets.

Před tiskem výsledků bude model čekat, až model vygeneruje celou odpověď. Pokud chcete asynchronně streamovat odpověď a vytisknout výsledky, můžete obsah program.cs nahradit kódem v dalším příkladu.

Asynchronní s využitím streamování

using Azure;
using Azure.AI.OpenAI;
using OpenAI.Chat;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureClient.GetChatClient("gpt-35-turbo");

var chatUpdates = chatClient.CompleteChatStreamingAsync(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

await foreach(var chatUpdate in chatUpdates)
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role} : ");
    }
    
    foreach(var contentPart in chatUpdate.ContentUpdate)
    {
        Console.Write(contentPart.Text);
    }
}

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Ukázky balíčku zdrojového kódu | (Go)|

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Místně nainstalovaná verze Go 1.21.0 nebo vyšší.
• Prostředek služby Azure OpenAI s nasazeným modelem gpt-35-turbo . Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření ukázkové aplikace

Vytvořte nový soubor s názvem chat_completions.go. Do souboru chat_completions.go zkopírujte následující kód.

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("YOUR_MODEL_DEPLOYMENT_NAME")
    maxTokens:= int32(400)


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

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		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://video2.skills-academy.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.Printf("ERROR: %s", err)
		return
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatRequestMessageClassification{
		// You set the tone and rules of the conversation with a prompt as the system role.
		&azopenai.ChatRequestSystemMessage{Content: to.Ptr("You are a helpful assistant.")},

		// The user asks a question
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Does Azure OpenAI support customer managed keys?")},

		// The reply would come back from the model. You'd add it to the conversation so we can maintain context.
		&azopenai.ChatRequestAssistantMessage{Content: to.Ptr("Yes, customer managed keys are supported by Azure OpenAI")},

		// The user answers the question based on the latest reply.
		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What other Azure Services support customer managed keys?")},

		// from here you'd keep iterating, sending responses back from ChatGPT
	}

	gotReply := false

	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:       messages,
		DeploymentName: &modelDeploymentID,
		MaxTokens: &maxTokens,
	}, nil)

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

	for _, choice := range resp.Choices {
		gotReply = true

		if choice.ContentFilterResults != nil {
			fmt.Fprintf(os.Stderr, "Content filter results\n")

			if choice.ContentFilterResults.Error != nil {
				fmt.Fprintf(os.Stderr, "  Error:%v\n", choice.ContentFilterResults.Error)
			}

			fmt.Fprintf(os.Stderr, "  Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
			fmt.Fprintf(os.Stderr, "  SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
			fmt.Fprintf(os.Stderr, "  Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
			fmt.Fprintf(os.Stderr, "  Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
		}

		if choice.Message != nil && choice.Message.Content != nil {
			fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
		}

		if choice.FinishReason != nil {
			// this choice's conversation is complete.
			fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
		}
	}

	if gotReply {
		fmt.Fprintf(os.Stderr, "Received chat completions reply\n")
	}

}

Teď otevřete příkazový řádek a spusťte:

go mod init chat_completions.go

Další spuštění:

go mod tidy
go run chat_completions.go

Výstup

Content filter results
  Hate: sev: safe, filtered: false
  SelfHarm: sev: safe, filtered: false
  Sexual: sev: safe, filtered: false
  Violence: sev: safe, filtered: false
Content[0]: As of my last update in early 2023, in Azure, several AI services support the use of customer-managed keys (CMKs) through Azure Key Vault. This allows customers to have control over the encryption keys used to secure their data at rest. The services that support this feature typically fall under Azure's range of cognitive services and might include:

1. Azure Cognitive Search: It supports using customer-managed keys to encrypt the index data.
2. Azure Form Recognizer: For data at rest, you can use customer-managed keys for added security.
3. Azure Text Analytics: CMKs can be used for encrypting your data at rest.
4. Azure Blob Storage: While not exclusively an AI service, it's often used in conjunction with AI services to store data, and it supports customer-managed keys for encrypting blob data.

Note that the support for CMKs can vary by service and sometimes even by the specific feature within the service. Additionally, the landscape of cloud services is fast evolving, and new features, including security capabilities, are frequently added. Therefore, it's recommended to check the latest Azure documentation or contact Azure support for the most current information about CMK support for any specific Azure AI service.
Finish reason[0]: stop
Received chat completions reply

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Artefakt zdrojového kódu | (Maven) | Ukázky | načtení rozšířené generace (RAG) – šablona | podnikového chatu IntelliJ IDEA

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma

• Aktuální verze sady Java Development Kit (JDK)

• Nástroj sestavení Gradle nebo jiný správce závislostí.
• Prostředek služby Azure OpenAI s gpt-35-turbo nasazenými modely gpt-4 Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření nové aplikace v Javě

Vytvořte nový projekt Gradle.

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

mkdir myapp && cd myapp

gradle init Spusťte příkaz z pracovního adresáře. Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně build.gradle.kts, které se používají za běhu k vytvoření a konfiguraci aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace sady Java SDK

V tomto rychlém startu se používá správce závislostí Gradle. Klientskou knihovnu a informace pro další správce závislostí najdete v centrálním úložišti Maven.

Vyhledejte build.gradle.kts a otevřete ho pomocí preferovaného integrovaného vývojového prostředí (IDE) nebo textového editoru. Pak zkopírujte následující konfiguraci sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupním bodem je třída OpenAIQuickstart. Naimportuje knihovnu Azure AI Vision.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.10")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Vytvoření ukázkové aplikace

1. Vytvořte soubor Java.

   Spuštěním následujícího příkazu z pracovního adresáře vytvořte zdrojovou složku projektu:

   mkdir -p src/main/java
   

   Přejděte do nové složky a vytvořte soubor s názvem OpenAIQuickstart.java.

2. Otevřete OpenAIQuickstart.java v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) a vložte následující kód.

   package com.azure.ai.openai.usage;
   
   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.ChatChoice;
   import com.azure.ai.openai.models.ChatCompletions;
   import com.azure.ai.openai.models.ChatCompletionsOptions;
   import com.azure.ai.openai.models.ChatRequestAssistantMessage;
   import com.azure.ai.openai.models.ChatRequestMessage;
   import com.azure.ai.openai.models.ChatRequestSystemMessage;
   import com.azure.ai.openai.models.ChatRequestUserMessage;
   import com.azure.ai.openai.models.ChatResponseMessage;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   import com.azure.core.util.Configuration;
   
   import java.util.ArrayList;
   import java.util.List;
   
   
   public class OpenAIQuickstart {
   
       public static void main(String[] args) {
           String azureOpenaiKey = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_API_KEY");
           String endpoint = Configuration.getGlobalConfiguration().get("AZURE_OPENAI_ENDPOINT");
           String deploymentOrModelId = "{azure-open-ai-deployment-model-id}";
   
           OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<ChatRequestMessage> chatMessages = new ArrayList<>();
           chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant."));
           chatMessages.add(new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"));
           chatMessages.add(new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI?"));
           chatMessages.add(new ChatRequestUserMessage("Do other Azure AI services support this too?"));    
   
           ChatCompletions chatCompletions = client.getChatCompletions(deploymentOrModelId, new ChatCompletionsOptions(chatMessages));
   
           System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
           for (ChatChoice choice : chatCompletions.getChoices()) {
               ChatResponseMessage message = choice.getMessage();
               System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
               System.out.println("Message:");
               System.out.println(message.getContent());
           }
   
           System.out.println();
           CompletionsUsage usage = chatCompletions.getUsage();
           System.out.printf("Usage: number of prompt token is %d, "
                   + "number of completion token is %d, and number of total tokens in request and response is %d.%n",
               usage.getPromptTokens(), usage.getCompletionTokens(), usage.getTotalTokens());
       }
   }
   

   Důležité

   V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace o zabezpečení přihlašovacích údajů najdete v článku zabezpečení služeb Azure AI.

3. Přejděte zpět do kořenové složky projektu a sestavte aplikaci pomocí:

   gradle build
   

   Pak ho spusťte pomocí gradle run příkazu:

   gradle run
   

Výstup

Model ID=chatcmpl-7JYnyE4zpd5gaIfTRH7hNpeVsvAw4 is created at 1684896378.
Index: 0, Chat Role: assistant.
Message:
Yes, most of the Azure AI services support customer managed keys. However, there may be some exceptions, so it is best to check the documentation of each specific service to confirm.

Usage: number of prompt token is 59, number of completion token is 36, and number of total tokens in request and response is 95.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Ukázka artefaktů zdrojového kódu | (Maven) |

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Aktuální verze sady Java Development Kit (JDK)
• Nástroj Spring Boot CLI
• Prostředek služby Azure OpenAI s nasazeným modelem gpt-35-turbo . Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku. Tento příklad předpokládá, že název vašeho nasazení odpovídá názvu modelu. gpt-35-turbo

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

export SPRING_AI_AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export SPRING_AI_AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"
export SPRING_AI_AZURE_OPENAI_MODEL="REPLACE_WITH_YOUR_MODEL_NAME_HERE"

Vytvoření nové aplikace Spring

Vytvořte nový projekt Spring.

V okně Bash vytvořte pro aplikaci nový adresář a přejděte na něj.

mkdir ai-chat-demo && cd ai-chat-demo

spring init Spusťte příkaz z pracovního adresáře. Tento příkaz vytvoří standardní adresářovou strukturu projektu Spring, včetně hlavního zdrojového souboru třídy Java a souboru pom.xml používaného ke správě projektů založených na Mavenu.

spring init -a ai-chat-demo -n AIChat --force --build maven -x

Vygenerované soubory a složky se podobají následující struktuře:

ai-chat-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aichatdemo/
    |                   |-- AiChatApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aichatdemo/
                        |-- AiChatApplicationTests.java

Upravit aplikaci Spring

1. Upravte soubor pom.xml.

   V kořenovém adresáři projektu otevřete soubor pom.xml v preferovaném editoru nebo integrovaném vývojovém prostředí a přepište soubor následujícím obsahem:

   <?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-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</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>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. Ve složce src/main/java/com/example/aichatdemo otevřete AiChatApplication.java v preferovaném editoru nebo integrovaném vývojovém prostředí a vložte následující kód:

   package com.example.aichatdemo;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.ChatMessage;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class AiChatApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiChatApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending chat prompts to AI service. One moment please...\r\n"));
   
           final List<Message> msgs = new ArrayList<>();
   
           msgs.add(new ChatMessage(MessageType.SYSTEM, "You are a helpful assistant"));
           msgs.add(new ChatMessage(MessageType.USER, "Does Azure OpenAI support customer managed keys?"));
           msgs.add(new ChatMessage(MessageType.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           msgs.add(new ChatMessage(MessageType.USER, "Do other Azure AI services support this too?"));
   
           final var resps = aiClient.generate(new Prompt(msgs));
   
           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()));
             });
       }
   
   }
   

   Důležité

   V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace o zabezpečení přihlašovacích údajů najdete v článku zabezpečení služeb Azure AI.

3. Přejděte zpět do kořenové složky projektu a spusťte aplikaci pomocí následujícího příkazu:

   ./mvnw spring-boot:run
   

Výstup

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.5)

2023-11-07T13:31:10.884-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : No active profile set, falling back to 1 default profile: "default"
2023-11-07T13:31:11.595-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : Started AiChatApplication in 0.994 seconds (process running for 1.28)
Sending chat prompts to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Yes, other Azure AI services also support customer managed keys. Azure AI Services, Azure Machine Learning, and other AI services in Azure provide options for customers to manage and control their encryption keys. This allows customers to have greater control over their data and security.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Ukázky balíčku zdrojového kódu | (npm) |

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Verze LTS Node.js
• Azure CLI , které se používá k ověřování bez hesla v místním vývojovém prostředí, vytvořte potřebný kontext přihlášením pomocí Azure CLI.
• Prostředek služby Azure OpenAI s nasazenými gpt-35-turbo gpt-4 modely řady Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření aplikace Node

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

Instalace klientské knihovny

Nainstalujte požadované balíčky pro JavaScript s npm z kontextu nového adresáře:

npm install openai @azure/identity

Soubor package.json vaší aplikace se aktualizuje o závislosti.

Vytvoření ukázkové aplikace

Otevřete příkazový řádek, na kterém chcete nový projekt, a vytvořte nový soubor s názvem ChatCompletion.js. Do souboru ChatCompletion.js zkopírujte následující kód.

const { AzureOpenAI } = require("openai");
const { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.


// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, azureADTokenProvider, deployment });
  const result = await client.chat.completions.create({
    messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
    { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI?" },
    { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  });

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

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

module.exports = { main };

node.exe ChatCompletion.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";
const apiVersion = "2024-05-01-preview";
const deployment = "gpt-4o"; //This must match your deployment name.

async function main() {

  const client = new AzureOpenAI({ endpoint, apiKey, apiVersion, deployment });
  const result = await client.chat.completions.create({
    messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
    { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI?" },
    { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  });

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

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

module.exports = { main };

node.exe ChatCompletion.js

Výstup

== Chat Completions Sample ==
{
  content: 'Yes, several other Azure AI services also support customer managed keys for enhanced security and control over encryption keys.',
  role: 'assistant'
}

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Přehled Azure OpenAI
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Ukázky balíčku zdrojového kódu | (npm) |

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Verze LTS Node.js
• TypeScript
• Azure CLI , které se používá k ověřování bez hesla v místním vývojovém prostředí, vytvořte potřebný kontext přihlášením pomocí Azure CLI.
• Prostředek služby Azure OpenAI s nasazenými gpt-35-turbo gpt-4 modely řady Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření aplikace Node

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

Instalace klientské knihovny

Nainstalujte požadované balíčky pro JavaScript s npm z kontextu nového adresáře:

npm install openai @azure/identity

Soubor package.json vaší aplikace se aktualizuje o závislosti.

Vytvoření ukázkové aplikace

Otevřete příkazový řádek, na kterém chcete nový projekt, a vytvořte nový soubor s názvem ChatCompletion.ts. Do souboru ChatCompletion.ts zkopírujte následující kód.

import { AzureOpenAI } from "openai";
import { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} from "@azure/identity";
import type {
  ChatCompletion,
  ChatCompletionCreateParamsNonStreaming,
} from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      {
        role: "user",
        content: "Does Azure OpenAI support customer managed keys?",
      },
      {
        role: "assistant",
        content: "Yes, customer managed keys are supported by Azure OpenAI?",
      },
      { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

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

tsc

node.exe ChatCompletion.js

import { AzureOpenAI } from "openai";
import type {
  ChatCompletion,
  ChatCompletionCreateParamsNonStreaming,
} from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-4o-mini"; //This must match your deployment name.

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}

function createMessages(): ChatCompletionCreateParamsNonStreaming {
  return {
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      {
        role: "user",
        content: "Does Azure OpenAI support customer managed keys?",
      },
      {
        role: "assistant",
        content: "Yes, customer managed keys are supported by Azure OpenAI?",
      },
      { role: "user", content: "Do other Azure AI services support this too?" },
    ],
    model: "",
  };
}
async function printChoices(completion: ChatCompletion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.message);
  }
}
export async function main() {
  const client = getClient();
  const messages = createMessages();
  const result = await client.chat.completions.create(messages);
  await printChoices(result);
}

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

tsc

node.exe ChatCompletion.js

Výstup

== Chat Completions Sample ==
{
  content: 'Yes, several other Azure AI services also support customer managed keys for enhanced security and control over encryption keys.',
  role: 'assistant'
}

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Přehled Azure OpenAI
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Šablona podnikového chatu načtení rozšířené generace (RAG) knihovny (PyPi) | | |

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Python 3.8 nebo novější verze
• Následující knihovny Pythonu: os.
• Prostředek služby Azure OpenAI s gpt-35-turbo nasazenými modely gpt-4 Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Nainstalujte klientskou knihovnu OpenAI Pythonu pomocí:

pip install openai

pip install openai==0.28.1

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Vytvoření nové aplikace v Pythonu

1. Vytvořte nový soubor Pythonu s názvem quickstart.py. Pak ho otevřete v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

2. Obsah quickstart.py nahraďte následujícím kódem.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

3. Spusťte aplikaci pomocí příkazu v souboru rychlého python startu:

   python quickstart.py
   

Výstup

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.",
        "role": "assistant"
      }
    }
  ],
  "created": 1679001781,
  "id": "chatcmpl-6upLpNYYOx2AhoOYxl9UgJvF4aPpR",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 39,
    "prompt_tokens": 58,
    "total_tokens": 97
  }
}
Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.

Principy struktury zpráv

Modely GPT-35-Turbo a GPT-4 jsou optimalizované pro práci se vstupy formátovanými jako konverzace. Proměnná messages předává pole slovníků s různými rolemi v konverzaci vypisované systémem, uživatelem a asistentem. Systémovou zprávu lze použít k vytvoření modelu zahrnutím kontextu nebo pokynů k tomu, jak by měl model reagovat.

Průvodce postupy GPT-35-Turbo &GPT-4 poskytuje podrobný úvod do možností komunikace s těmito novými modely.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Přečtěte si další informace o tom, jak pracovat s modely GPT-35-Turbo a GPT-4 s naším návodem.
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Specifikace rozhraní REST API |

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Prostředek služby Azure OpenAI s gpt-35-turbo nasazenými modely gpt-4 Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

REST API

V prostředí Bash spusťte následující příkaz. Budete muset nahradit gpt-35-turbo názvem nasazení, který jste zvolili při nasazení modelů GPT-35-Turbo nebo GPT-4. Zadání názvu modelu způsobí chybu, pokud jste vybrali název nasazení, který je shodný s názvem základního modelu.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo/chat/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{"messages":[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},{"role": "user", "content": "Do other Azure AI services support this too?"}]}'

Formát prvního řádku příkazu s ukázkovým koncovým bodem by se zobrazil následovně curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \ : Pokud dojde k chybě dvojité kontroly, abyste se ujistili, že nemáte zdvojnásobení rozdělení / mezi koncovým bodem a /openai/deployments.

Pokud chcete tento příkaz spustit v normálním příkazovém řádku systému Windows, musíte text změnit, aby se odebraly \ konce řádků.

Výstup

{"id":"chatcmpl-6v7mkQj980V1yBec6ETrKPRqFjNw9",
"object":"chat.completion","created":1679072642,
"model":"gpt-35-turbo",
"usage":{"prompt_tokens":58,
"completion_tokens":68,
"total_tokens":126},
"choices":[{"message":{"role":"assistant",
"content":"Yes, other Azure AI services also support customer managed keys. Azure AI services offer multiple options for customers to manage keys, such as using Azure Key Vault, customer-managed keys in Azure Key Vault or customer-managed keys through Azure Storage service. This helps customers ensure that their data is secure and access to their services is controlled."},"finish_reason":"stop","index":0}]}

Formátování výstupu upravené pro snadné čtení, skutečný výstup je jeden blok textu bez konců řádků.

Principy struktury zpráv

Modely GPT-35-Turbo a GPT-4 jsou optimalizované pro práci se vstupy formátovanými jako konverzace. Proměnná messages předává pole slovníků s různými rolemi v konverzaci vypisované systémem, uživatelem a asistentem. Systémovou zprávu lze použít k vytvoření modelu zahrnutím kontextu nebo pokynů k tomu, jak by měl model reagovat.

Průvodce postupy GPT-35-Turbo &GPT-4 poskytuje podrobný úvod do možností komunikace s těmito novými modely.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure CLI

Další kroky

• Přečtěte si další informace o tom, jak pracovat s modely GPT-35-Turbo a GPT-4 s naším návodem.
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Můžete použít nejnovější verzi, PowerShell 7 nebo Windows PowerShell 5.1.
• Prostředek služby Azure OpenAI s nasazeným modelem Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.
• Prostředek služby Azure OpenAI s gpt-35-turbo nasazenými modely gpt-4 Další informace o nasazení modelu najdete v tématu Průvodce nasazením prostředku.

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI budete potřebovat koncový bod a klíč.

Na webu Azure Portal přejděte ke svému prostředku. Koncový bod a klíče najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'
$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment
echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Vytvoření nového skriptu PowerShellu

1. Vytvořte nový soubor PowerShellu s názvem quickstart.ps1. Pak ho otevřete v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

2. Obsah souboru quickstart.ps1 nahraďte následujícím kódem. Proměnnou engine musíte nastavit na název nasazení, který jste zvolili při nasazení modelů GPT-35-Turbo nebo GPT-4. Zadání názvu modelu způsobí chybu, pokud jste vybrali název nasazení, který je shodný s názvem základního modelu.

   # 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 = '2024-02-01' # 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.
   }
   
   # Completion text
   $messages = @()
   $messages += @{
     role = 'system'
     content = 'You are a helpful assistant.'
   }
   $messages += @{
     role = 'user'
     content = 'Does Azure OpenAI support customer managed keys?'
   }
   $messages += @{
     role = 'assistant'
     content = 'Yes, customer managed keys are supported by Azure OpenAI.'
   }
   $messages += @{
     role = 'user'
     content = 'Do other Azure AI services support this too?'
   }
   
   # Header for authentication
   $headers = [ordered]@{
      'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
      messages = $messages
   } | ConvertTo-Json
   
   # Send a request to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/chat/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response
   

   Důležité

   V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je správa tajných kódů PowerShellu pomocí služby Azure Key Vault. Další informace o zabezpečení přihlašovacích údajů najdete v článku zabezpečení služeb Azure AI.

3. Spusťte skript pomocí PowerShellu:

   ./quickstart.ps1
   

Výstup

# the output of the script will be a .NET object containing the response
id      : chatcmpl-7sdJJRC6fDNGnfHMdfHXvPkYFbaVc
object  : chat.completion
created : 1693255177
model   : gpt-35-turbo
choices : {@{index=0; finish_reason=stop; message=}}
usage   : @{completion_tokens=67; prompt_tokens=55; total_tokens=122}

# convert the output to JSON
./quickstart.ps1 | ConvertTo-Json -Depth 3

# or to view the text returned, select the specific object property
$reponse = ./quickstart.ps1
$response.choices.message.content

Principy struktury zpráv

Modely GPT-35-Turbo a GPT-4 jsou optimalizované pro práci se vstupy formátovanými jako konverzace. Proměnná messages předává pole slovníků s různými rolemi v konverzaci vypisované systémem, uživatelem a asistentem. Systémovou zprávu lze použít k vytvoření modelu zahrnutím kontextu nebo pokynů k tomu, jak by měl model reagovat.

Průvodce postupy GPT-35-Turbo &GPT-4 poskytuje podrobný úvod do možností komunikace s těmito novými modely.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

• Azure Portal
• Azure PowerShell

Další kroky

• Přečtěte si další informace o tom, jak pracovat s modely GPT-35-Turbo a GPT-4 s naším návodem.
• Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.