Dela via

Kontextuell funktionsval med agenter

Viktigt!

Den här funktionen är i den experimentella fasen. Funktionerna i det här skedet är under aktiv utveckling och kan ändras avsevärt innan de går vidare till förhandsversionen eller lanseringsfasen.

Översikt

Val av kontextuell funktion är en avancerad funktion i Semantic Kernel Agent Framework som gör det möjligt för agenter att dynamiskt välja och annonsera endast de mest relevanta funktionerna baserat på den aktuella konversationskontexten. I stället för att exponera alla tillgängliga funktioner för AI-modellen använder den här funktionen Retrieval-Augmented Generation (RAG) för att filtrera och endast presentera de funktioner som är mest relevanta för användarens begäran.

Den här metoden hanterar utmaningen med funktionsval när du hanterar ett stort antal tillgängliga funktioner, där AI-modeller annars kan ha svårt att välja lämplig funktion, vilket leder till förvirring och suboptimal prestanda.

Så här fungerar sammanhangsberoende funktionsval

När en agent konfigureras med sammanhangsberoende funktionsval utnyttjar den ett vektorlager och en inbäddningsgenerator för att semantiskt matcha den aktuella konversationskontexten (inklusive tidigare meddelanden och användarindata) med beskrivningarna och namnen på tillgängliga funktioner. De mest relevanta funktionerna, upp till den angivna gränsen, annonseras sedan till AI-modellen för anrop.

Den här mekanismen är särskilt användbar för agenter som har åtkomst till en bred uppsättning plugin-program eller verktyg, vilket säkerställer att endast kontextuellt lämpliga åtgärder beaktas i varje steg.

Användningsexempel

I följande exempel visas hur en agent kan konfigureras för att använda sammanhangsberoende funktionsval. Agenten har konfigurerats för att sammanfatta kundrecensioner, men endast de mest relevanta funktionerna annonseras till AI-modellen för varje anrop. Metoden GetAvailableFunctions innehåller avsiktligt både relevanta och irrelevanta funktioner för att belysa fördelarna med sammanhangsberoende urval.

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

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

Vektorlager

Providern är främst utformad för att fungera med minnesbaserade vektorlager, vilket erbjuder enkelhet. Men om andra typer av vektorlager används är det viktigt att observera att ansvaret för att hantera datasynkronisering och konsekvens ligger på värdprogrammet.

Synkronisering krävs när listan över funktioner ändras eller när källan för inbäddning av funktioner ändras. Om en agent till exempel ursprungligen har tre funktioner (f1, f2, f3) som är vektoriserade och lagrade i ett molnvektorlager och senare f3 tas bort från agentens lista över funktioner, måste vektorarkivet uppdateras för att endast återspegla de aktuella funktioner som agenten har (f1 och f2). Om det inte går att uppdatera vektorlagret kan det leda till att irrelevanta funktioner returneras som resultat. Om data som används för vektorisering, till exempel funktionsnamn, beskrivningar osv. ändras, bör vektorlagret rensas och fyllas i igen med nya inbäddningar baserat på den uppdaterade informationen.

Att hantera datasynkronisering i externa eller distribuerade vektorlager kan vara komplext och felbenäget, särskilt i distribuerade program där olika tjänster eller instanser kan fungera oberoende av varandra och kräver konsekvent åtkomst till samma data. Att använda ett minnesinternt arkiv förenklar däremot den här processen: när funktionslistan eller vektoriseringskällan ändras kan det minnesinterna arkivet enkelt återskapas med den nya uppsättningen funktioner och deras inbäddningar, vilket ger konsekvens med minimal ansträngning.

Ange funktioner

Den kontextuella funktionsprovidern måste anges med en lista över funktioner som den kan välja de mest relevanta från baserat på den aktuella kontexten. Detta uppnås genom att tillhandahålla en lista över funktioner till parametern functions för ContextualFunctionProvider konstruktorn.

Förutom funktionerna måste du också ange det maximala antalet relevanta funktioner som ska returneras med hjälp av parametern maxNumberOfFunctions . Den här parametern avgör hur många funktioner providern ska tänka på när du väljer de mest relevanta funktionerna för den aktuella kontexten. Det angivna talet är inte avsett att vara exakt. I stället fungerar den som en övre gräns som är beroende av det specifika scenariot.

