Hinzufügen von systemeigenem Code als Plug-In

Die einfachste Möglichkeit, einen KI-Agent mit Funktionen bereitzustellen, die nicht nativ unterstützt werden, besteht darin, systemeigenen Code in ein Plug-In umzuschließen. Auf diese Weise können Sie Ihre vorhandenen Fähigkeiten als App-Entwickler nutzen, um die Funktionen Ihrer KI-Agents zu erweitern.

Hinter den Kulissen verwendet der semantische Kernel dann die Beschreibungen, die Sie bereitstellen, zusammen mit Reflexion, um das Plug-In semantisch dem KI-Agent zu beschreiben. Auf diese Weise kann der KI-Agent die Funktionen des Plug-Ins verstehen und mit diesem interagieren.

Bereitstellen der LLM mit den richtigen Informationen

Beim Erstellen eines Plug-Ins müssen Sie dem KI-Agenten die richtigen Informationen bereitstellen, um die Funktionen des Plug-Ins und seiner Funktionen zu verstehen. Dies umfasst:

• Der Name des Plug-Ins
• Die Namen der Funktionen
• Die Beschreibungen der Funktionen
• Die Parameter der Funktionen
• Das Schema der Parameter
• Das Schema des Rückgabewerts

Der Wert des semantischen Kernels besteht darin, dass die meisten dieser Informationen automatisch aus dem Code selbst generiert werden können. Als Entwickler bedeutet dies lediglich, dass Sie die semantischen Beschreibungen der Funktionen und Parameter bereitstellen müssen, damit der KI-Agent sie verstehen kann. Wenn Sie Ihren Code richtig kommentieren und annotieren, haben Sie diese Informationen wahrscheinlich bereits zur Hand.

Im Folgenden werden wir die beiden verschiedenen Möglichkeiten zum Bereitstellen Ihres KI-Agents mit systemeigenem Code und der Bereitstellung dieser semantischen Informationen durchgehen.

Definieren eines Plug-Ins mithilfe einer Klasse

Die einfachste Möglichkeit zum Erstellen eines nativen Plug-Ins besteht darin, mit einer Klasse zu beginnen und dann Methoden hinzuzufügen, die mit dem KernelFunction Attribut versehen sind. Es wird auch empfohlen, die Description Anmerkung liberal zu verwenden, um dem KI-Agenten die erforderlichen Informationen zur Kenntnis der Funktion bereitzustellen.

Tipp

Im Folgenden LightsPlugin wird die LightModelhier definierte Definition verwendet.

public class LightsPlugin
{
   private readonly List<LightModel> _lights;

   public LightsPlugin(LoggerFactory loggerFactory, List<LightModel> lights)
   {
      _lights = lights;
   }

   [KernelFunction("get_lights")]
   [Description("Gets a list of lights and their current state")]
   public async Task<List<LightModel>> GetLightsAsync()
   {
      return _lights;
   }

   [KernelFunction("change_state")]
   [Description("Changes the state of the light")]
   public async Task<LightModel?> ChangeStateAsync(LightModel changeState)
   {
      // Find the light to change
      var light = _lights.FirstOrDefault(l => l.Id == changeState.Id);

      // If the light does not exist, return null
      if (light == null)
      {
         return null;
      }

      // Update the light state
      light.IsOn = changeState.IsOn;
      light.Brightness = changeState.Brightness;
      light.Color = changeState.Color;

      return light;
   }
}

from typing import Annotated

from semantic_kernel.functions import kernel_function

class LightsPlugin:
    def __init__(self, lights: list[LightModel]):
        self._lights = lights

    @kernel_function
    async def get_lights(self) -> list[LightModel]:
        """Gets a list of lights and their current state."""
        return self._lights

    @kernel_function
    async def change_state(
        self,
        change_state: LightModel
    ) -> LightModel | None:
        """Changes the state of the light."""
        for light in self._lights:
            if light["id"] == change_state["id"]:
                light["is_on"] = change_state.get("is_on", light["is_on"])
                light["brightness"] = change_state.get("brightness", light["brightness"])
                light["hex"] = change_state.get("hex", light["hex"])
                return light
        return None

public class LightsPlugin {

    // Mock data for the lights
    private final Map<Integer, LightModel> lights = new HashMap<>();

