Kontextbezogene Funktionsauswahl mit Agenten

Überblick

Die Kontextfunktionsauswahl ist eine erweiterte Funktion im Semantischen Kernel-Agent-Framework, mit der Agents nur die relevantesten Funktionen basierend auf dem aktuellen Unterhaltungskontext dynamisch auswählen und bewerben können. Anstatt dem KI-Modell alle verfügbaren Funktionen zur Verfügung zu stellen, verwendet diese Funktion die Retrieval-Augmented Generation (RAG), um nur die Funktionen herauszufiltern und zu präsentieren, die für die Anforderungen des Benutzers am relevantesten sind.

Dieser Ansatz behebt die Herausforderung der Funktionsauswahl bei der Behandlung einer großen Anzahl verfügbarer Funktionen, bei denen KI-Modelle andernfalls schwierigkeiten können, die entsprechende Funktion auszuwählen, was zu Verwirrung und suboptimaler Leistung führt.

Funktionsweise der Kontextfunktionsauswahl

Wenn ein Agent mit kontextbezogener Funktionsauswahl konfiguriert ist, nutzt er einen Vektorspeicher und einen Einbettungsgenerator, um semantisch mit dem aktuellen Unterhaltungskontext (einschließlich vorheriger Nachrichten und Benutzereingaben) mit den Beschreibungen und Namen der verfügbaren Funktionen übereinzugleichen. Die relevantesten Funktionen bis zum angegebenen Grenzwert werden dann dem KI-Modell zur Ausführung bereitgestellt.

Dieser Mechanismus ist besonders nützlich für Agents, die Zugriff auf eine breite Palette von Plug-Ins oder Tools haben, um sicherzustellen, dass nur kontextbezogene geeignete Aktionen in jedem Schritt berücksichtigt werden.

Verwendungsbeispiel

Im folgenden Beispiel wird veranschaulicht, wie ein Agent für die Verwendung der Kontextfunktionsauswahl konfiguriert werden kann. Der Agent wird eingerichtet, um Kundenrezensionen zusammenzufassen, aber nur die relevantesten Funktionen werden für jeden Aufruf an das KI-Modell beworben. Die GetAvailableFunctions Methode umfasst absichtlich relevante und irrelevante Funktionen, um die Vorteile der kontextbezogenen Auswahl hervorzuheben.

// Create an embedding generator for function vectorization
var embeddingGenerator = new AzureOpenAIClient(new Uri("<endpoint>"), new ApiKeyCredential("<api-key>"))
    .GetEmbeddingClient("<deployment-name>")
    .AsIEmbeddingGenerator();

// Create kernel and register AzureOpenAI chat completion service
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion("<deployment-name>", "<endpoint>", "<api-key>");
    .Build();

// Create a chat completion agent
ChatCompletionAgent agent = new()
{
    Name = "ReviewGuru",
    Instructions = "You are a friendly assistant that summarizes key points and sentiments from customer reviews. For each response, list available functions.",
    Kernel = kernel,
    Arguments = new(new PromptExecutionSettings { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(options: new FunctionChoiceBehaviorOptions { RetainArgumentTypes = true }) }),
    // This setting must be set to true when using the ContextualFunctionProvider
    UseImmutableKernel = true
};

// Create the agent thread and register the contextual function provider
ChatHistoryAgentThread agentThread = new();

agentThread.AIContextProviders.Add(
    new ContextualFunctionProvider(
        vectorStore: new InMemoryVectorStore(new InMemoryVectorStoreOptions() { EmbeddingGenerator = embeddingGenerator }),
        vectorDimensions: 1536,
        functions: AvailableFunctions(),
        maxNumberOfFunctions: 3, // Only the top 3 relevant functions are advertised
        loggerFactory: LoggerFactory
    )
);


// Invoke the agent
ChatMessageContent message = await agent.InvokeAsync("Get and summarize customer review.", agentThread).FirstAsync();
Console.WriteLine(message.Content);

// Output
/*
    Customer Reviews:
    -----------------
    1. John D. - ★★★★★
       Comment: Great product and fast shipping!
       Date: 2023-10-01

    Summary:
    --------
    The reviews indicate high customer satisfaction,
    highlighting product quality and shipping speed.

    Available functions:
    --------------------
    - Tools-GetCustomerReviews
    - Tools-Summarize
    - Tools-CollectSentiments
*/

IReadOnlyList<AIFunction> GetAvailableFunctions()
{
    // Only a few functions are directly related to the prompt; the majority are unrelated to demonstrate the benefits of contextual filtering.
    return new List<AIFunction>
    {
        // Relevant functions
        AIFunctionFactory.Create(() => "[ { 'reviewer': 'John D.', 'date': '2023-10-01', 'rating': 5, 'comment': 'Great product and fast shipping!' } ]", "GetCustomerReviews"),
        AIFunctionFactory.Create((string text) => "Summary generated based on input data: key points include customer satisfaction.", "Summarize"),
        AIFunctionFactory.Create((string text) => "The collected sentiment is mostly positive.", "CollectSentiments"),

        // Irrelevant functions
        AIFunctionFactory.Create(() => "Current weather is sunny.", "GetWeather"),
        AIFunctionFactory.Create(() => "Email sent.", "SendEmail"),
        AIFunctionFactory.Create(() => "The current stock price is $123.45.", "GetStockPrice"),
        AIFunctionFactory.Create(() => "The time is 12:00 PM.", "GetCurrentTime")
    };
}

