Sdílet prostřednictvím

Konfigurace agentů pomocí plug-inů sémantického jádra

Důležité

Tato funkce je ve fázi před vydáním. Funkce v této fázi jsou téměř dokončené a obecně stabilní, i když mohou před dosažením úplné obecné dostupnosti projít menší vylepšení nebo optimalizace.

Funkce a moduly plug-in v sémantickém jádru

Volání funkcí je výkonný nástroj, který vývojářům umožňuje přidávat vlastní funkce a rozšiřovat možnosti aplikací AI. Architektura modulu plug-in sémantického jádra nabízí flexibilní architekturu pro podporu volání funkcí. AgentIntegrace pluginů a volání funkcí je postavená na této základní funkci Semantic Kernel.

Po nakonfigurování agent zvolí, kdy a jak volat dostupnou funkci, stejně jako při jakémkoli použití mimo .Agent Framework

Návod

Referenční informace k rozhraní API:

Návod

Referenční informace k rozhraní API:

Návod

Referenční informace k rozhraní API:

Přidání modulů plug-in do agenta

Každý plugin, který je dostupný pro Agent, je spravován ve své příslušné Kernel instanci. Toto nastavení umožňuje každému Agent přístup k odlišným funkcím na základě jeho konkrétní role.

Pluginy je možné přidat do Kernel buď před nebo po vytvoření Agent. Proces inicializace modulů plug-in se řídí stejnými vzory používanými pro jakoukoli implementaci sémantického jádra, což umožňuje konzistenci a snadné použití při správě funkcí AI.

Poznámka:

ChatCompletionAgentV případě funkce musí být režim volání funkce explicitně povolený. OpenAIAssistant agent je vždy založen na automatickém volání funkcí.

// Factory method to produce an agent with a specific role.
// Could be incorporated into DI initialization.
ChatCompletionAgent CreateSpecificAgent(Kernel kernel, string credentials)
{
    // Clone kernel instance to allow for agent specific plug-in definition
    Kernel agentKernel = kernel.Clone();

    // Import plug-in from type
    agentKernel.ImportPluginFromType<StatelessPlugin>();

    // Import plug-in from object
    agentKernel.ImportPluginFromObject(new StatefulPlugin(credentials));

    // Create the agent
    return
        new ChatCompletionAgent()
        {
            Name = "<agent name>",
            Instructions = "<agent instructions>",
            Kernel = agentKernel,
            Arguments = new KernelArguments(
                new OpenAIPromptExecutionSettings()
                {
                    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
                })
        };
}

Jsou dva způsoby, jak vytvořit ChatCompletionAgent s pluginy.

Metoda 1: Určení modulů plug-in prostřednictvím konstruktoru

Konstruktoru můžete přímo předat seznam modulů plug-in:

from semantic_kernel.agents import ChatCompletionAgent

# Create the Chat Completion Agent instance by specifying a list of plugins
agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    instructions="<instructions>",
    plugins=[SamplePlugin()]
)

Návod

Ve výchozím nastavení je povolené automatické volání funkcí. Chcete-li jej zakázat, nastavte argument function_choice_behavior na function_choice_behavior=FunctionChoiceBehavior.Auto(auto_invoke=False) v konstruktoru. S tímto nastavením jsou plug-in moduly vysílány do modelu, ale nejsou vyvolány automaticky. Pokud nastavení provádění určuje stejné service_id nebo ai_model_id jako konfigurace služby AI, bude mít přednost chování volání funkce definované v nastavení spouštění (prostřednictvím KernelArguments) před chováním funkce nastavené v konstruktoru.

Metoda 2: Ruční konfigurace jádra

Pokud není prostřednictvím konstruktoru k dispozici žádné jádro, vytvoří se během ověřování modelu automaticky. Jakékoli pluginy, které jsou předány, mají přednost a přidají se do jádra. Pokud chcete jemněji odstupňovanou kontrolu nad stavem jádra, postupujte takto:

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.functions import KernelFunctionFromPrompt
from semantic_kernel.kernel import Kernel

# Create the instance of the Kernel
kernel = Kernel()

# Add the chat completion service to the Kernel
kernel.add_service(AzureChatCompletion())

# Get the AI Service settings
settings = kernel.get_prompt_execution_settings_from_service_id()

# Configure the function choice behavior to auto invoke kernel functions
settings.function_choice_behavior = FunctionChoiceBehavior.Auto()

# Add the Plugin to the Kernel
kernel.add_plugin(SamplePlugin(), plugin_name="<plugin name>")

# Create the agent
agent = ChatCompletionAgent(
    kernel=kernel,
    name=<agent name>,
    instructions=<agent instructions>,
    arguments=KernelArguments(settings=settings),
)

Návod

