Compartilhar via

Conclusão do chat

  • Artigo

Com a conclusão do chat, você pode simular uma conversa de ida e volta com um agente de IA. É claro que isso é útil para criar bots de bate-papo, mas também pode ser usado para criar agentes autônomos que podem concluir processos de negócios, gerar código e muito mais. Como o principal tipo de modelo fornecido pela OpenAI, Google, Mistral, Facebook e outros, a conclusão do bate-papo é o serviço de IA mais comum que você adicionará ao seu projeto do Semantic Kernel.

Ao escolher um modelo de conclusão de chat, você precisará considerar o seguinte:

  • Quais modalidades o modelo suporta (por exemplo, texto, imagem, áudio, etc.)?
  • Ele suporta chamada de função?
  • Com que rapidez ele recebe e gera tokens?
  • Quanto custa cada token?

Importante

De todas as perguntas acima, a mais importante é se o modelo dá suporte à chamada de função. Caso contrário, você não poderá usar o modelo para chamar o código existente. A maioria dos modelos mais recentes da OpenAI, Google, Mistral e Amazon suporta chamadas de função. O suporte de pequenos modelos de linguagem, no entanto, ainda é limitado.

Configurando seu ambiente local

Alguns dos Serviços de IA podem ser hospedados localmente e podem exigir alguma configuração. Abaixo estão as instruções para aqueles que dão suporte a isso.

Nenhuma configuração local necessária.

Instalando os pacotes necessários

Antes de adicionar o preenchimento do chat ao seu kernel, você precisará instalar os pacotes necessários. Abaixo estão os pacotes que você precisará instalar para cada provedor de serviços de IA.

dotnet add package Microsoft.SemanticKernel.Connectors.AzureOpenAI

Criação de serviços de conclusão de chat

Agora que você instalou os pacotes necessários, pode criar serviços de conclusão de bate-papo. Abaixo estão as várias maneiras de criar serviços de conclusão de bate-papo usando o Semantic Kernel.

Adicionando diretamente ao kernel

Para adicionar um serviço de conclusão de chat, você pode usar o código a seguir para adicioná-lo ao provedor de serviços interno do kernel.

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

Como usar a injeção de dependência

Se você estiver usando a injeção de dependência, provavelmente desejará adicionar seus serviços de IA diretamente ao provedor de serviços. Isso é útil se você quiser criar singletons de seus serviços de IA e reutilizá-los em kernels transitórios.

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

Criando instâncias independentes

Por fim, você pode criar instâncias do serviço diretamente para que possa adicioná-las a um kernel posteriormente ou usá-las diretamente em seu código sem nunca injetá-las no kernel ou em um provedor de serviços.

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

Para criar um serviço de conclusão de chat, você precisa importar os módulos necessários e criar uma instância do serviço. Abaixo estão as etapas para criar um serviço de conclusão de chat para cada provedor de serviços de IA.

Dica

Há três métodos para fornecer as informações necessárias aos serviços de IA. Você pode fornecer as informações diretamente por meio do construtor, definir as variáveis de ambiente necessárias ou criar um arquivo .env no diretório do projeto que contém as variáveis de ambiente. Você pode visitar esta página para encontrar todas as variáveis de ambiente necessárias para cada provedor de serviços de IA: 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")

Observação

O serviço AzureChatCompletion também dá suporte à autenticação Microsoft Entra. Se você não fornecer uma chave de API, o serviço tentará autenticar usando o token Entra.

Você pode começar a usar o serviço de conclusão imediatamente ou adicionar o serviço de conclusão de chat a um kernel. Você pode usar o código a seguir para adicionar um serviço ao kernel.

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)

Você pode criar instâncias do serviço de conclusão de chat diretamente e adicioná-las a um kernel ou usá-las diretamente em seu código sem injetá-las no kernel. O código a seguir mostra como criar um serviço de conclusão de chat e adicioná-lo ao kernel.

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

Recuperando serviços de conclusão de chat

Depois de adicionar serviços de conclusão de chat ao kernel, você pode recuperá-los usando o método get service. Abaixo está um exemplo de como você pode recuperar um serviço de conclusão de chat do kernel.

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

Dica

A adição do serviço de conclusão de chat ao kernel não será necessária se você não precisar usar outros serviços no kernel. Você pode usar o serviço de conclusão de chat diretamente em seu código.

Uso de serviços de conclusão de chat

Agora que você tem um serviço de conclusão de chat, pode usá-lo para gerar respostas de um agente de IA. Existem duas maneiras principais de usar um serviço de conclusão de bate-papo:

  • sem streaming: aguarde até que o serviço gere uma resposta inteira antes de devolvê-la ao usuário.
  • Streaming: partes individuais da resposta são geradas e retornadas ao usuário à medida que são criadas.

Antes de começar, você precisará criar manualmente uma instância de configurações de execução para usar o serviço de conclusão de chat se não tiver registrado o serviço com o kernel.

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

execution_settings = OpenAIChatPromptExecutionSettings()

Dica

Para ver o que você pode configurar nas configurações de execução, verifique a definição de classe no código-fonte ou confira a documentação da API.

Abaixo estão as duas maneiras de usar um serviço de conclusão de bate-papo para gerar respostas.

Conclusão de bate-papo sem transmissão

Para usar a conclusão de chat sem streaming, você pode usar o código a seguir para gerar uma resposta do agente de IA.

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

Conclusão do bate-papo por streaming

Para usar a conclusão do chat de streaming, você pode usar o código a seguir para gerar uma resposta do agente de IA.

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="")

Observação

O Semantic Kernel for Java não dá suporte ao modelo de resposta de streaming.

Próximas etapas

Agora que você adicionou serviços de conclusão de chat ao seu projeto do Semantic Kernel, pode começar a criar conversas com seu agente de IA. Para saber mais sobre como usar um serviço de conclusão de chat, confira os seguintes artigos:

Uso do objeto de histórico de bate-papo

Otimizando a chamada de função com a conclusão do chat