Vektorspeicher

Der Anbieter ist in erster Linie dafür konzipiert, mit Vektorspeichern im Arbeitsspeicher zu arbeiten, die Einfachheit bieten. Wenn jedoch andere Arten von Vektorspeichern verwendet werden, ist es wichtig zu beachten, dass die Verantwortung für die Verarbeitung von Datensynchronisierung und Konsistenz auf die Hostinganwendung fällt.

Die Synchronisierung ist immer dann erforderlich, wenn sich die Liste der Funktionen ändert oder wenn die Quelle der Funktionseinbettungen geändert wird. Wenn beispielsweise ein Agent zunächst drei Funktionen (f1, f2, f3) aufweist, die in einem Cloudvektorspeicher vektorisiert und gespeichert sind, und später f3 aus der Liste der Funktionen des Agents entfernt wird, muss der Vektorspeicher aktualisiert werden, um nur die aktuellen Funktionen widerzuspiegeln, die der Agent hat (f1 und f2). Fehler beim Aktualisieren des Vektorspeichers können dazu führen, dass irrelevante Funktionen als Ergebnisse zurückgegeben werden. Wenn die daten, die für die Vektorisierung verwendet werden, z. B. Funktionsnamen, Beschreibungen usw., geändert werden, sollte der Vektorspeicher gelöscht und mit neuen Einbettungen basierend auf den aktualisierten Informationen neu aufgefüllt werden.

Die Verwaltung der Datensynchronisierung in externen oder verteilten Vektorspeichern kann komplex und anfällig für Fehler sein, insbesondere in verteilten Anwendungen, in denen verschiedene Dienste oder Instanzen unabhängig ausgeführt werden können und einen konsistenten Zugriff auf dieselben Daten erfordern. Im Gegensatz dazu vereinfacht die Verwendung eines Speichers im Arbeitsspeicher diesen Prozess: Wenn sich die Funktionsliste oder die Vektorisierungsquelle ändert, kann der Speicher im Arbeitsspeicher problemlos mit dem neuen Satz von Funktionen und deren Einbettungen neu erstellt werden, sodass Konsistenz mit minimalem Aufwand gewährleistet wird.

Funktionen festlegen

Der Kontextfunktionsanbieter muss eine Liste von Funktionen bereitstellen, aus denen er die relevantesten Funktionen basierend auf dem aktuellen Kontext auswählen kann. Dazu wird eine Liste der Funktionen für den functions Parameter des ContextualFunctionProvider Konstruktors bereitgestellt.

Zusätzlich zu den Funktionen müssen Sie auch die maximale Anzahl relevanter Funktionen angeben, die mit dem maxNumberOfFunctions Parameter zurückgegeben werden sollen. Dieser Parameter bestimmt, wie viele Funktionen der Anbieter berücksichtigen wird, wenn die relevantesten funktionen für den aktuellen Kontext ausgewählt werden. Die angegebene Zahl soll nicht präzise sein; sie dient vielmehr als Obergrenze, die von dem jeweiligen Szenario abhängt.

Wenn Sie diesen Wert zu niedrig festlegen, kann der Agent möglicherweise daran gehindert werden, auf alle erforderlichen Funktionen für ein Szenario zuzugreifen, was zu einem Szenariofehler führt. Umgekehrt kann das Festlegen zu hoch den Agent mit zu vielen Funktionen überfordern, was zu Halluzinationen, übermäßigem Eingabetokenverbrauch und suboptimaler Leistung führen kann.

// Create the provider with a list of functions and a maximum number of functions to return
ContextualFunctionProvider provider = new (
    vectorStore: new InMemoryVectorStore(new InMemoryVectorStoreOptions { EmbeddingGenerator = embeddingGenerator }),
    vectorDimensions: 1536,
    functions: [AIFunctionFactory.Create((string text) => $"Echo: {text}", "Echo"), <other functions>]
    maxNumberOfFunctions: 3 // Only the top 3 relevant functions are advertised
);

Optionen für Kontextfunktionsanbieter

Der Anbieter kann mithilfe der ContextualFunctionProviderOptions Klasse konfiguriert werden, mit der Sie verschiedene Aspekte der Funktionsweise des Anbieters anpassen können:

// Create options for the contextual function provider
ContextualFunctionProviderOptions options = new ()
{
    ...
};

// Create the provider with options
ContextualFunctionProvider provider = new (
    ...
    options: options // Pass the options
);

Kontextgröße

