Partilhar via

Conclusão do chat

  • Artigo

Com a conclusão do bate-papo, você pode simular uma conversa de ida e volta com um agente de IA. É claro que isso é útil para criar bots de chat, 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 tipo de modelo primário fornecido pelo OpenAI, Google, Mistral, Facebook e outros, a conclusão de bate-papo é o serviço de IA mais comum que você adicionará ao seu projeto de Kernel Semântico.

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

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

Importante

De todas as perguntas acima, a mais importante é se o modelo suporta chamada de função. Se isso não acontecer, você não poderá usar o modelo para chamar seu código existente. A maioria dos modelos mais recentes da OpenAI, Google, Mistral e Amazon suportam chamadas de função. O suporte de modelos de linguagem pequenos, 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 instruções para aqueles que apoiam isso.

Nenhuma configuração local.

Instalando os pacotes necessários

Antes de adicionar a conclusão 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

Criando serviços de conclusão de bate-papo

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

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

Usando injeção de dependência

Se você estiver usando 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);
});

Criação de instâncias autônomas

Por fim, você pode criar instâncias do serviço diretamente para que você possa adicioná-las a um kernel mais tarde 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 bate-papo para cada provedor de serviços de IA.

Dica

Existem três métodos para fornecer as informações necessárias aos serviços de IA. Você pode fornecer as informações diretamente através do construtor, definir as variáveis de ambiente necessárias ou criar um arquivo .env dentro do diretório do projeto contendo 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")

Nota

O serviço AzureChatCompletion também suporta 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 pode 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 bate-papo

Depois de adicionar serviços de conclusão de chat ao seu 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 bate-papo 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

Adicionar o serviço de conclusão de chat ao kernel não é necessário se você não precisar usar outros serviços no kernel. Você pode usar o serviço de conclusão de bate-papo diretamente em seu código.

Usando serviços de conclusão de bate-papo

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

  • não streaming: você espera que o serviço gere uma resposta inteira antes de devolvê-la ao usuário.
  • Streaming: Fragmentos individuais da resposta são gerados e devolvidos ao utilizador à medida que são criados.

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 bate-papo 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 podes configurar nas definições de execução, podes verificar a definição de classe no código-fonte ou consultar 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 streaming

Para usar a conclusão de bate-papo 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 de streaming

Para usar a conclusão do bate-papo 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="")

Nota

O Semantic Kernel for Java não suporta o modelo de resposta de streaming.

Próximos passos

Agora que você adicionou serviços de conclusão de bate-papo ao seu projeto de Kernel Semântico, você 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:

Usando o objeto de histórico de bate-papo

Otimizando a chamada de função com a conclusão do bate-papo