Partager via

Modes d’appel de fonction

  • Article

Lorsque le modèle IA reçoit une invite contenant une liste de fonctions, il peut choisir un ou plusieurs d’entre eux pour l’appel pour terminer l’invite. Lorsqu’une fonction est choisie par le modèle, elle doit être appelée par le noyau sémantique.

Le sous-système d’appel de fonction dans le noyau sémantique a deux modes d’appel de fonction : automatique et manuel.

Selon le mode d’appel, le noyau sémantique effectue un appel de fonction de bout en bout ou donne le contrôle de l’appelant sur le processus d’appel de fonction.

Appel de fonction automatique

L’appel de fonction automatique est le mode par défaut du sous-système d’appel de fonction du noyau sémantique. Lorsque le modèle IA choisit une ou plusieurs fonctions, le noyau sémantique appelle automatiquement les fonctions choisies. Les résultats de ces appels de fonction sont ajoutés à l’historique des conversations et envoyés automatiquement au modèle dans les requêtes suivantes. Le modèle entraîne ensuite des raisons sur l’historique des conversations, choisit des fonctions supplémentaires si nécessaire ou génère la réponse finale. Cette approche est entièrement automatisée et ne nécessite aucune intervention manuelle de l’appelant.

Cet exemple montre comment utiliser l’appel de fonction automatique dans le noyau sémantique. Le modèle IA décide quelles fonctions appeler pour terminer l’invite et le noyau sémantique effectue le reste et les appelle automatiquement.

using Microsoft.SemanticKernel;

IKernelBuilder builder = Kernel.CreateBuilder(); 
builder.AddOpenAIChatCompletion("<model-id>", "<api-key>");
builder.Plugins.AddFromType<WeatherForecastUtils>();
builder.Plugins.AddFromType<DateTimeUtils>(); 

Kernel kernel = builder.Build();

// By default, functions are set to be automatically invoked.  
// If you want to explicitly enable this behavior, you can do so with the following code:  
// PromptExecutionSettings settings = new() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(autoInvoke: true) };  
PromptExecutionSettings settings = new() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }; 

await kernel.InvokePromptAsync("Given the current time of day and weather, what is the likely color of the sky in Boston?", new(settings));

Certains modèles IA prennent en charge l’appel de fonction parallèle, où le modèle choisit plusieurs fonctions pour l’appel. Cela peut être utile dans les cas où l’appel des fonctions choisies prend beaucoup de temps. Par exemple, l’IA peut choisir de récupérer les dernières actualités et l’heure actuelle simultanément, plutôt que d’effectuer un aller-retour par fonction.

Le noyau sémantique peut appeler ces fonctions de deux façons différentes :

  • Séquentiellement : les fonctions sont appelées l’une après l’autre. C’est le paramétrage par défaut.
  • Simultanément : les fonctions sont appelées en même temps. Cela peut être activé en définissant la FunctionChoiceBehaviorOptions.AllowConcurrentInvocation propriété truesur , comme illustré dans l’exemple ci-dessous.
using Microsoft.SemanticKernel;

IKernelBuilder builder = Kernel.CreateBuilder(); 
builder.AddOpenAIChatCompletion("<model-id>", "<api-key>");
builder.Plugins.AddFromType<NewsUtils>();
builder.Plugins.AddFromType<DateTimeUtils>(); 

Kernel kernel = builder.Build();

// Enable concurrent invocation of functions to get the latest news and the current time.
FunctionChoiceBehaviorOptions options = new() { AllowConcurrentInvocation = true };

PromptExecutionSettings settings = new() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(options: options) }; 

await kernel.InvokePromptAsync("Good morning! What is the current time and latest news headlines?", new(settings));

Appel de fonction manuelle

Dans les cas où l’appelant souhaite avoir plus de contrôle sur le processus d’appel de fonction, l’appel de fonction manuel peut être utilisé.

Lorsque l’appel de fonction manuelle est activé, le noyau sémantique n’appelle pas automatiquement les fonctions choisies par le modèle IA. Au lieu de cela, elle retourne une liste de fonctions choisies à l’appelant, qui peut ensuite décider des fonctions à appeler, les appeler séquentiellement ou en parallèle, gérer les exceptions, et ainsi de suite. Les résultats de l’appel de fonction doivent être ajoutés à l’historique des conversations et retournés au modèle, qui les expliquent et déterminent s’il faut choisir des fonctions supplémentaires ou générer la réponse finale.

L’exemple ci-dessous montre comment utiliser l’appel de fonction manuelle.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;

IKernelBuilder builder = Kernel.CreateBuilder(); 
builder.AddOpenAIChatCompletion("<model-id>", "<api-key>");
builder.Plugins.AddFromType<WeatherForecastUtils>();
builder.Plugins.AddFromType<DateTimeUtils>(); 

Kernel kernel = builder.Build();

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

// Manual function invocation needs to be enabled explicitly by setting autoInvoke to false.
PromptExecutionSettings settings = new() { FunctionChoiceBehavior = Microsoft.SemanticKernel.FunctionChoiceBehavior.Auto(autoInvoke: false) };

ChatHistory chatHistory = [];
chatHistory.AddUserMessage("Given the current time of day and weather, what is the likely color of the sky in Boston?");

while (true)
{
    ChatMessageContent result = await chatCompletionService.GetChatMessageContentAsync(chatHistory, settings, kernel);

    // Check if the AI model has generated a response.
    if (result.Content is not null)
    {
        Console.Write(result.Content);
        // Sample output: "Considering the current weather conditions in Boston with a tornado watch in effect resulting in potential severe thunderstorms,
        // the sky color is likely unusual such as green, yellow, or dark gray. Please stay safe and follow instructions from local authorities."
        break;
    }

    // Adding AI model response containing chosen functions to chat history as it's required by the models to preserve the context.
    chatHistory.Add(result); 

    // Check if the AI model has chosen any function for invocation.
    IEnumerable<FunctionCallContent> functionCalls = FunctionCallContent.GetFunctionCalls(result);
    if (!functionCalls.Any())
    {
        break;
    }

    // Sequentially iterating over each chosen function, invoke it, and add the result to the chat history.
    foreach (FunctionCallContent functionCall in functionCalls)
    {
        try
        {
            // Invoking the function
            FunctionResultContent resultContent = await functionCall.InvokeAsync(kernel);

            // Adding the function result to the chat history
            chatHistory.Add(resultContent.ToChatMessage());
        }
        catch (Exception ex)
        {
            // Adding function exception to the chat history.
            chatHistory.Add(new FunctionResultContent(functionCall, ex).ToChatMessage());
            // or
            //chatHistory.Add(new FunctionResultContent(functionCall, "Error details that the AI model can reason about.").ToChatMessage());
        }
    }
}

Remarque

Les classes FunctionCallContent et FunctionResultContent sont utilisées pour représenter les appels de fonction de modèle IA et les résultats d’appel de fonction de noyau sémantique, respectivement. Ils contiennent des informations sur la fonction choisie, telles que l’ID de fonction, le nom et les arguments, ainsi que les résultats d’appel de fonction, tels que l’ID d’appel de fonction et le résultat.

Bientôt disponible

Plus d’informations prochainement.

Bientôt disponible

Plus d’informations prochainement.