Compartir a través de

Finalización del chat

  • Artículo

Con la finalización del chat, puede simular una conversación de ida y vuelta con un agente de IA. Esto es, por supuesto, útil para crear bots de chat, pero también se puede usar para crear agentes autónomos que puedan completar procesos empresariales, generar código, etc. Como el tipo de modelo principal proporcionado por OpenAI, Google, Mistral, Facebook y otros, la finalización del chat es el servicio de inteligencia artificial más común que agregará al proyecto de kernel semántico.

Al seleccionar un modelo de finalización de chat, deberá tener en cuenta lo siguiente:

  • ¿Qué modalidades admite el modelo (por ejemplo, texto, imagen, audio, etc.)?
  • ¿Admite llamadas a funciones?
  • ¿Qué tan rápido recibe y genera tokens?
  • ¿Cuánto cuesta cada token?

Importante

De todas las preguntas anteriores, lo más importante es si el modelo admite llamadas a funciones. Si no es así, no podrá usar el modelo para llamar al código existente. La mayoría de los modelos más recientes de OpenAI, Google, Mistral y Amazon admiten llamadas a funciones. Sin embargo, la compatibilidad con modelos de lenguaje pequeños sigue siendo limitada.

Instalación de los paquetes necesarios

Antes de agregar la finalización del chat al kernel, deberá instalar los paquetes necesarios. A continuación se muestran los paquetes que deberá instalar para cada proveedor de servicios de IA.

dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI

Creación de servicios de finalización de chat

Ahora que ha instalado los paquetes necesarios, puede crear servicios de finalización de chat. A continuación se muestran las varias maneras de crear servicios de finalización de chat mediante kernel semántico.

Agregar directamente al kernel

Para agregar un servicio de finalización de chat, puede usar el código siguiente para agregarlo al proveedor de servicios interno del kernel.

dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI

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

Uso de la inserción de dependencias

Si usa la inserción de dependencias, es probable que quiera agregar los servicios de IA directamente al proveedor de servicios. Esto resulta útil si desea crear singletons de los servicios de IA y reutilizarlos en kernels transitorios.

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

Creación de instancias independientes

Por último, puede crear instancias del servicio directamente para poder agregarlas a un kernel más adelante o usarlas directamente en el código sin insertarlas nunca en el kernel o en un proveedor de servicios.

using Microsoft.SemanticKernel.Connectors.OpenAI;

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 agregar un servicio de finalización de chat, puede usar el código siguiente para agregarlo al kernel.

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

# Initialize the kernel
kernel = Kernel()

# Add the Azure OpenAI chat completion service
kernel.add_service(AzureChatCompletion(
    deployment_name="my-deployment",
    api_key="my-api-key",
    base_url="https://my-deployment.azurewebsites.net", # Used to point to your service
    service_id="my-service-id", # Optional; for targeting specific services within Semantic Kernel
))

También puede crear instancias del servicio directamente para poder agregarlas a un kernel más adelante o usarlas directamente en el código sin insertarlas en el kernel.

from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

chat_completion_service = AzureChatCompletion(
    deployment_name="my-deployment",
    api_key="my-api-key",
    base_url="https://my-deployment.azurewebsites.net", # Used to point to your service
    service_id="my-service-id", # Optional; for targeting specific services within Semantic Kernel
)

Puede crear instancias del servicio de finalización de chat directamente y agregarlas a un kernel o usarlas directamente en el código sin insertarlas en el kernel. En el código siguiente se muestra cómo crear un servicio de finalización de chat y agregarlo al 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();

Recuperación de servicios de finalización de chat

Una vez que haya agregado servicios de finalización de chat al kernel, puede recuperarlos mediante el método get service. A continuación se muestra un ejemplo de cómo recuperar un servicio de finalización de chat del kernel.

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

from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase

chat_completion_service = kernel.get_service(type=ChatCompletionClientBase)

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

Uso de servicios de finalización de chat

Ahora que tiene un servicio de finalización de chat, puede usarlo para generar respuestas de un agente de IA. Hay dos maneras principales de usar un servicio de finalización de chat:

  • No streaming: espera a que el servicio genere una respuesta completa antes de devolverla al usuario.
  • Streaming: se generan fragmentos individuales de la respuesta y se devuelven al usuario a medida que se crean.

A continuación se muestran las dos maneras de usar un servicio de finalización de chat para generar respuestas.

Finalización de chat sin streaming

Para usar la finalización del chat sin streaming, puede usar el código siguiente para generar una respuesta del 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,
    kernel=kernel,
)

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

InvocationContext optionalInvocationContext = null;

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

Finalización del chat en streaming

Para usar la finalización del chat en streaming, puede usar el código siguiente para generar una respuesta del 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,
    kernel=kernel,
)

async for chunk in response:
    print(chunk)

Nota:

El kernel semántico para Java no admite el modelo de respuesta de streaming.

Pasos siguientes

Ahora que ha agregado servicios de finalización de chat al proyecto de kernel semántico, puede empezar a crear conversaciones con el agente de IA. Para más información sobre el uso de un servicio de finalización de chat, consulte los artículos siguientes: