Környezetfüggő függvény kiválasztása ügynökökkel

Áttekintés

A környezetfüggő függvények kiválasztása a Szemantikus kernelügynök-keretrendszer speciális képessége, amely lehetővé teszi az ügynökök számára, hogy csak a legrelevánsabb függvényeket jelölik ki és hirdetik meg az aktuális beszélgetési környezet alapján. Ahelyett, hogy az AI-modell számára az összes elérhető függvényt kiteszi, ez a funkció Retrieval-Augmented generációs (RAG) használatával szűri és csak a felhasználó kéréséhez leginkább illő függvényeket jeleníti meg.

Ez a megközelítés a függvények sokaságából való kiválasztás kihívását célozza meg, amely különösen nagy számú rendelkezésre álló függvény esetében jelentkezik, ahol az AI-modellek nehezen választják ki a megfelelő függvényt, ami zavart okoz és alulteljesítést eredményez.

A környezetfüggő függvények kiválasztásának működése

Ha egy ügynök konfigurálva van a környezetfüggő függvény kiválasztásával, egy vektortárolót és egy beágyazási generátort használ, hogy szemantikailag egyezzen az aktuális beszélgetési környezettel (beleértve a korábbi üzeneteket és a felhasználói bevitelt) az elérhető függvények leírásával és nevével. A leginkább releváns függvényeket a megadott korlátig a rendszer meghívja az AI-modellben.

Ez a mechanizmus különösen hasznos az olyan ügynökök számára, amelyek számos beépülő modulhoz vagy eszközhöz rendelkeznek hozzáféréssel, biztosítva, hogy minden lépésnél csak a környezetfüggően megfelelő műveletek legyenek figyelembe véve.

Használati példa

Az alábbi példa bemutatja, hogyan konfigurálható egy ügynök a környezetfüggő függvények kiválasztására. Az ügynök úgy van beállítva, hogy összegezze az ügyfélértékeléseket, de az egyes meghívásokhoz csak a leginkább releváns funkciók vannak bemutatva az AI-modell számára. A GetAvailableFunctions módszer szándékosan tartalmaz releváns és irreleváns függvényeket is, hogy kiemelje a környezetfüggő kiválasztás előnyeit.

// 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")
    };
}

Vektortároló

A szolgáltató elsősorban a memóriabeli vektortárolók használatához készült, amelyek egyszerűséget kínálnak. Más típusú vektortárolók használata esetén azonban fontos megjegyezni, hogy az adatszinkronizálás és a konzisztencia kezelésének felelőssége az üzemeltetési alkalmazásra hárul.

Szinkronizálásra akkor van szükség, ha a függvények listája megváltozik, vagy ha a függvénybeágyazások forrását módosítják. Ha például egy ügynök kezdetben három függvényt (f1, f2, f3) tartalmaz, amelyek vektorizáltak és egy felhővektortárolóban vannak tárolva, és később az f3 el lesz távolítva az ügynök függvénylistájából, a vektortárat frissíteni kell, hogy csak az ügynök aktuális függvényeit tükrözze (f1 és f2). A vektortároló frissítésének elmulasztása irreleváns függvények eredményként való visszaadásához vezethet. Hasonlóképpen, ha a vektorizáláshoz használt adatok, például a függvénynevek, leírások stb. megváltoznak, a vektortárat a frissített információk alapján új beágyazásokkal kell kiüríteni és újra feltölteni.

Az adatszinkronizálás kezelése külső vagy elosztott vektortárolókban összetett és hibákra hajlamos lehet, különösen olyan elosztott alkalmazásokban, ahol a különböző szolgáltatások vagy példányok egymástól függetlenül működnek, és konzisztens hozzáférést igényelnek ugyanahhoz az adatokhoz. Ezzel szemben a memóriabeli tároló használata leegyszerűsíti ezt a folyamatot: ha a függvénylista vagy a vektorizálási forrás megváltozik, a memóriabeli tároló egyszerűen újra létrehozható az új függvénykészlettel és azok beágyazásával, így minimális erőfeszítéssel konzisztenciát biztosít.

Függvények megadása

A környezetfüggő függvényszolgáltatónak rendelkeznie kell azon függvények listájával, amelyek közül az aktuális környezet alapján kiválaszthatja a legrelevánsabbakat. Ez a konstruktor paraméteréhez functions tartozó függvények ContextualFunctionProvider listájának megadásával érhető el.

A függvények mellett meg kell adnia a paraméterrel maxNumberOfFunctions visszaadandó releváns függvények maximális számát is. Ez a paraméter határozza meg, hogy a szolgáltató hány függvényt fog figyelembe venni az aktuális környezet szempontjából leginkább relevánsak kiválasztásakor. A megadott szám nem pontos; inkább az adott forgatókönyvtől függő felső korlátként szolgál.

