Tervezés

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.

That is not necessary since there are no changes to apply.	Üzenet
🔵 Felhasználó	Kapcsolja be a lámpát #1
🔴 Assistant (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.

That is not necessary since there are no changes to apply.	Üzenet
🔵 Felhasználó	Kapcsolja át az összes lámpát
🔴 Assistant (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" } ] }
🔴 Assistant (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ényeket átkapcsolták

Megjegyzé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.

Megjegyzé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 chatbefejező szolgáltatás meghívása a csevegési előzményekkel és a kernellel együtt.

Jótanács

Az alábbi kódminta az itt definiált LightsPlugin kódot használja.

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() 
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

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.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
from semantic_kernel.connectors.ai.open_ai import (
    AzureChatCompletion,
    AzureChatPromptExecutionSettings,
)
from semantic_kernel.contents import ChatHistory
from semantic_kernel.functions import kernel_function

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

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

    # 2. Enable automatic function calling
    execution_settings = AzureChatPromptExecutionSettings()
    execution_settings.function_choice_behavior = FunctionChoiceBehavior.Auto()

    # 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_content(
            chat_history=history,
            settings=execution_settings,
            kernel=kernel,
        )

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

    OpenAIAsyncClient client = new OpenAIClientBuilder()
        .credential(new AzureKeyCredential(AZURE_CLIENT_KEY))
        .endpoint(CLIENT_ENDPOINT)
        .buildAsyncClient();

    // Import the LightsPlugin
    KernelPlugin lightPlugin = KernelPluginFactory.createFromObject(new LightsPlugin(),
        "LightsPlugin");

    // Create your AI service client
    ChatCompletionService chatCompletionService = OpenAIChatCompletion.builder()
        .withModelId(MODEL_ID)
        .withOpenAIAsyncClient(client)
        .build();

    // Create a kernel with Azure OpenAI chat completion and plugin
    Kernel kernel = Kernel.builder()
        .withAIService(ChatCompletionService.class, chatCompletionService)
        .withPlugin(lightPlugin)
        .build();

    // Add a converter to the kernel to show it how to serialise LightModel objects into a prompt
    ContextVariableTypes
        .addGlobalConverter(
            ContextVariableTypeConverter.builder(LightModel.class)
                .toPromptString(new Gson()::toJson)
                .build());

    // Enable planning
    InvocationContext invocationContext = new InvocationContext.Builder()
        .withReturnMode(InvocationReturnMode.LAST_MESSAGE_ONLY)
        .withToolCallBehavior(ToolCallBehavior.allowAllKernelFunctions(true))
        .build();

    // Create a history to store the conversation
    ChatHistory history = new ChatHistory();

    // Initiate a back-and-forth chat
    Scanner scanner = new Scanner(System.in);
    String userInput;
    do {
      // Collect user input
      System.out.print("User > ");

      userInput = scanner.nextLine();
      // Add user input
      history.addUserMessage(userInput);

      // Prompt AI for response to users input
      List<ChatMessageContent<?>> results = chatCompletionService
          .getChatMessageContentsAsync(history, kernel, invocationContext)
          .block();

      for (ChatMessageContent<?> result : results) {
        // Print the results
        if (result.getAuthorRole() == AuthorRole.ASSISTANT && result.getContent() != null) {
          System.out.println("Assistant > " + result);
        }
        // Add the message from the agent to the chat history
        history.addMessage(result);
      }
    } while (userInput != null && !userInput.isEmpty());

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 történt a Stepwise és a Handlebars tervezőkkel?

A Stepwise és a Handlebars tervezők elavultak, és el lettek távolítva a Szemantic Kernel csomagból. Ezek a tervezők már nem támogatottak sem a Pythonban, sem a .NET-ben, sem a Java-ban.

Azt javasoljuk, hogy használjon függvényhívást, amely a legtöbb forgatókönyv esetében hatékonyabb és könnyebben használható.

A meglévő megoldások frissítéséhez kövesse a Stepwise Planner migrálási útmutatót.

Jótanács

Új AI-ügynökök esetén használjon függvényhívást az elavult tervezők helyett. Nagyobb rugalmasságot, beépített eszköztámogatást és egyszerűbb fejlesztési élményt nyújt.

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.