Che cos'è un Planner?

Dopo aver creato più plug-in, è necessario un modo per consentire all'agente di intelligenza artificiale di usarli insieme per risolvere le esigenze di un utente. È qui che entra in gioco la pianificazione.

Nelle prime fasi, il kernel semantico ha introdotto il concetto di planner che usava richieste di richiedere all'intelligenza artificiale di scegliere le funzioni da richiamare. Poiché il kernel semantico è stato introdotto, Tuttavia, OpenAI ha introdotto un modo nativo per il modello di richiamare o "chiamare" una funzione: chiamata di funzione. Altri modelli di intelligenza artificiale come Gemini, Claude e Mistral hanno adottato la chiamata di funzione come funzionalità di base, rendendola una funzionalità supportata tra modelli.

A causa di questi progressi, il kernel semantico si è evoluto per usare la chiamata di funzione come metodo principale per pianificare ed eseguire attività.

Come funziona la chiamata a creare un "piano"?

Al suo modo più semplice, la chiamata di funzione è semplicemente un modo per richiamare una funzione con i parametri corretti. Si supponga, ad esempio, che un utente voglia attivare una lampadina. Supponendo che l'intelligenza artificiale abbia il plug-in corretto, può chiamare la funzione per accendere la luce.

Ma cosa succede se l'utente non conosce l'ID della luce? O se l'utente vuole accendere tutte le luci? È qui che entra in gioco la pianificazione. I modelli LLM di oggi sono in grado di chiamare in modo iterativo le funzioni per risolvere le esigenze di un utente. Questa operazione viene eseguita creando un ciclo di feedback in cui l'intelligenza artificiale può chiamare una funzione, controllare il risultato e quindi decidere cosa fare successivamente.

Ad esempio, un utente può chiedere all'intelligenza artificiale di attivare o disattivare una lampadina. L'intelligenza artificiale deve prima controllare lo stato della lampadina prima di decidere se attivarla o disattivarla.

Ciclo di pianificazione automatica

Il supporto della chiamata di funzione senza semantic kernel è relativamente complesso. È necessario scrivere un ciclo che consenta di eseguire le operazioni seguenti:

1. Creare schemi JSON per ognuna delle funzioni
2. Specificare l'LLM con la cronologia delle chat e gli schemi di funzione precedenti
3. Analizzare la risposta dell'LLM per determinare se vuole rispondere con un messaggio o chiamare una funzione
4. Se l'LLM vuole chiamare una funzione, è necessario analizzare il nome e i parametri della funzione dalla risposta LLM
5. Richiamare la funzione con i parametri corretti
6. Restituire i risultati della funzione in modo che l'LLM possa determinare le operazioni da eseguire successivamente
7. Ripetere i passaggi da 2 a 6 fino a quando l'LLM non decide di aver completato l'attività o ha bisogno di assistenza da parte dell'utente

Nel kernel semantico, è facile usare la chiamata di funzione automatizzando automaticamente questo ciclo. In questo modo è possibile concentrarsi sulla creazione dei plug-in necessari per risolvere le esigenze dell'utente.

Uso della chiamata automatica delle funzioni

Per usare la chiamata automatica della funzione in Semantic Kernel, è necessario eseguire le operazioni seguenti:

1. Registrare il plug-in con il kernel
2. Creare un oggetto impostazioni di esecuzione che indica all'intelligenza artificiale di chiamare automaticamente le funzioni
3. Richiamare il servizio di completamento della chat con la cronologia delle chat e il kernel

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

Quando si usa la chiamata automatica delle funzioni, tutti i passaggi del ciclo di pianificazione automatica vengono gestiti automaticamente e aggiunti all'oggetto ChatHistory . Al termine del ciclo di chiamata della funzione, è possibile esaminare l'oggetto ChatHistory per visualizzare tutte le chiamate di funzione effettuate e i risultati forniti dal kernel semantico.

Che cos'è la funzione che chiama stepwise e handlebars planner?

I planner stepwise e handlebars sono ancora disponibili nel kernel semantico. Tuttavia, è consigliabile usare la chiamata di funzione per la maggior parte delle attività perché è più potente e più facile da usare. Gli planner Stepwise e Handlebars saranno deprecati in una versione futura del kernel semantico.

Prima di deprecare questi planner, verranno fornite indicazioni su come eseguire la migrazione dei planner esistenti per chiamare le funzioni. Per eventuali domande su questo processo, contattare Microsoft nella bacheca delle discussioni nel repository GitHub del kernel semantico.

Passaggi successivi

Ora che si comprende come funzionano i planner nel kernel semantico, è possibile ottenere altre informazioni sull'influenza dell'agente di intelligenza artificiale in modo che pianino e eseseguono attività per conto degli utenti.