Ha ezt az értéket túl alacsonyra állítja, az megakadályozhatja, hogy az ügynök hozzáférjen egy forgatókönyv összes szükséges függvényéhez, ami a forgatókönyv meghibásodásához vezethet. Ezzel szemben a túl magas beállítás túl sok funkcióval terhelheti az ügynököt, ami hallucinációkat, túlzott bemeneti jogkivonat-használatot és optimálisnál rosszabb teljesítményt eredményezhet.

// 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
);

Környezeti függvényszolgáltató beállításai

A szolgáltató konfigurálható az ContextualFunctionProviderOptions osztály használatával, amely lehetővé teszi a szolgáltató működésének különböző aspektusainak testreszabását:

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

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

Kontextus mérete

A környezet mérete határozza meg, hogy az új meghívás környezetének kialakításakor hány legutóbbi üzenet szerepel az előző ügynökhívásokból. A szolgáltató összegyűjti a korábbi meghívások összes üzenetét a megadott számig, és előküldi őket az új üzenetekre a környezet kialakításához.

A legutóbbi üzenetek és az új üzenetek együttes használata különösen hasznos azokhoz a feladatokhoz, amelyek a beszélgetés korábbi lépéseiből származó információkat igényelnek. Ha például egy ügynök kiépít egy erőforrást egy meghívásban, és a következőben helyezi üzembe, az üzembe helyezési lépés a kiépítési lépés részleteihez férhet hozzá, hogy lekérje az üzembe helyezéshez kiosztott erőforrás-információkat.

A környezetben lévő legutóbbi üzenetek számának alapértelmezett értéke 2, de ezt igény szerint konfigurálhatja a NumberOfRecentMessagesInContext következő tulajdonság ContextualFunctionProviderOptionsmegadásával:

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

Kontextusba beágyazott forrásérték

A környezetfüggő függvény kiválasztásához a szolgáltatónak vektorizálnia kell az aktuális környezetet, hogy össze lehessen hasonlítani a vektortárolóban elérhető függvényekkel. A szolgáltató alapértelmezés szerint úgy hozza létre ezt a környezetbe ágyazott környezetet, hogy az összes nem üres legutóbbi és új üzenetet egyetlen sztringbe fűzi össze, amelyet ezután vektorizál, és a megfelelő függvények keresésére szolgál.

Bizonyos esetekben érdemes lehet a következő módon testre szabni ezt a viselkedést:

• Fókusz adott üzenettípusokra (például csak felhasználói üzenetekre)
• Bizonyos információk kizárása a szövegkörnyezetből
• A környezet előfeldolgozása vagy összegzése a vektorizálás előtt (például parancssori újraírás alkalmazása)

Ehhez egyéni meghatalmazottat rendelhet hozzá ContextEmbeddingValueProvider. Ez a meghatalmazott megkapja a legutóbbi és az új üzeneteket, és visszaad egy sztringértéket, amelyet forrásként használ a környezetbe ágyazáshoz:

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);
    }
};

A környezetbe ágyazás testreszabása javíthatja a függvények kiválasztásának relevanciáját, különösen összetett vagy magas specializált ügynökforgatókönyvekben.

Függvénybeágyazási forrásérték

A szolgáltatónak vektorizálnia kell az egyes elérhető függvényeket, hogy összehasonlíthassa a környezettel, és kiválaszthassa a leginkább releváns függvényeket. Alapértelmezés szerint a szolgáltató létrehoz egy beágyazási függvényt úgy, hogy a függvény nevét és leírását egyetlen sztringbe összefűzi, majd vektorizálja és tárolja a vektortárolóban.

Ezt a viselkedést a EmbeddingValueProvider következő tulajdonság ContextualFunctionProviderOptionshasználatával szabhatja testre: . Ez a tulajdonság lehetővé teszi egy visszahívás megadását, amely megkapja a függvényt és a törlési tokent, és visszaad egy sztringet, amely forrásként szolgál majd a függvény beágyazásához. Ez a következő esetekben hasznos:

• További függvény metaadatainak hozzáadása a beágyazási forráshoz
• A függvényinformációk előfeldolgozása, szűrése vagy újraformálása vektorosítás előtt

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

A függvénybeágyazási forrásérték testreszabása javíthatja a függvények kiválasztásának pontosságát, különösen akkor, ha a függvények gazdag, környezetfüggő metaadatokkal rendelkeznek, vagy ha az egyes függvények adott aspektusaira szeretné összpontosítani a keresést.

Következő lépések

A környezetfüggő függvények kijelölési mintáinak megismerése

Hamarosan elérhető

Hamarosan további információk is érkeznek.

Hamarosan elérhető

Hamarosan további információk is érkeznek.