service_id Pokud není zadán při přidávání služby do jádra, použije se výchozí hodnota default. Při konfiguraci více služeb AI v jádru se doporučuje je odlišit pomocí argumentu service_id . To vám umožní načíst nastavení spuštění pro konkrétní service_id a svázat tato nastavení s požadovanou službou.

var chatCompletion = OpenAIChatCompletion.builder()
    .withModelId("<model-id>")
    .withOpenAIAsyncClient(new OpenAIClientBuilder()
            .credential(new AzureKeyCredential("<api-key>"))
            .endpoint("<endpoint>")
            .buildAsyncClient())
    .build();

Kernel kernel = Kernel.builder()
    .withAIService(ChatCompletionService.class, chatCompletion)
    .withPlugin(KernelPluginFactory.createFromObject(new SamplePlugin(), "<plugin name>"))
    .build();

var agent = ChatCompletionAgent.builder()
    .withKernel(kernel)
    .withName("<agent name>")
    .withInstructions("<agent instructions>")
    .build();

Přidání funkcí do agenta

Modul plug-in je nejběžnějším přístupem ke konfiguraci volání funkcí. Jednotlivé funkce je ale možné zadat i nezávisle na sobě, včetně promptovacích funkcí.

// Factory method to product an agent with a specific role.
// Could be incorporated into DI initialization.
ChatCompletionAgent CreateSpecificAgent(Kernel kernel)
{
    // Clone kernel instance to allow for agent specific plug-in definition
    Kernel agentKernel = kernel.Clone();

    // Create plug-in from a static function
    var functionFromMethod = agentKernel.CreateFunctionFromMethod(StatelessPlugin.AStaticMethod);

    // Create plug-in from a prompt
    var functionFromPrompt = agentKernel.CreateFunctionFromPrompt("<your prompt instructions>");

    // Add to the kernel
    agentKernel.ImportPluginFromFunctions("my_plugin", [functionFromMethod, functionFromPrompt]);

    // Create the agent
    return
        new ChatCompletionAgent()
        {
            Name = "<agent name>",
            Instructions = "<agent instructions>",
            Kernel = agentKernel,
            Arguments = new KernelArguments(
                new OpenAIPromptExecutionSettings()
                {
                    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
                })
        };
}

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.functions import KernelFunctionFromPrompt
from semantic_kernel.kernel import Kernel

# Create the instance of the Kernel
kernel = Kernel()

# Add the chat completion service to the Kernel
kernel.add_service(AzureChatCompletion())

# Create the AI Service settings
settings = AzureChatPromptExecutionSettings()

# Configure the function choice behavior to auto invoke kernel functions
settings.function_choice_behavior = FunctionChoiceBehavior.Auto()

# Add the Plugin to the Kernel
kernel.add_function(
    plugin_name="<plugin_name>",
    function=KernelFunctionFromPrompt(
        function_name="<function_name>",
        prompt="<your prompt instructions>",
    )
)

# Create the agent
agent = ChatCompletionAgent(
    kernel=kernel,
    name=<agent name>,
    instructions=<agent instructions>,
    arguments=KernelArguments(settings=settings),
)

var chatCompletion = OpenAIChatCompletion.builder()
    .withModelId("<model-id>")
    .withOpenAIAsyncClient(new OpenAIClientBuilder()
            .credential(new AzureKeyCredential("<api-key>"))
            .endpoint("<endpoint>")
            .buildAsyncClient())
    .build();

// Create function from method
var functionFromMethod = KernelFunction.createFromMethod(SamplePlugin.class.getMethod("method"), new SamplePlugin());

// Create function from prompt
var functionFromPrompt = KernelFunction.createFromPrompt("<your prompt instructions>");

// Create the kernel with a plugin from the two functions
Kernel kernel = Kernel.builder()
    .withAIService(ChatCompletionService.class, chatCompletion)
    .withPlugin(KernelPluginFactory.createFromFunctions("SamplePlugin", List.of(functionFromMethod, functionFromPrompt)))
    .build();

InvocationContext invocationContext = InvocationContext.builder()
    .withFunctionChoiceBehavior(FunctionChoiceBehavior.auto(true))
    .build();

// Create the agent
var agent = ChatCompletionAgent.builder()
    .withKernel(kernel)
    .withName("<agent name>")
    .withInstructions("<agent instructions>")
    .withInvocationContext(invocationContext)
    .build();

Omezení při používání funkcí agenta

Při přímém voláníChatCompletionAgent jsou podporována všechna chování výběru funkce. Při použití funkce OpenAIAssistantje však aktuálně k dispozici pouze automatické volání funkcí .

Postupy

Kompletní příklad použití volání funkcí viz:

Další kroky

Jak streamovat odpovědi agenta

  • Last updated on