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.

Configuración del entorno local

Algunos de los servicios de IA se pueden hospedar localmente y pueden requerir alguna configuración. A continuación se muestran instrucciones para aquellos que admiten esto.

No hay ninguna configuración local.

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.AzureOpenAI

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.

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.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 crear un servicio de finalización de chat, debe instalar e importar los módulos necesarios y crear una instancia del servicio. A continuación se muestran los pasos para instalar y crear un servicio de finalización de chat para cada proveedor de servicios de IA.

Instalación de los paquetes necesarios

El paquete kernel semántico incluye todos los paquetes necesarios para usar Azure OpenAI. No se requieren paquetes adicionales para usar Azure OpenAI.

Creación de un servicio de finalización de chat

Propina

Hay tres métodos para proporcionar la información necesaria a los servicios de inteligencia artificial. Puede proporcionar la información directamente a través del constructor, establecer las variables de entorno necesarias o crear un archivo .env en el directorio del proyecto que contenga las variables de entorno. Puede visitar esta página para buscar todas las variables de entorno necesarias para cada proveedor de servicios 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:

El servicio AzureChatCompletion también admite autenticación de Microsoft Entra. Si no proporciona una clave de API, el servicio intentará autenticarse mediante el token entra.

Puede empezar a usar el servicio de finalización inmediatamente o agregar el servicio de finalización de chat a un kernel. Puede usar el código siguiente para agregar un servicio al 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)

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

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

Propina

No es necesario agregar el servicio de finalización de chat al kernel si no es necesario usar otros servicios en el kernel. Puedes usar el servicio de finalización de chat directamente en tu código.

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 transmisión: Esperas 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.

Antes de empezar, deberá crear manualmente una instancia de configuración de ejecución para usar el servicio de finalización de chat si no registró el servicio con el kernel.

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

execution_settings = OpenAIChatPromptExecutionSettings()

Propina

Para ver lo que puede configurar en las opciones de ejecución, puede comprobar la definición de clase en el código fuente de o consultar la documentación de la API de .

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,
    settings=execution_settings,
)

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,
    settings=execution_settings,
)

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

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:

Uso del objeto de historial de chat

Optimización de llamadas de funciones con finalización de chat