Mi az a Planner?

Ha több beépülő modult is használ, az AI-ügynöknek módot kell találnia arra, hogy együtt használják őket a felhasználó igényeinek megoldásához. Itt jön a tervezés.

A Szemantic Kernel már a kezdetekkor bevezette a tervezők fogalmát, amelyek arra kérték az AI-t, hogy válassza ki a meghívandó függvényeket. A Szemantikus Kernel bevezetése óta azonban az OpenAI natív módot vezetett be a modell számára egy függvény meghívására vagy "meghívására": függvényhívásra. Más AI-modellek, például a Gemini, a Claude és a Mistral azóta alapvető képességként használják a függvényhívást, így modellfüggvények közötti támogatott funkcióként működnek.

Ezen fejlesztések miatt a Szemantic Kernel úgy fejlődött, hogy a függvényhívást használja a feladatok tervezésének és végrehajtásának elsődleges módjaként.

Fontos

A függvényhívás csak a 0613 vagy újabb OpenAI-modellekben érhető el. Ha régebbi modellt használ (pl. 0314), ez a funkció hibát ad vissza. Javasoljuk, hogy használja a legújabb OpenAI-modelleket a funkció előnyeinek kihasználásához.

Hogyan hoz létre "tervet" a függvényhívás?

A legegyszerűbb esetben a függvényhívás csupán egy módja annak, hogy az AI meghívjon egy függvényt a megfelelő paraméterekkel. Vegyük például egy felhasználó szeretné bekapcsolni a villanykörte. Feltéve, hogy az AI rendelkezik a megfelelő beépülő modulval, meghívhatja a függvényt a fény bekapcsolásához.

Szerepkör	Üzenet
🔵Felhasználó	Kapcsolja be a lámpát #1
🔴Asszisztens (függvényhívás)	Lights.change_state(1, { "isOn": true })
🟢Eszköz	{ "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" }
🔴Asszisztens	A lámpa be van kapcsolva

De mi a teendő, ha a felhasználó nem ismeri a fény azonosítóját? Vagy mi a teendő, ha a felhasználó bekapcsolja az összes lámpát? Itt jön a tervezés. A mai LLM-modellek képesek iteratív módon meghívni a függvényeket a felhasználó szükségletének megoldásához. Ez egy visszajelzési ciklus létrehozásával érhető el, ahol az AI meghívhat egy függvényt, ellenőrizheti az eredményt, majd eldöntheti, hogy mi a következő lépés.

Egy felhasználó például megkérheti az AI-t, hogy "váltson" egy villanykörtét. Az AI-nek először ellenőriznie kell a villanykörte állapotát, mielőtt eldöntené, hogy be- vagy kikapcsolja-e.

Szerepkör	Üzenet
🔵Felhasználó	Kapcsolja ki az összes lámpát
🔴Asszisztens (függvényhívás)	Lights.get_lights()
🟢Eszköz	{ "lights": [ { "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" }, { "id": 2, "name": "Ceiling Light", "isOn": false, "brightness": 0, "hex": "FFFFFF" } ] }
🔴Asszisztens (függvényhívás)	Lights.change_state(1, { "isOn": false }) Lights.change_state(2, { "isOn": true })
🟢Eszköz	{ "id": 1, "name": "Table Lamp", "isOn": false, "brightness": 0, "hex": "FFFFFF" }
🟢Eszköz	{ "id": 2, "name": "Ceiling Light", "isOn": true, "brightness": 100, "hex": "FF0000" }
🔴Asszisztens	A fények ki vannak kapcsolva

Feljegyzés

Ebben a példában párhuzamos függvényhívást is láthatott. Az AI itt hívhat egyszerre több függvényt. Ez egy hatékony funkció, amely segíthet az AI-nek az összetett feladatok gyorsabb megoldásában. Az OpenAI-modellekhez 1106-ban adták hozzá.

Az automatikus tervezési ciklus

A szemantikai kernel nélküli függvényhívás támogatása viszonylag összetett. Olyan hurkot kell írnia, amely a következőket hajtja végre:

1. JSON-sémák létrehozása az egyes függvényekhez
2. Adja meg az LLM-nek az előző csevegési előzményeket és függvénysémákat
3. Az LLM válaszának elemzése annak megállapításához, hogy üzenettel szeretne-e válaszolni, vagy függvényt szeretne meghívni
4. Ha az LLM függvényt szeretne meghívni, elemeznie kell a függvény nevét és paramétereit az LLM válaszából
5. A függvény meghívása a megfelelő paraméterekkel
6. Adja vissza a függvény eredményeit, hogy az LLM meg tudja határozni, hogy mi legyen a következő lépés
7. Ismételje meg a 2–6. lépést, amíg az LLM el nem dönti, hogy elvégezte a feladatot, vagy segítségre van szüksége a felhasználótól

A Szemantic Kernelben a ciklus automatizálásával megkönnyítjük a függvényhívás használatát. Ez lehetővé teszi, hogy a felhasználó igényeinek kielégítéséhez szükséges beépülő modulok létrehozására összpontosítson.

Feljegyzés

A függvényhívási ciklus működésének megértése elengedhetetlen a teljesítményt nyújtó és megbízható AI-ügynökök létrehozásához. A ciklus működésének részletes ismertetését a függvényhívásról szóló cikkben találja.

Automatikus függvényhívás használata

Ha automatikus függvényhívást szeretne használni a Szemantic Kernelben, a következőket kell tennie:

1. A beépülő modul regisztrálása a kernellel
2. Végrehajtási beállításokat tartalmazó objektum létrehozása, amely arra utasítja az AI-t, hogy automatikusan hívja meg a függvényeket
3. A csevegés befejező szolgáltatásának meghívása a csevegési előzményekkel és a kernellel

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

Ha automatikus függvényhívást használ, az automatikus tervezési ciklus minden lépését kezeli a rendszer, és hozzáadja az ChatHistory objektumhoz. A függvényhívási ciklus befejezése után megvizsgálhatja az ChatHistory objektumot, hogy lássa a Szemantic Kernel által végrehajtott összes függvényhívást és eredményt.

Mi a helyzet a lépésenkénti és a kezelősáv-tervezőket hívó függvényekkel?

A Stepwise és a Handlebars planners továbbra is elérhető a Szemantic Kernelben. Azt javasoljuk azonban, hogy a legtöbb feladathoz használjon függvényhívást, mivel hatékonyabb és könnyebben használható. A Stepwise és a Handlebars tervezők is elavultak lesznek a Szemantic Kernel jövőbeli kiadásában.

Mielőtt megszüntetnénk ezeket a tervezőket, útmutatást adunk a meglévő tervezők függvényhívásra való migrálásához. Ha kérdése van a folyamatról, forduljon hozzánk a Szemantic Kernel GitHub-adattár vitafórumán .

Figyelemfelhívás

Ha új AI-ügynököt hoz létre, javasoljuk, hogy ne használja a Stepwise vagy a Handlebars tervezőt. Ehelyett használjon függvényhívást, mivel hatékonyabb és könnyebben használható.

Következő lépések

Most, hogy megismerte, hogyan működnek a tervezők a Szemantic Kernelben, többet tudhat meg arról, hogyan befolyásolja az AI-ügynököt, hogy a felhasználók nevében a legjobban megtervezhesse és végrehajthassa a feladatokat.

További információ a személyekről