Qu’est-ce qu’un planificateur ?

Une fois que vous avez plusieurs plug-ins, vous avez besoin d’un moyen pour que votre agent IA les utilise ensemble pour résoudre les besoins d’un utilisateur. C’est là que se trouve la planification.

Dès le début, le noyau sémantique a introduit le concept de planificateurs qui utilisaient des invites pour demander à l’IA de choisir les fonctions à appeler. Depuis l’introduction du noyau sémantique, cependant, OpenAI a introduit une méthode native pour que le modèle appelle ou « appelle » une fonction : appel de fonction. D’autres modèles IA tels que Gemini, Claude et Mistral ont depuis adopté l’appel de fonction comme fonctionnalité de base, ce qui en fait une fonctionnalité prise en charge par plusieurs modèles.

En raison de ces avancées, le noyau sémantique a évolué pour utiliser l’appel de fonction comme moyen principal de planifier et d’exécuter des tâches.

Comment la fonction appelante crée-t-elle un « plan » ?

À son plus simple, l’appel de fonction est simplement un moyen pour une IA d’appeler une fonction avec les paramètres appropriés. Prenons l’exemple d’un utilisateur qui souhaite activer une ampoule. En supposant que l’IA dispose du plug-in approprié, elle peut appeler la fonction pour activer la lumière.

Mais que se passe-t-il si l’utilisateur ne connaît pas l’ID de la lumière ? Ou que se passe-t-il si l’utilisateur veut activer toutes les lumières ? C’est là que se trouve la planification. Les modèles LLM d’aujourd’hui sont capables d’appeler de manière itérative des fonctions pour résoudre les besoins d’un utilisateur. Pour ce faire, créez une boucle de commentaires dans laquelle l’IA peut appeler une fonction, vérifier le résultat, puis décider de ce qu’il faut faire ensuite.

Par exemple, un utilisateur peut demander à l’IA de « basculer » une ampoule. L’IA doit d’abord vérifier l’état de l’ampoule avant de décider s’il faut l’activer ou le désactiver.

Boucle de planification automatique

La prise en charge des appels de fonction sans noyau sémantique est relativement complexe. Vous devez écrire une boucle qui effectuerait les opérations suivantes :

1. Créer des schémas JSON pour chacune de vos fonctions
2. Fournir le LLM avec l’historique de conversation et les schémas de fonction précédents
3. Analyser la réponse du LLM pour déterminer s’il souhaite répondre avec un message ou appeler une fonction
4. Si le LLM souhaite appeler une fonction, vous devez analyser le nom et les paramètres de la fonction à partir de la réponse de LLM
5. Appeler la fonction avec les paramètres appropriés
6. Retourne les résultats de la fonction afin que le LLM puisse déterminer ce qu’il doit faire ensuite
7. Répétez les étapes 2 à 6 jusqu’à ce que le LLM décide qu’il a terminé la tâche ou a besoin d’aide de l’utilisateur

Dans le noyau sémantique, nous allons facilement utiliser les appels de fonction en automatisant cette boucle pour vous. Cela vous permet de vous concentrer sur la création des plug-ins nécessaires pour répondre aux besoins de votre utilisateur.

Utilisation de l’appel automatique de fonction

Pour utiliser l’appel automatique de fonction dans le noyau sémantique, vous devez effectuer les opérations suivantes :

1. Inscrire le plug-in auprès du noyau
2. Créer un objet de paramètres d’exécution qui indique à l’IA d’appeler automatiquement des fonctions
3. Appeler le service d’achèvement de conversation avec l’historique des conversations et le noyau

using System.ComponentModel;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.OpenAI;

// 1. Create the kernel with the Lights plugin
var builder = Kernel.CreateBuilder().AddAzureOpenAIChatCompletion(modelId, endpoint, apiKey);
builder.Plugins.AddFromType<LightsPlugin>("Lights");
Kernel kernel = builder.Build();

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

// 2. Enable automatic function calling
OpenAIPromptExecutionSettings openAIPromptExecutionSettings = new() 
{
    ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions
};

var history = new ChatHistory();

string? userInput;
do {
    // Collect user input
    Console.Write("User > ");
    userInput = Console.ReadLine();

    // Add user input
    history.AddUserMessage(userInput);

    // 3. Get the response from the AI with automatic function calling
    var result = await chatCompletionService.GetChatMessageContentAsync(
        history,
        executionSettings: openAIPromptExecutionSettings,
        kernel: kernel);

    // Print the results
    Console.WriteLine("Assistant > " + result);

    // Add the message from the agent to the chat history
    history.AddMessage(result.Role, result.Content ?? string.Empty);
} while (userInput is not null)

import asyncio

from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior
from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.functions.kernel_arguments import KernelArguments

from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
    AzureChatPromptExecutionSettings,
)

async def main():
    # 1. Create the kernel with the Lights plugin
    kernel = Kernel()
    kernel.add_service(AzureChatCompletion(
        deployment_name="your_models_deployment_name",
        api_key="your_api_key",
        base_url="your_base_url",
    ))
    kernel.add_plugin(
        LightsPlugin(),
        plugin_name="Lights",
    )

    chat_completion : AzureChatCompletion = kernel.get_service(type=ChatCompletionClientBase)

    # 2. Enable automatic function calling
    execution_settings = AzureChatPromptExecutionSettings(tool_choice="auto")
    execution_settings.function_call_behavior = FunctionCallBehavior.EnableFunctions(auto_invoke=True, filters={})

    # Create a history of the conversation
    history = ChatHistory()

    userInput = None
    while True:
        # Collect user input
        userInput = input("User > ")

        # Terminate the loop if the user says "exit"
        if userInput == "exit":
            break

        # Add user input to the history
        history.add_user_message(userInput)

        # 3. Get the response from the AI with automatic function calling
        result = (await chat_completion.get_chat_message_contents(
            chat_history=history,
            settings=execution_settings,
            kernel=kernel,
            arguments=KernelArguments(),
        ))[0]

        # Print the results
        print("Assistant > " + str(result))

        # Add the message from the agent to the chat history
        history.add_message(result)

# Run the main function
if __name__ == "__main__":
    asyncio.run(main())

Lorsque vous utilisez l’appel automatique de fonction, toutes les étapes de la boucle de planification automatique sont gérées pour vous et ajoutées à l’objet ChatHistory . Une fois la boucle d’appel de fonction terminée, vous pouvez inspecter l’objet ChatHistory pour afficher tous les appels de fonction effectués et les résultats fournis par le noyau sémantique.

Qu’en est-il des planificateurs d’appels de fonction et de handlebars ?

Les planificateurs Stepwise et Handlebars sont toujours disponibles dans le noyau sémantique. Toutefois, nous vous recommandons d’utiliser l’appel de fonction pour la plupart des tâches, car il est plus puissant et plus facile à utiliser. Les planificateurs Stepwise et Handlebars seront déconseillés dans une prochaine version du noyau sémantique.

Avant de déprécier ces planificateurs, nous fournirons des conseils sur la migration de vos planificateurs existants vers les appels de fonction. Si vous avez des questions sur ce processus, contactez-nous sur le forum de discussion dans le dépôt GitHub du noyau sémantique.

Étapes suivantes

Maintenant que vous comprenez le fonctionnement des planificateurs dans le noyau sémantique, vous pouvez en savoir plus sur l’influence de votre agent IA afin qu’il planifie et exécute les tâches au nom de vos utilisateurs.