    public LightsPlugin() {
        lights.put(1, new LightModel(1, "Table Lamp", false, LightModel.Brightness.MEDIUM, "#FFFFFF"));
        lights.put(2, new LightModel(2, "Porch light", false, LightModel.Brightness.HIGH, "#FF0000"));
        lights.put(3, new LightModel(3, "Chandelier", true, LightModel.Brightness.LOW, "#FFFF00"));
    }

    @DefineKernelFunction(name = "get_lights", description = "Gets a list of lights and their current state")
    public List<LightModel> getLights() {
        System.out.println("Getting lights");
        return new ArrayList<>(lights.values());
    }

    @DefineKernelFunction(name = "change_state", description = "Changes the state of the light")
    public LightModel changeState(
            @KernelFunctionParameter(
                    name = "model",
                    description = "The new state of the model to set. Example model: " +
                            "{\"id\":99,\"name\":\"Head Lamp\",\"isOn\":false,\"brightness\":\"MEDIUM\",\"color\":\"#FFFFFF\"}",
                    type = LightModel.class) LightModel model
    ) {
        System.out.println("Changing light " + model.getId() + " " + model.getIsOn());
        if (!lights.containsKey(model.getId())) {
            throw new IllegalArgumentException("Light not found");
        }

        lights.put(model.getId(), model);

        return lights.get(model.getId());
    }
}

Tipp

