Dela via

Chatten har slutförts

  • Artikel

När chatten är klar kan du simulera en konversation fram och tillbaka med en AI-agent. Detta är naturligtvis användbart för att skapa chattrobotar, men det kan också användas för att skapa autonoma agenter som kan slutföra affärsprocesser, generera kod med mera. Som den primära modelltypen som tillhandahålls av OpenAI, Google, Mistral, Facebook och andra är chattavslut den vanligaste AI-tjänsten som du lägger till i ditt Semantic Kernel-projekt.

När du väljer en modell för chattens slutförande måste du överväga följande:

  • Vilka metoder stöder modellen (t.ex. text, bild, ljud osv.)?
  • Stöder den funktionsanrop?
  • Hur snabbt tar den emot och genererar token?
  • Hur mycket kostar varje token?

Viktigt!

Av alla ovanstående frågor är det viktigaste om modellen stöder funktionsanrop. Om den inte gör det kan du inte använda modellen för att anropa din befintliga kod. De flesta av de senaste modellerna från OpenAI, Google, Mistral och Amazon stöder alla funktionssamtal. Stödet från små språkmodeller är dock fortfarande begränsat.

Konfigurera din lokala miljö

Vissa av AI-tjänsterna kan finnas lokalt och kan kräva viss inställning. Nedan visas instruktioner för dem som stöder detta.

Ingen lokal installation.

Installera nödvändiga paket

Innan du lägger till chatten i kerneln måste du installera nödvändiga paket. Nedan visas de paket som du behöver installera för varje AI-tjänstleverantör.

dotnet add package Microsoft.SemanticKernel.Connectors.AzureOpenAI

Skapa tjänster för chattens slutförande

Nu när du har installerat de nödvändiga paketen kan du skapa tjänster för chattens slutförande. Nedan visas flera sätt att skapa tjänster för chattens slutförande med hjälp av semantisk kernel.

Lägga till direkt i kerneln

Om du vill lägga till en tjänst för chattens slutförande kan du använda följande kod för att lägga till den i kernelns inre tjänstleverantör.

using Microsoft.SemanticKernel;

IKernelBuilder kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT",
    modelId: "gpt-4", // Optional name of the underlying model if the deployment name doesn't match the model name
    serviceId: "YOUR_SERVICE_ID", // Optional; for targeting specific services within Semantic Kernel
    httpClient: new HttpClient() // Optional; if not provided, the HttpClient from the kernel will be used
);
Kernel kernel = kernelBuilder.Build();

Använda beroendeinmatning

Om du använder beroendeinmatning vill du förmodligen lägga till dina AI-tjänster direkt till tjänstleverantören. Det här är användbart om du vill skapa singletons av dina AI-tjänster och återanvända dem i tillfälliga kärnor.

using Microsoft.SemanticKernel;

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT",
    modelId: "gpt-4", // Optional name of the underlying model if the deployment name doesn't match the model name
    serviceId: "YOUR_SERVICE_ID" // Optional; for targeting specific services within Semantic Kernel
);

builder.Services.AddTransient((serviceProvider)=> {
    return new Kernel(serviceProvider);
});

Skapa fristående instanser

Slutligen kan du skapa instanser av tjänsten direkt så att du antingen kan lägga till dem i en kernel senare eller använda dem direkt i koden utan att någonsin mata in dem i kerneln eller i en tjänstleverantör.

using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

AzureOpenAIChatCompletionService chatCompletionService = new (
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT",
    modelId: "gpt-4", // Optional name of the underlying model if the deployment name doesn't match the model name
    httpClient: new HttpClient() // Optional; if not provided, the HttpClient from the kernel will be used
);

För att skapa en tjänst för chattens slutförande måste du installera och importera nödvändiga moduler och skapa en instans av tjänsten. Nedan följer stegen för att installera och skapa en chatttjänst för varje AI-tjänstleverantör.

Installera nödvändiga paket

Semantic Kernel-paketet levereras med alla nödvändiga paket för att använda Azure OpenAI. Det finns inga ytterligare paket som krävs för att använda Azure OpenAI.

Skapa en tjänst för chattens slutförande

Tips

Det finns tre metoder för att tillhandahålla nödvändig information till AI-tjänster. Du kan antingen ange informationen direkt via konstruktorn, ange nödvändiga miljövariabler eller skapa en .env-fil i projektkatalogen som innehåller miljövariablerna. Du kan besöka den här sidan för att hitta alla nödvändiga miljövariabler för varje AI-tjänstleverantör: https://github.com/microsoft/semantic-kernel/blob/main/python/samples/concepts/setup/ALL_SETTINGS.md

from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

chat_completion_service = AzureChatCompletion(
    deployment_name="my-deployment",  
    api_key="my-api-key",
    endpoint="my-api-endpoint", # Used to point to your service
    service_id="my-service-id", # Optional; for targeting specific services within Semantic Kernel
)

# You can do the following if you have set the necessary environment variables or created a .env file
chat_completion_service = AzureChatCompletion(service_id="my-service-id")

Kommentar

