Was ist ein Planner?
Sobald Sie über mehrere Plug-Ins verfügen, benötigen Sie eine Möglichkeit für Ihren KI-Agenten, sie zusammen zu verwenden, um die Notwendigkeit eines Benutzers zu lösen. Hier kommt die Planung an.
Früher hat der semantische Kernel das Konzept von Plannern eingeführt, die Dazu aufgefordert wurden, die KI anzufordern, welche Funktionen aufgerufen werden sollen. Seit der Einführung des semantischen Kernels hat OpenAI jedoch eine systemeigene Methode für das Modell zum Aufrufen oder "Aufrufen" einer Funktion eingeführt: Funktionsaufrufe. Andere KI-Modelle wie Gemini, Claude und Mistral haben seitdem Funktionsaufrufe als Kernfunktion übernommen, wodurch es zu einem modellübergreifenden unterstützten Feature wird.
Aufgrund dieser Fortschritte hat sich der semantische Kernel entwickelt, um Funktionsaufrufe als primäre Methode zum Planen und Ausführen von Aufgaben zu verwenden.
Wichtig
Funktionsaufrufe sind nur in OpenAI-Modellen verfügbar, die 0613 oder höher sind. Wenn Sie ein älteres Modell (z. B. 0314) verwenden, gibt diese Funktion einen Fehler zurück. Wir empfehlen die Verwendung der neuesten OpenAI-Modelle, um dieses Feature nutzen zu können.
Wie wird durch Funktionsaufrufe ein "Plan" erstellt?
Am einfachsten ist das Aufrufen von Funktionen lediglich eine Möglichkeit für eine KI, eine Funktion mit den richtigen Parametern aufzurufen. Nehmen Wir beispielsweise an, dass ein Benutzer eine Glühbirne einschalten möchte. Wenn die KI über das richtige Plug-In verfügt, kann sie die Funktion aufrufen, um das Licht zu aktivieren.
| Role | `Message` |
|---|---|
| 🔵Benutzer | Bitte aktivieren Sie licht Nr. 1 |
| 🔴Assistent (Funktionsaufruf) | Lights.change_state(1, { "isOn": true }) |
| 🟢Tool | { "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" } |
| 🔴Assistent | Die Lampe ist jetzt eingeschaltet |
Aber was passiert, wenn der Benutzer die ID des Lichts nicht kennt? Oder was geschieht, wenn der Benutzer alle Lichter einschalten möchte? Hier kommt die Planung an. Die heutigen LLM-Modelle können Funktionen iterativ aufrufen, um die Notwendigkeit eines Benutzers zu lösen. Dazu wird eine Feedbackschleife erstellt, in der die KI eine Funktion aufrufen kann, das Ergebnis überprüfen und dann entscheiden, was als Nächstes zu tun ist.
Beispielsweise kann ein Benutzer die KI auffordern, eine Glühbirne zu "umschalten". Die KI müsste zuerst den Zustand der Glühbirne überprüfen, bevor Sie entscheiden, ob sie ein- oder ausgeschaltet werden soll.
| Role | `Message` |
|---|---|
| 🔵Benutzer | Bitte schalten Sie alle Lichter um. |
| 🔴Assistent (Funktionsaufruf) | Lights.get_lights() |
| 🟢Tool | { "lights": [ { "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" }, { "id": 2, "name": "Ceiling Light", "isOn": false, "brightness": 0, "hex": "FFFFFF" } ] } |
| 🔴Assistent (Funktionsaufruf) | Lights.change_state(1, { "isOn": false }) Lights.change_state(2, { "isOn": true }) |
| 🟢Tool | { "id": 1, "name": "Table Lamp", "isOn": false, "brightness": 0, "hex": "FFFFFF" } |
| 🟢Tool | { "id": 2, "name": "Ceiling Light", "isOn": true, "brightness": 100, "hex": "FF0000" } |
| 🔴Assistent | Die Lichter wurden umgeschaltet |
Hinweis
In diesem Beispiel haben Sie auch parallele Funktionsaufrufe gesehen. Hier kann die KI mehrere Funktionen gleichzeitig aufrufen. Dies ist ein leistungsfähiges Feature, mit dem die KI komplexe Aufgaben schneller lösen kann. Es wurde 1106 den OpenAI-Modellen hinzugefügt.
Die automatische Planungsschleife
Das Unterstützen von Funktionsaufrufen ohne semantischen Kernel ist relativ komplex. Sie müssen eine Schleife schreiben, die folgendes erreichen würde:
- Erstellen von JSON-Schemas für jede Ihrer Funktionen
- Bereitstellen des LLM mit den vorherigen Chatverlaufs- und Funktionsschemas
- Analysieren Sie die Antwort des LLM, um zu ermitteln, ob er mit einer Nachricht antworten oder eine Funktion aufrufen möchte.
- Wenn die LLM eine Funktion aufrufen möchte, müssen Sie den Funktionsnamen und die Parameter aus der Antwort des LLM analysieren.
- Aufrufen der Funktion mit den richtigen Parametern
- Zurückgeben der Ergebnisse der Funktion, damit die LLM bestimmen kann, was als Nächstes ausgeführt werden soll
- Wiederholen Sie die Schritte 2 bis 6, bis die LLM entscheidet, dass sie die Aufgabe abgeschlossen hat oder Hilfe vom Benutzer benötigt.
Im semantischen Kernel vereinfachen wir die Verwendung von Funktionsaufrufen, indem diese Schleife für Sie automatisiert wird. Auf diese Weise können Sie sich auf die Erstellung der Plug-Ins konzentrieren, die erforderlich sind, um die Anforderungen Ihres Benutzers zu lösen.
Hinweis
Das Verständnis der Funktionsweise der Funktionsaufrufschleife ist für die Erstellung von leistungsfähigen und zuverlässigen KI-Agents unerlässlich. Ausführliche Informationen zur Funktionsweise der Schleife finden Sie im Artikel zum Aufrufen von Funktionen.
Verwenden von automatischen Funktionsaufrufen
Um automatische Funktionsaufrufe im semantischen Kernel zu verwenden, müssen Sie die folgenden Schritte ausführen:
- Registrieren des Plug-Ins beim Kernel
- Erstellen eines Ausführungseinstellungsobjekts, das die KI angibt, Funktionen automatisch aufzurufen
- Aufrufen des Chatabschlussdiensts mit dem Chatverlauf und dem 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())
Wenn Sie automatische Funktionsaufrufe verwenden, werden alle Schritte in der automatischen Planungsschleife für Sie behandelt und dem ChatHistory Objekt hinzugefügt. Nachdem die Funktionsaufrufschleife abgeschlossen ist, können Sie das ChatHistory Objekt überprüfen, um alle vom semantischen Kernel bereitgestellten Funktionsaufrufe und Ergebnisse anzuzeigen.
Was ist mit den Planern für Funktionsaufrufe und Handlebars?
Die Planer "Stepwise" und "Handlebars" sind weiterhin im semantischen Kernel verfügbar. Es wird jedoch empfohlen, Funktionsaufrufe für die meisten Aufgaben zu verwenden, da sie leistungsstärker und einfacher zu verwenden ist. Sowohl die Planer "Stepwise" als auch "Handlebars" werden in einer zukünftigen Version des semantischen Kernels veraltet sein.
Bevor wir diese Planner veraltet sind, bieten wir Anleitungen zum Migrieren Ihrer vorhandenen Planner zum Funktionsaufruf. Wenn Sie Fragen zu diesem Prozess haben, wenden Sie sich bitte an uns über die Diskussionsrunde im Repository für semantischen Kernel GitHub.
Achtung
Wenn Sie einen neuen KI-Agent erstellen, empfehlen wir, die Planer "Stepwise" oder "Handlebars" nicht zu verwenden. Verwenden Sie stattdessen Funktionsaufrufe, da sie leistungsstärker und einfacher zu verwenden ist.
Nächste Schritte
Nachdem Sie nun verstehen, wie Planner im semantischen Kernel funktionieren, erfahren Sie mehr darüber, wie Sie Ihren KI-Agent beeinflussen, damit sie Aufgaben im Auftrag Ihrer Benutzer am besten planen und ausführen können.