Da die LLMs überwiegend auf Python-Code trainiert werden, empfiehlt es sich, snake_case für Funktionsnamen und Parameter zu verwenden (auch wenn Sie C# oder Java verwenden). Dies hilft dem KI-Agent, die Funktion und die zugehörigen Parameter besser zu verstehen.

Tipp

Ihre Funktionen können Kernel, KernelArguments, ILoggerFactory, ILogger, IAIServiceSelector, CultureInfo, IFormatProvider, CancellationToken als Parameter angeben. Diese werden nicht an das LLM weitergegeben, sondern automatisch festgelegt, wenn die Funktion aufgerufen wird. Wenn Sie sich auf KernelArguments anstelle expliziter Eingabeargumente verlassen, ist Ihr Code für die Ausführung von Typkonvertierungen verantwortlich.

Wenn Ihre Funktion ein komplexes Objekt als Eingabevariable aufweist, generiert der semantische Kernel auch ein Schema für dieses Objekt und übergibt es an den KI-Agent. Ähnlich wie Funktionen sollten Sie Anmerkungen für Description Eigenschaften bereitstellen, die für die KI nicht offensichtlich sind. Unten sehen Sie die Definition für die LightState Klasse und die Brightness Enumeration.

using System.Text.Json.Serialization;

public class LightModel
{
   [JsonPropertyName("id")]
   public int Id { get; set; }

   [JsonPropertyName("name")]
   public string? Name { get; set; }

   [JsonPropertyName("is_on")]
   public bool? IsOn { get; set; }

   [JsonPropertyName("brightness")]
   public Brightness? Brightness { get; set; }

   [JsonPropertyName("color")]
   [Description("The color of the light with a hex code (ensure you include the # symbol)")]
   public string? Color { get; set; }
}

[JsonConverter(typeof(JsonStringEnumConverter))]
public enum Brightness
{
   Low,
   Medium,
   High
}

from enum import Enum
from typing import TypedDict

class Brightness(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class LightModel(TypedDict):
    id: int
    name: str
    is_on: bool | None
    brightness: Brightness | None
    color: Annotated[str | None, "The color of the light with a hex code (ensure you include the # symbol)"]

public class LightModel {

    private int id;
    private String name;
    private Boolean isOn;
    private Brightness brightness;
    private String color;


    public enum Brightness {
        LOW,
        MEDIUM,
        HIGH
    }

    public LightModel(int id, String name, Boolean isOn, Brightness brightness, String color) {
        this.id = id;
        this.name = name;
        this.isOn = isOn;
        this.brightness = brightness;
        this.color = color;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Boolean getIsOn() {
        return isOn;
    }

    public void setIsOn(Boolean isOn) {
        this.isOn = isOn;
    }

    public Brightness getBrightness() {
        return brightness;
    }

    public void setBrightness(Brightness brightness) {
        this.brightness = brightness;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

Hinweis

Während dies ein "lustiges" Beispiel ist, ist es eine gute Aufgabe, genau zu zeigen, wie komplex die Parameter eines Plug-Ins sein können. In diesem einzigen Fall haben wir ein komplexes Objekt mit vier verschiedenen Eigenschaftentypen: eine ganze Zahl, eine Zeichenfolge, einen Booleschen Wert und eine Enumeration. Der Wert des semantischen Kernels besteht darin, dass es das Schema für dieses Objekt automatisch generieren und an den KI-Agent übergeben und die vom KI-Agent generierten Parameter in das richtige Objekt marshallen kann.

Nachdem Sie die Erstellung Ihrer Plug-In-Klasse abgeschlossen haben, können Sie sie mit den AddFromType<> Methoden oder AddFromObject Methoden zum Kernel hinzufügen.

Nachdem Sie die Erstellung Ihrer Plug-In-Klasse abgeschlossen haben, können Sie sie mithilfe der add_plugin-Methode zum Kernel hinzufügen.

Nachdem Sie die Erstellung Ihrer Plug-In-Klasse abgeschlossen haben, können Sie sie mit den AddFromType<> Methoden oder AddFromObject Methoden zum Kernel hinzufügen.

Tipp

Fragen Sie sich beim Erstellen einer Funktion immer: "Wie kann ich der KI zusätzliche Hilfe zur Verwendung dieser Funktion geben?" Dazu können bestimmte Eingabetypen verwendet werden (Zeichenfolgen möglichst vermeiden), Beschreibungen und Beispiele bereitstellen.

Hinzufügen eines Plug-Ins mithilfe der AddFromObject Methode

Mit AddFromObject der Methode können Sie eine Instanz der Plug-In-Klasse direkt zur Plug-In-Sammlung hinzufügen, falls Sie direkt steuern möchten, wie das Plug-In erstellt wird.

Beispielsweise erfordert der Konstruktor der LightsPlugin Klasse die Liste der Lichter. In diesem Fall können Sie eine Instanz der Plug-In-Klasse erstellen und der Plugin-Sammlung hinzufügen.

List<LightModel> lights = new()
   {
      new LightModel { Id = 1, Name = "Table Lamp", IsOn = false, Brightness = Brightness.Medium, Color = "#FFFFFF" },
      new LightModel { Id = 2, Name = "Porch light", IsOn = false, Brightness = Brightness.High, Color = "#FF0000" },
      new LightModel { Id = 3, Name = "Chandelier", IsOn = true, Brightness = Brightness.Low, Color = "#FFFF00" }
   };

kernel.Plugins.AddFromObject(new LightsPlugin(lights));

Hinzufügen eines Plug-Ins mithilfe der AddFromType<> Methode

Bei Verwendung der AddFromType<> Methode verwendet der Kernel automatisch abhängigkeitsinjektion, um eine Instanz der Plug-In-Klasse zu erstellen und der Plug-In-Sammlung hinzuzufügen.

Dies ist hilfreich, wenn ihr Konstruktor Dienste oder andere Abhängigkeiten erfordert, die in das Plug-In eingefügt werden müssen. Zum Beispiel kann unsere LightsPlugin Klasse einen Logger und einen Lichtdienst benötigen, die in sie statt einer Liste von Lichtern injiziert werden.

public class LightsPlugin
{
   private readonly Logger _logger;
   private readonly LightService _lightService;

   public LightsPlugin(LoggerFactory loggerFactory, LightService lightService)
   {
      _logger = loggerFactory.CreateLogger<LightsPlugin>();
      _lightService = lightService;
   }

   [KernelFunction("get_lights")]
   [Description("Gets a list of lights and their current state")]
   public async Task<List<LightModel>> GetLightsAsync()
   {
      _logger.LogInformation("Getting lights");
      return lightService.GetLights();
   }

   [KernelFunction("change_state")]
   [Description("Changes the state of the light")]
   public async Task<LightModel?> ChangeStateAsync(LightModel changeState)
   {
      _logger.LogInformation("Changing light state");
      return lightService.ChangeState(changeState);
   }
}

Mit Dependency Injection können Sie dem Kernel-Generator die erforderlichen Dienste und Plug-Ins hinzufügen, bevor Sie den Kernel erstellen.

var builder = Kernel.CreateBuilder();

// Add dependencies for the plugin
builder.Services.AddLogging(loggingBuilder => loggingBuilder.AddConsole().SetMinimumLevel(LogLevel.Trace));
builder.Services.AddSingleton<LightService>();

// Add the plugin to the kernel
builder.Plugins.AddFromType<LightsPlugin>("Lights");

// Build the kernel
Kernel kernel = builder.Build();

Definieren eines Plug-Ins mithilfe einer Sammlung von Funktionen

Weniger häufig, aber dennoch nützlich ist das Definieren eines Plug-Ins mithilfe einer Sammlung von Funktionen. Dies ist besonders hilfreich, wenn Sie ein Plug-In dynamisch aus einer Reihe von Funktionen zur Laufzeit erstellen müssen.

Wenn Sie diesen Prozess verwenden, müssen Sie die Funktionsfabrik verwenden, um einzelne Funktionen zu erstellen, bevor Sie sie dem Plugin hinzufügen.

kernel.Plugins.AddFromFunctions("time_plugin",
[
    KernelFunctionFactory.CreateFromMethod(
        method: () => DateTime.Now,
        functionName: "get_time",
        description: "Get the current time"
    ),
    KernelFunctionFactory.CreateFromMethod(
        method: (DateTime start, DateTime end) => (end - start).TotalSeconds,
        functionName: "diff_time",
        description: "Get the difference between two times in seconds"
    )
]);

Zusätzliche Strategien zum Hinzufügen von nativem Code mit Dependency Injection

Wenn Sie mit Dependency Injection arbeiten, gibt es zusätzliche Strategien, mit denen Sie Plug-Ins erstellen und dem Kernel hinzufügen können. Im Folgenden finden Sie einige Beispiele dafür, wie Sie ein Plug-In mithilfe von Dependency Injection hinzufügen können.

Einfügen einer Plug-In-Sammlung

Tipp

Wir empfehlen, Ihre Plug-In-Sammlung als vorübergehenden Dienst zu verwenden, damit sie nach jeder Verwendung gelöscht wird, da die Plug-In-Sammlung änderbar ist. Das Erstellen einer neuen Plug-In-Sammlung für jede Verwendung ist billig, daher sollte es kein Leistungsproblem sein.

var builder = Host.CreateApplicationBuilder(args);

// Create native plugin collection
builder.Services.AddTransient((serviceProvider)=>{
   KernelPluginCollection pluginCollection = [];
   pluginCollection.AddFromType<LightsPlugin>("Lights");

   return pluginCollection;
});

// Create the kernel service
builder.Services.AddTransient<Kernel>((serviceProvider)=> {
   KernelPluginCollection pluginCollection = serviceProvider.GetRequiredService<KernelPluginCollection>();

   return new Kernel(serviceProvider, pluginCollection);
});

Tipp

Wie im Kernelartikel erwähnt, ist der Kernel äußerst leicht, sodass das Erstellen eines neuen Kernels für jede Verwendung als temporäre Einheit keine Leistungsprobleme verursacht.

Generieren Sie Ihre Plug-Ins als Singletons

Plugins sind nicht änderbar, daher ist es in der Regel sicher, sie als Singletons zu erstellen. Dies kann mithilfe der Plug-In-Factory erfolgen und das resultierende Plug-In zu Ihrer Dienstsammlung hinzufügen.

var builder = Host.CreateApplicationBuilder(args);

// Create singletons of your plugin
builder.Services.AddKeyedSingleton("LightPlugin", (serviceProvider, key) => {
    return KernelPluginFactory.CreateFromType<LightsPlugin>();
});

// Create a kernel service with singleton plugin
builder.Services.AddTransient((serviceProvider)=> {
    KernelPluginCollection pluginCollection = [
      serviceProvider.GetRequiredKeyedService<KernelPlugin>("LightPlugin")
    ];

    return new Kernel(serviceProvider, pluginCollection);
});

Hinzufügen eines Plug-Ins mithilfe der add_plugin Methode

Mit der add_plugin Methode können Sie dem Kernel eine Plug-In-Instanz hinzufügen. Nachfolgend finden Sie ein Beispiel dafür, wie Sie die LightsPlugin Klasse konstruieren und dem Kernel hinzufügen können.

# Create the kernel
kernel = Kernel()

# Create dependencies for the plugin
lights = [
    {"id": 1, "name": "Table Lamp", "is_on": False, "brightness": 100, "hex": "FF0000"},
    {"id": 2, "name": "Porch light", "is_on": False, "brightness": 50, "hex": "00FF00"},
    {"id": 3, "name": "Chandelier", "is_on": True, "brightness": 75, "hex": "0000FF"},
]

# Create the plugin
lights_plugin = LightsPlugin(lights)

# Add the plugin to the kernel
kernel.add_plugin(lights_plugin)

Hinzufügen eines Plug-Ins mithilfe der createFromObject Methode

Mit der createFromObject Methode können Sie ein Kernel-Plug-In aus einem Objekt mit kommentierten Methoden erstellen.

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

Dieses Plug-In kann dann einem Kernel hinzugefügt werden.

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

Bereitstellung eines Schemas für den Rückgabewert von Funktionen für das LLM

Derzeit gibt es keinen gut definierten, branchenweiten Standard für die Bereitstellung von Funktionsrückgabe-Metadaten für KI-Modelle. Bis ein solcher Standard eingerichtet wird, können die folgenden Techniken für Szenarien berücksichtigt werden, in denen die Namen von Rückgabetypeigenschaften nicht ausreichen, um zu gewährleisten, dass LLMs ihre Inhalte verstehen, oder wenn zusätzliche Kontext- oder Verarbeitungsrichtlinien dem Rückgabetyp zugeordnet werden müssen, um Ihre Szenarien zu modellieren oder zu verbessern.

Bevor Sie eine dieser Techniken verwenden, ist es ratsam, aussagekräftigere Namen für die Rückgabeeigenschaften bereitzustellen, da dies die einfachste Möglichkeit ist, das Verständnis des Rückgabetyps zu verbessern und auch kosteneffizient in Bezug auf den Tokenverbrauch ist.

Bereitstellung von Funktions-Rückgabetyp-Informationen in der Funktionsbeschreibung

Um diese Technik anzuwenden, fügen Sie das Rückgabetypschema in das Beschreibungsattribut der Funktion ein. Das Schema sollte die Eigenschaftennamen, Beschreibungen und Typen wie im folgenden Beispiel gezeigt detailliert beschreiben:

public class LightsPlugin
{
   [KernelFunction("change_state")]
   [Description("""Changes the state of the light and returns:
   {  
       "type": "object",
       "properties": {
           "id": { "type": "integer", "description": "Light ID" },
           "name": { "type": "string", "description": "Light name" },
           "is_on": { "type": "boolean", "description": "Is light on" },
           "brightness": { "type": "string", "enum": ["Low", "Medium", "High"], "description": "Brightness level" },
           "color": { "type": "string", "description": "Hex color code" }
       },
       "required": ["id", "name"]
   } 
   """)]
   public async Task<LightModel?> ChangeStateAsync(LightModel changeState)
   {
      ...
   }
}

Einige Modelle haben möglicherweise Einschränkungen für die Größe der Funktionsbeschreibung, daher ist es ratsam, das Schema präzise zu halten und nur wichtige Informationen einzuschließen.

In Fällen, in denen Typinformationen nicht kritisch sind und Sie den Tokenverbrauch minimieren möchten, sollten Sie eine kurze Beschreibung des Rückgabetyps in der Funktionsbeschreibung statt des vollständigen Schemas angeben.

public class LightsPlugin
{
   [KernelFunction("change_state")]
   [Description("""Changes the state of the light and returns:
        id: light ID,
        name: light name,
        is_on: is light on,
        brightness: brightness level (Low, Medium, High),
        color: Hex color code.
    """)]
   public async Task<LightModel?> ChangeStateAsync(LightModel changeState)
   {
      ...
   }
}

Bei beiden oben genannten Ansätzen muss das Rückgabetypschema manuell hinzugefügt und aktualisiert werden, sobald sich der Rückgabetyp ändert. Um dies zu vermeiden, sollten Sie die nächste Technik in Betracht ziehen.

Bereitstellung eines Schemas des Rückgabetyps als Teil des Rückgabewerts der Funktion.

Bei dieser Technik werden sowohl der Rückgabewert der Funktion als auch das Schema an das LLM übermittelt, anstatt nur den Rückgabewert. Auf diese Weise kann das LLM das Schema verwenden, um die Eigenschaften des Rückgabewerts zu ermitteln.

Um diese Technik zu implementieren, müssen Sie einen automatischen Funktionsaufruf-Filter registrieren und erstellen. Weitere Informationen finden Sie im Artikel Auto Function Invocation Filter. Dieser Filter sollte den Rückgabewert der Funktion in ein benutzerdefiniertes Objekt einschließen, das sowohl den ursprünglichen Rückgabewert als auch sein Schema enthält. Nachfolgend finden Sie ein Beispiel:

private sealed class AddReturnTypeSchemaFilter : IAutoFunctionInvocationFilter
{
    public async Task OnAutoFunctionInvocationAsync(AutoFunctionInvocationContext context, Func<AutoFunctionInvocationContext, Task> next)
    {
        await next(context); // Invoke the original function

        // Crete the result with the schema
        FunctionResultWithSchema resultWithSchema = new()
        {
            Value = context.Result.GetValue<object>(),                  // Get the original result
            Schema = context.Function.Metadata.ReturnParameter?.Schema  // Get the function return type schema
        };

        // Return the result with the schema instead of the original one
        context.Result = new FunctionResult(context.Result, resultWithSchema);
    }

    private sealed class FunctionResultWithSchema
    {
        public object? Value { get; set; }
        public KernelJsonSchema? Schema { get; set; }
    }
}

// Register the filter
Kernel kernel = new Kernel();
kernel.AutoFunctionInvocationFilters.Add(new AddReturnTypeSchemaFilter());

Mit dem registrierten Filter können Sie nun Beschreibungen für den Rückgabetyp und dessen Eigenschaften bereitstellen, die automatisch vom Semantischen Kernel extrahiert werden.

[Description("The state of the light")] // Equivalent to annotating the function with the [return: Description("The state of the light")] attribute
public class LightModel
{
    [JsonPropertyName("id")]
    [Description("The ID of the light")]
    public int Id { get; set; }

    [JsonPropertyName("name")]
    [Description("The name of the light")]
    public string? Name { get; set; }

    [JsonPropertyName("is_on")]
    [Description("Indicates whether the light is on")]
    public bool? IsOn { get; set; }

    [JsonPropertyName("brightness")]
    [Description("The brightness level of the light")]
    public Brightness? Brightness { get; set; }

    [JsonPropertyName("color")]
    [Description("The color of the light with a hex code (ensure you include the # symbol)")]
    public string? Color { get; set; }
}

Bei diesem Ansatz ist es nicht erforderlich, das Rückgabetypschema bei jeder Änderung des Rückgabetyps manuell bereitzustellen und zu aktualisieren, da das Schema automatisch vom semantischen Kernel extrahiert wird.

Bereitstellen weiterer Details zu den Funktionen

Beim Erstellen eines Plug-Ins in Python können Sie zusätzliche Informationen zu den Funktionen im kernel_function Dekorateur bereitstellen. Diese Informationen werden vom KI-Agenten verwendet, um die Funktionen besser zu verstehen.

from typing import Annotated

from semantic_kernel.functions import kernel_function

class LightsPlugin:
    def __init__(self, lights: list[LightModel]):
        self._lights = lights

    @kernel_function(name="GetLights", description="Gets a list of lights and their current state")
    async def get_lights(self) -> list[LightModel]:
        """Gets a list of lights and their current state."""
        return self._lights

    @kernel_function(name="ChangeState", description="Changes the state of the light")
    async def change_state(
        self,
        change_state: LightModel
    ) -> LightModel | None:
        """Changes the state of the light."""
        for light in self._lights:
            if light["id"] == change_state["id"]:
                light["is_on"] = change_state.get("is_on", light["is_on"])
                light["brightness"] = change_state.get("brightness", light["brightness"])
                light["hex"] = change_state.get("hex", light["hex"])
                return light
        return None

Im obigen Beispiel wird gezeigt, wie der Funktionsname geändert und eine Beschreibung für die Funktion bereitgestellt wird. Standardmäßig ist der Funktionsname der Name der Funktion, und die Beschreibung ist leer. Wenn der Funktionsname aussagekräftig genug ist, benötigen Sie keine Beschreibung, wodurch Sie Tokens sparen. Wenn das Funktionsverhalten jedoch nicht aus dem Namen offensichtlich ist, sollten Sie eine Beschreibung für die KI angeben.

Da die LLMs überwiegend auf Python-Code geschult sind, empfiehlt es sich, Funktionsnamen zu verwenden, die den Python-Benennungskonventionenfolgen. Dies bedeutet, dass Sie die Funktionsnamen selten überschreiben müssen, wenn Sie die Konventionen in Ihrem Python-Code befolgen.

Nächste Schritte

Nachdem Sie nun wissen, wie Sie ein Plug-In erstellen, können Sie jetzt erfahren, wie Sie sie mit Ihrem KI-Agent verwenden können. Abhängig von der Art der Funktionen, die Sie Ihren Plug-Ins hinzugefügt haben, gibt es verschiedene Muster, denen Sie folgen sollten. Informationen zu Abruffunktionen finden Sie im Artikel zur Verwendung von Abruffunktionen . Informationen zu Aufgabenautomatisierungsfunktionen finden Sie im Artikel "Aufgabenautomatisierungs-Funktionen" .

Informationen zur Verwendung von Abruffunktionen