Partager via

Saisie semi-automatique de la conversation

  • Article

Une fois la conversation terminée, vous pouvez simuler une conversation back-and-forth avec un agent IA. Cela est bien sûr utile pour créer des bots de conversation, mais il peut également être utilisé pour créer des agents autonomes qui peuvent terminer des processus métier, générer du code et bien plus encore. Comme type de modèle principal fourni par OpenAI, Google, Mistral, Facebook et d’autres, la saisie semi-automatique de conversation est le service IA le plus courant que vous allez ajouter à votre projet de noyau sémantique.

Lors de la sélection d’un modèle d’achèvement de conversation, vous devez prendre en compte les éléments suivants :

  • Quelles sont les modalités prises en charge par le modèle (par exemple, texte, image, audio, etc.) ?
  • Prend-il en charge l’appel de fonction ?
  • Combien de temps reçoit-il et génère-t-il des jetons ?
  • Combien coûte chaque jeton ?

Important

Parmi toutes les questions ci-dessus, le plus important est de savoir si le modèle prend en charge l’appel de fonction. Si ce n’est pas le cas, vous ne pourrez pas utiliser le modèle pour appeler votre code existant. La plupart des derniers modèles d’OpenAI, Google, Mistral et Amazon prennent tous en charge les appels de fonction. Toutefois, la prise en charge des modèles de petite langue est encore limitée.

Configuration de votre environnement local

Certains des services IA peuvent être hébergés localement et peuvent nécessiter une configuration. Vous trouverez ci-dessous des instructions pour ceux qui soutiennent cela.

Aucune configuration locale.

Installation des packages nécessaires

Avant d’ajouter la saisie semi-automatique de conversation à votre noyau, vous devez installer les packages nécessaires. Voici les packages que vous devez installer pour chaque fournisseur de services IA.

dotnet add package Microsoft.SemanticKernel.Connectors.AzureOpenAI

Création de services d’achèvement de conversation

Maintenant que vous avez installé les packages nécessaires, vous pouvez créer des services d’achèvement de conversation. Vous trouverez ci-dessous plusieurs façons de créer des services d’achèvement de conversation à l’aide du noyau sémantique.

Ajout direct au noyau

Pour ajouter un service d’achèvement de conversation, vous pouvez utiliser le code suivant pour l’ajouter au fournisseur de services interne du noyau.

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

Utilisation de l’injection de dépendances

Si vous utilisez l’injection de dépendances, vous souhaiterez probablement ajouter vos services IA directement au fournisseur de services. Cela est utile si vous souhaitez créer des singletons de vos services IA et les réutiliser dans des noyaux temporaires.

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

Création d’instances autonomes

Enfin, vous pouvez créer des instances du service directement afin de pouvoir les ajouter à un noyau ultérieurement ou les utiliser directement dans votre code sans jamais les injecter dans le noyau ou dans un fournisseur de services.

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

Pour créer un service d’achèvement de conversation, vous devez importer les modules nécessaires et créer une instance du service. Vous trouverez ci-dessous les étapes à suivre pour créer un service d’achèvement de conversation pour chaque fournisseur de services IA.

Pourboire

Il existe trois méthodes pour fournir les informations requises aux services IA. Vous pouvez fournir les informations directement via le constructeur, définir les variables d’environnement nécessaires ou créer un fichier .env dans votre répertoire de projet contenant les variables d’environnement. Vous pouvez visiter cette page pour rechercher toutes les variables d’environnement requises pour chaque fournisseur de services 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")

Remarque

Le service AzureChatCompletion prend également en charge l'authentification Microsoft Entra. Si vous ne fournissez pas de clé API, le service tente de s’authentifier à l’aide du jeton Entra.

Vous pouvez commencer à utiliser le service d’achèvement immédiatement ou ajouter le service d’achèvement de conversation à un noyau. Vous pouvez utiliser le code suivant pour ajouter un service au noyau.

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)

Vous pouvez créer des instances du service d’achèvement de conversation directement et les ajouter à un noyau ou les utiliser directement dans votre code sans les injecter dans le noyau. Le code suivant montre comment créer un service d’achèvement de conversation et l’ajouter au noyau.

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

Récupération des services d’achèvement de conversation

Une fois que vous avez ajouté des services d’achèvement de conversation à votre noyau, vous pouvez les récupérer à l’aide de la méthode get service. Voici un exemple de la façon dont vous pouvez récupérer un service d’achèvement de conversation à partir du noyau.

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

Pourboire

L’ajout du service d’achèvement de conversation au noyau n’est pas nécessaire si vous n’avez pas besoin d’utiliser d’autres services dans le noyau. Vous pouvez utiliser le service de complétion de chat directement dans votre code.

Utilisation des services d’achèvement de conversation

Maintenant que vous disposez d’un service d’achèvement de conversation, vous pouvez l’utiliser pour générer des réponses à partir d’un agent IA. Il existe deux façons principales d’utiliser un service d’achèvement de conversation :

  • de non-diffusion en continu : vous attendez que le service génère une réponse entière avant de le renvoyer à l’utilisateur.
  • streaming: les blocs individuels de la réponse sont générés et retournés à l’utilisateur lors de leur création.

Avant de commencer, vous devez créer manuellement une instance de paramètres d’exécution pour utiliser le service d’achèvement de conversation si vous n’avez pas inscrit le service auprès du noyau.

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

execution_settings = OpenAIChatPromptExecutionSettings()

Pourboire

Pour voir ce que vous pouvez configurer dans les paramètres d’exécution, vous pouvez vérifier la définition de classe dans le code source ou consulter la documentation de l’API .

Vous trouverez ci-dessous les deux façons d’utiliser un service d’achèvement de conversation pour générer des réponses.

Fin de la conversation sans diffusion en continu

Pour utiliser la saisie semi-automatique de conversation en continu, vous pouvez utiliser le code suivant pour générer une réponse à partir de l’agent 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
);

Fin de la conversation en streaming

Pour utiliser la saisie semi-automatique de conversation en streaming, vous pouvez utiliser le code suivant pour générer une réponse à partir de l’agent 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="")

Remarque

Le noyau sémantique pour Java ne prend pas en charge le modèle de réponse de streaming.

Étapes suivantes

Maintenant que vous avez ajouté des services d’achèvement de conversation à votre projet de noyau sémantique, vous pouvez commencer à créer des conversations avec votre agent IA. Pour en savoir plus sur l’utilisation d’un service d’achèvement de conversation, consultez les articles suivants :

Utilisation de l’objet d’historique de conversation

Optimisation de l’appel de fonction avec la saisie semi-automatique de conversation