Filtr vyvolaných funkcí

Dokončeno

Filtry v sémantickém jádru umožňují vývojářům spravovat a zabezpečit spouštění funkcí tím, že umožňují jemně odstupňované řízení a viditelnost. Slouží k vytváření zodpovědných řešení AI, která splňují podnikové standardy. Filtry ověřují akce, jako jsou uživatelská oprávnění nebo úpravy interakcí s modely AI, aby se zajistilo dodržování předpisů a spolehlivost.

Typy filtrů

Sémantické jádro nabízí tři typy filtrů, které zlepšují kontrolu a přizpůsobení: Filtry volání funkcí pro správu provádění funkcí, filtry vykreslování výzvy pro úpravy výzev před odesláním a filtry automatického vyvolání funkcí pro směrování vícekrokových pracovních postupů. Každý typ filtru řeší konkrétní potřeby, což vývojářům umožňuje vytvářet zabezpečená a přizpůsobitelná řešení AI.

Filtr vyvolání funkce

Tento filtr se spustí při každém spuštění funkce, ať už pochází z výzvy nebo je implementovaný v jazyce C#. Mezi její možnosti patří:

• Přístup k metadatům o funkci a jejích argumentech
• Protokolování nebo ověřování akcí před a po spuštění
• Přepsat výsledky nebo opakovat operace s využitím alternativních modelů umělé inteligence.

Tady je příklad filtru vyvolání funkce, který protokoluje vyvolánou funkci modulu plug-in:

public sealed class LoggingFilter(ILogger logger) : IFunctionInvocationFilter
{
    public async Task OnFunctionInvocationAsync(FunctionInvocationContext context, Func<FunctionInvocationContext, Task> next)
    {
        logger.LogInformation("Invoking: {PluginName}.{FunctionName}", context.Function.PluginName, context.Function.Name);

        await next(context);

        logger.LogInformation("Executed: {PluginName}.{FunctionName}", context.Function.PluginName, context.Function.Name);
    }
}

# Python example: Function invocation filter using a decorator

from semantic_kernel.functions.kernel_function_decorator import kernel_function

def logging_filter(func):
    def wrapper(*args, **kwargs):
        print(f"Invoking: {func.__qualname__}")
        result = func(*args, **kwargs)
        print(f"Executed: {func.__qualname__}")
        return result
    return wrapper

class WeatherForecastUtils:
    @kernel_function(name="GetWeatherForCity", description="Gets the weather for a given city.")
    @logging_filter
    def get_weather_for_city(self, city: str) -> str:
        return "Sunny"

Filtr vykreslování podnětů

Tento filtr se aktivuje při vykreslování výzvy, který poskytuje kontrolu nad formátováním a odesláním výzev do AI. Je ideální pro úlohy, jako je úprava výzev k citlivým informacím (např. redakce PII) nebo povolení sémantického ukládání do mezipaměti.

Tady je příklad filtru vykreslování promptu:

public class SafePromptFilter : IPromptRenderFilter
{
    public async Task OnPromptRenderAsync(PromptRenderContext context, Func<PromptRenderContext, Task> next)
    {
        await next(context);

        // Modify prompt before submission
        context.RenderedPrompt = "Safe and sanitized prompt.";
    }
}

# Python example: Prompt render filter using a decorator

def safe_prompt_filter(render_func):
    def wrapper(*args, **kwargs):
        prompt = render_func(*args, **kwargs)
        # Modify prompt before submission
        return "Safe and sanitized prompt."
    return wrapper

@safe_prompt_filter
def render_prompt(user_input):
    return f"User prompt: {user_input}"

# Example usage
print(render_prompt("Sensitive information here"))

Filtr automatického vyvolání funkce

Tento filtr se vyvolá pouze během procesu automatického volání funkce. Může upravit nebo dokonce ukončit pracovní postupy na základě průběžných výsledků.

Tady je příklad filtru volání funkce, který ukončuje proces volání funkce:

public sealed class EarlyTerminationFilter : IAutoFunctionInvocationFilter
{
    public async Task OnAutoFunctionInvocationAsync(AutoFunctionInvocationContext context, Func<AutoFunctionInvocationContext, Task> next)
    {
        await next(context);

        var result = context.Result.GetValue<string>();
        if (result == "desired result")
        {
            context.Terminate = true;
        }
    }
}

# Python example: Auto function invocation filter using a decorator

def early_termination_filter(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        # Simulate checking the result and terminating if needed
        if result == "desired result":
            print("Terminating workflow early.")
            return result
        return result
    return wrapper

@early_termination_filter
def auto_function():
    # Simulate function logic
    return "desired result"

# Example usage
auto_function()

Integrace filtrů funkcí

K integraci některého z filtrů funkcí můžete použít následující metody:

• Vkládání závislostí:

Přidejte funkci do služeb KernelBuilder:

builder.Services.AddSingleton<IFunctionInvocationFilter, LoggingFilter>();

• vlastnosti jádra :

Přidejte funkci do seznamu FunctionInvocationFilters jádra:

kernel.FunctionInvocationFilters.Add(new LoggingFilter(logger));

Pro integraci filtrů v Pythonu aplikujte dekorátory na metody pluginu nebo vykreslovací funkce, jak je uvedeno výše.
Zaregistrujte třídu plug-inu s jádrem jako obvykle:

kernel.add_plugin(WeatherForecastUtils(), "WeatherForecastUtils")

Dekorované metody budou mít logiku filtru automaticky použitou.

Vždy vyvolejte delegáta next ve vašem filtru funkce, aby následné filtry nebo primární operace mohly být provedeny. Přeskočení tohoto kroku zablokuje operaci.

Integrací filtrů vykreslování promptů zajistíte, že budou řešení sémantického jádra bezpečnější a spolehlivější. Filtry pro výzvy umožňují vyčistit výzvy před tím, než se dostanou k umělé inteligenci. Filtry automatického vyvolání umožňují řídit spouštění funkcí, což umožňuje předčasné ukončení nebo vlastní logiku na základě výsledků.