Die Kontextgröße bestimmt, wie viele kürzlich gesendete Nachrichten aus vorherigen Agentaufrufen in den notwendigen Kontext für einen neuen Aufruf einbezogen werden. Der Anbieter sammelt alle Nachrichten aus vorherigen Aufrufen, bis zur angegebenen Nummer und stellt sie den neuen Nachrichten vor, um den Kontext zu bilden.

Die Verwendung zuletzt verwendeter Nachrichten zusammen mit neuen Nachrichten ist besonders nützlich für Aufgaben, die Informationen aus früheren Schritten in einer Unterhaltung erfordern. Wenn z. B. ein Agent eine Ressource in einem Aufruf bereitstellt und diese im nächsten Schritt einsetzt, kann der Einsatzschritt auf Details des Bereitstellungsschrittes zugreifen, um Informationen über die bereitgestellte Ressource für die Einsatzbereitstellung abzurufen.

Der Standardwert für die Anzahl der neuesten Nachrichten im Kontext ist 2. Dieser kann jedoch bei Bedarf konfiguriert werden, durch Festlegung der NumberOfRecentMessagesInContext Eigenschaft in der ContextualFunctionProviderOptions.

ContextualFunctionProviderOptions options = new ()
{
    NumberOfRecentMessagesInContext = 1 // Only the last message will be included in the context
};

Kontext einbettender Quellwert

Um kontextbezogene Funktionsauswahl durchzuführen, muss der Anbieter den aktuellen Kontext vektorisieren, damit er mit verfügbaren Funktionen im Vektorspeicher verglichen werden kann. Standardmäßig erstellt der Anbieter diese Kontext-Einbettung, indem alle nicht leeren aktuellen und neuen Nachrichten in eine einzige Zeichenfolge verkettet werden, die dann vektorisiert und verwendet wird, um nach relevanten Funktionen zu suchen.

In einigen Szenarien möchten Sie dieses Verhalten möglicherweise wie folgt anpassen:

• Konzentrieren Sie sich auf bestimmte Nachrichtentypen (z. B. nur Benutzernachrichten)
• Ausschließen bestimmter Informationen aus dem Kontext
• Kontext vor der Vektorisierung vorverarbeiten oder zusammenfassen (z. B. promptes Rewriting anwenden)

Zu diesem Zweck können Sie ContextEmbeddingValueProvider einen benutzerdefinierten Stellvertreter zuweisen. Dieser Delegat empfängt die jüngsten und neuen Nachrichten und gibt einen Zeichenfolgenwert zurück, der als Quelle für die Kontext-Einbettung verwendet wird.

ContextualFunctionProviderOptions options = new()
{
    ContextEmbeddingValueProvider = async (recentMessages, newMessages, cancellationToken) =>
    {
        // Example: Only include user messages in the embedding
        var allUserMessages = recentMessages.Concat(newMessages)
            .Where(m => m.Role == "user")
            .Select(m => m.Content)
            .Where(content => !string.IsNullOrWhiteSpace(content));
        return string.Join("\n", allUserMessages);
    }
};

Durch das Anpassen der Kontexteinbettung kann die Relevanz der Funktionsauswahl verbessert werden, insbesondere in komplexen oder hochspezialisierten Agent-Szenarien.

Funktion Einbettung des Quellwerts

Der Anbieter muss jede verfügbare Funktion vektorisieren, um sie mit dem Kontext zu vergleichen und die relevantesten zu markieren. Standardmäßig erstellt der Anbieter eine Funktionseinbettung, indem der Name und die Beschreibung der Funktion in eine einzelne Zeichenfolge verkettet werden, die dann im Vektorspeicher vektorisiert und gespeichert wird.

Sie können dieses Verhalten mithilfe der Eigenschaft EmbeddingValueProvider von ContextualFunctionProviderOptions anpassen. Mit dieser Eigenschaft können Sie einen Rückruf angeben, der die Funktion und ein Abbruchtoken empfängt, und eine Zeichenfolge zurückgibt, die als Quelle für die Einbettung der Funktion verwendet werden soll. Dies ist hilfreich, wenn Sie:

• Hinzufügen zusätzlicher Funktionsmetadaten zur Einbettungsquelle
• Vorverarbeitung, Filtern oder Neuformatieren der Funktionsinformationen vor der Vektorisierung

ContextualFunctionProviderOptions options = new()
{
    EmbeddingValueProvider = async (function, cancellationToken) =>
    {
        // Example: Use only the function name for embedding
        return function.Name;
    }
};

Das Anpassen des Funktionseinbettungsquellwerts kann die Genauigkeit der Funktionsauswahl verbessern, insbesondere, wenn Ihre Funktionen umfangreiche, kontextrelevante Metadaten aufweisen oder wenn Sie die Suche auf bestimmte Aspekte jeder Funktion konzentrieren möchten.

Nächste Schritte

Erkunden der Auswahlbeispiele für kontextbezogene Funktionen

Bald verfügbar

Weitere Informationen werden in Kürze verfügbar sein.

Bald verfügbar

Weitere Informationen werden in Kürze verfügbar sein.