Om du anger det här värdet för lågt kan agenten inte komma åt alla nödvändiga funktioner för ett scenario, vilket kan leda till scenariofelet. Omvänt kan inställningen för hög överbelasta agenten med för många funktioner, vilket kan resultera i hallucinationer, överdriven indatatokenförbrukning och suboptimal prestanda.

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

Alternativ för kontextbaserad funktionstjänstleverantör

Providern kan konfigureras med hjälp av ContextualFunctionProviderOptions klassen, vilket gör att du kan anpassa olika aspekter av hur providern fungerar:

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

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

Kontextstorlek

Kontextstorleken avgör hur många senaste meddelanden från tidigare agentanrop som ingår när kontexten skapas för ett nytt anrop. Providern samlar in alla meddelanden från tidigare anrop, upp till det angivna numret, och förbereder dem till de nya meddelandena för att bilda kontexten.

Att använda de senaste meddelandena tillsammans med nya meddelanden är särskilt användbart för uppgifter som kräver information från tidigare steg i en konversation. Om en agent till exempel etablerar en resurs i ett anrop och distribuerar den i nästa, kan distributionssteget komma åt information från etableringssteget för att hämta etablerad resursinformation för distributionen.

Standardvärdet för antalet senaste meddelanden i kontexten är 2, men det kan konfigureras efter behov genom att NumberOfRecentMessagesInContext ange egenskapen i ContextualFunctionProviderOptions:

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

Källvärde för kontextbäddning

För att utföra sammanhangsberoende funktionsval måste providern vektorisera den aktuella kontexten så att den kan jämföras med tillgängliga funktioner i vektorlagret. Som standard skapar providern den här kontextinbäddningen genom att sammanfoga alla icke-tomma senaste och nya meddelanden i en enda sträng, som sedan vektoriseras och används för att söka efter relevanta funktioner.

I vissa scenarier kanske du vill anpassa det här beteendet till:

  • Fokusera på specifika meddelandetyper (t.ex. endast användarmeddelanden)
  • Undanta viss information från kontexten
  • Förbearbeta eller sammanfatta kontexten före vektorisering (t.ex. tillämpa omformulering av uppmaning)

För att göra detta kan du tilldela ett anpassat ombud till ContextEmbeddingValueProvider. Det här ombudet tar emot de senaste och nya meddelandena och returnerar ett strängvärde som ska användas som källa för kontextens inbäddning:

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

Anpassning av kontextens inbäddning kan förbättra relevansen för funktionsval, särskilt i komplexa eller mycket specialiserade agentscenarier.

Källvärde för inbäddning av funktion

Providern måste vektorisera varje tillgänglig funktion för att kunna jämföra den med kontexten och välja de mest relevanta. Som standard skapar providern en funktionsbäddning genom att sammanfoga funktionens namn och beskrivning i en enda sträng, som sedan vektoriseras och lagras i vektorlagret.

Du kan anpassa det här beteendet med egenskapen EmbeddingValueProviderContextualFunctionProviderOptions. Med den här egenskapen kan du ange ett återanrop som tar emot funktionen och en annulleringstoken och returnerar en sträng som ska användas som källa för funktionsinbäddningen. Detta är användbart om du vill:

  • Lägga till ytterligare funktionsmetadata i inbäddningskällan
  • Förbearbeta, filtrera eller formatera om funktionsinformationen före vektorisering
ContextualFunctionProviderOptions options = new()
{
    EmbeddingValueProvider = async (function, cancellationToken) =>
    {
        // Example: Use only the function name for embedding
        return function.Name;
    }
};

Om du anpassar funktionens inbäddningsvärde kan du förbättra noggrannheten för funktionsval, särskilt när dina funktioner har omfattande, kontextreleventa metadata eller när du vill fokusera sökningen på specifika aspekter av varje funktion.

Nästa steg

Utforska urvalsexemplen för kontextuell funktion

Kommer snart

Mer information kommer snart.

Kommer snart

Mer information kommer snart.