Tjänsten AzureChatCompletion stöder även Microsoft Entra-autentisering. Om du inte anger någon API-nyckel försöker tjänsten autentisera med hjälp av Entra-token.

Du kan börja använda slutförandetjänsten direkt eller lägga till tjänsten för chattens slutförande i en kernel. Du kan använda följande kod för att lägga till en tjänst i kerneln.

from semantic_kernel import Kernel

# Initialize the kernel
kernel = Kernel()

# Add the chat completion service created above to the kernel
kernel.add_service(chat_completion_service)

Du kan skapa instanser av tjänsten för chattens slutförande direkt och antingen lägga till dem i en kernel eller använda dem direkt i koden utan att mata in dem i kerneln. Följande kod visar hur du skapar en tjänst för chattens slutförande och lägger till den i kerneln.

import com.azure.ai.openai.OpenAIAsyncClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.microsoft.semantickernel.Kernel;
import com.microsoft.semantickernel.services.chatcompletion.ChatCompletionService;

// Create the client
OpenAIAsyncClient client = new OpenAIClientBuilder()
    .credential(azureOpenAIClientCredentials)
    .endpoint(azureOpenAIClientEndpoint)
    .buildAsyncClient();

// Create the chat completion service
ChatCompletionService openAIChatCompletion = OpenAIChatCompletion.builder()
    .withOpenAIAsyncClient(client)
    .withModelId(modelId)
    .build();

// Initialize the kernel
Kernel kernel = Kernel.builder()
    .withAIService(ChatCompletionService.class, openAIChatCompletion)
    .build();

Hämtar tjänster för chattens slutförande

När du har lagt till tjänster för chattavslut i kerneln kan du hämta dem med hjälp av metoden hämta tjänst. Nedan visas ett exempel på hur du kan hämta en tjänst för chattens slutförande från kerneln.

var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();

from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase

# Retrieve the chat completion service by type
chat_completion_service = kernel.get_service(type=ChatCompletionClientBase)

# Retrieve the chat completion service by id
chat_completion_service = kernel.get_service(service_id="my-service-id")

# Retrieve the default inference settings
execution_settings = kernel.get_prompt_execution_settings_from_service_id("my-service-id")

ChatCompletionService chatCompletionService = kernel.getService(ChatCompletionService.class);

Tips

Det krävs inte att du lägger till tjänsten för chattens slutförande i kerneln om du inte behöver använda andra tjänster i kerneln. Du kan använda tjänsten för chattens slutförande direkt i koden.

Använda tjänster för chattens slutförande

Nu när du har en chatttjänst kan du använda den för att generera svar från en AI-agent. Det finns två huvudsakliga sätt att använda en tjänst för chattens slutförande:

  • Icke-strömmande: Du väntar tills tjänsten genererar ett helt svar innan du returnerar det till användaren.
  • Streaming: Enskilda delar av svaret genereras och returneras till användaren när de skapas.

Innan du kommer igång måste du manuellt skapa en instans av körningsinställningar för att använda tjänsten för chattens slutförande om du inte registrerade tjänsten med kerneln.

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

execution_settings = OpenAIChatPromptExecutionSettings()

Tips

Om du vill se vad du kan konfigurera i körningsinställningarna kan du kontrollera klassdefinitionen i källkoden eller läsa API-dokumentationen.

Nedan visas de två sätt som du kan använda en tjänst för chattens slutförande för att generera svar.

Icke-direktuppspelad chatt har slutförts

Om du vill använda icke-direktuppspelad chatt kan du använda följande kod för att generera ett svar från AI-agenten.

ChatHistory history = [];
history.AddUserMessage("Hello, how are you?");

var response = await chatCompletionService.GetChatMessageContentAsync(
    history,
    kernel: kernel
);

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = await chat_completion.get_chat_message_content(
    chat_history=history,
    settings=execution_settings,
)

ChatHistory history = new ChatHistory();
history.addUserMessage("Hello, how are you?");

InvocationContext optionalInvocationContext = null;

List<ChatMessageContent<?>> response = chatCompletionService.getChatMessageContentsAsync(
    history,
    kernel,
    optionalInvocationContext
);

Slutförande av direktuppspelningschatt

Om du vill använda slutförande av direktuppspelningschatt kan du använda följande kod för att generera ett svar från AI-agenten.

ChatHistory history = [];
history.AddUserMessage("Hello, how are you?");

var response = chatCompletionService.GetStreamingChatMessageContentsAsync(
    chatHistory: history,
    kernel: kernel
);

await foreach (var chunk in response)
{
    Console.Write(chunk);
}

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = chat_completion.get_streaming_chat_message_content(
    chat_history=history,
    settings=execution_settings,
)

async for chunk in response:
    print(chunk, end="")

Kommentar

Semantisk kernel för Java stöder inte strömningssvarsmodellen.

Nästa steg

Nu när du har lagt till tjänster för att slutföra chattar i ditt Semantic Kernel-projekt kan du börja skapa konversationer med din AI-agent. Mer information om hur du använder en tjänst för att slutföra chatten finns i följande artiklar:

Använda chatthistorikobjektet

Optimera funktionssamtal med chatten klar