Compartilhar via

Criar um agente com base em um modelo de kernel semântico

Modelos de comandos no Kernel Semântico

O papel de um agente é moldado principalmente pelas instruções que recebe, que ditam seu comportamento e ações. Semelhante à chamada de um Kernelprompt, as instruções de um agente podem incluir parâmetros de modelo — valores e funções — que são substituídos dinamicamente durante a execução. Isso permite respostas flexíveis e sensíveis ao contexto, permitindo que o agente ajuste sua saída com base na entrada em tempo real.

Além disso, um agente pode ser configurado diretamente usando uma Configuração de Modelo de Prompt, fornecendo aos desenvolvedores uma maneira estruturada e reutilizável de definir seu comportamento. Essa abordagem oferece uma ferramenta poderosa para padronizar e personalizar as instruções do agente, garantindo consistência em vários casos de uso e, ao mesmo tempo, mantendo a adaptabilidade dinâmica.

Dica

Referência de API:

Dica

Referência de API:

Recurso atualmente indisponível em Java.

Instruções do agente como modelo

A criação de um agente com parâmetros de modelo oferece maior flexibilidade, permitindo que suas instruções sejam facilmente personalizadas com base em diferentes cenários ou requisitos. Essa abordagem permite que o comportamento do agente seja adaptado substituindo valores ou funções específicas no modelo, tornando-o adaptável a uma variedade de tarefas ou contextos. Ao aproveitar os parâmetros do modelo, os desenvolvedores podem projetar agentes mais versáteis que podem ser configurados para atender a diversos casos de uso sem a necessidade de modificar a lógica principal.

Agente de conclusão de bate-papo

// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;

var instructions = "Tell a story about {{$topic}} that is {{$length}} sentences long.";

ChatCompletionAgent agent =
    new(templateFactory: new KernelPromptTemplateFactory(),
        templateConfig: new(instructions) { TemplateFormat = PromptTemplateConfig.SemanticKernelTemplateFormat })
    {
        Kernel = kernel,
        Name = "StoryTeller",
        Arguments = new KernelArguments()
        {
            { "topic", "Dog" },
            { "length", "3" },
        }
    };

agent = ChatCompletionAgent(
    service=AzureChatCompletion(), # or other supported AI Services
    name="StoryTeller",
    instructions="Tell a story about {{$topic}} that is {{$length}} sentences long.",
    arguments=KernelArguments(topic="Dog", length="2"),
)

Recurso atualmente indisponível em Java.

Agente Assistente do OpenAI

Instruções modeladas são especialmente poderosas ao trabalhar com um OpenAIAssistantAgent. Com essa abordagem, uma única definição de assistente pode ser criada e reutilizada várias vezes, cada vez com diferentes valores de parâmetro adaptados a tarefas ou contextos específicos. Isso possibilita uma configuração mais eficiente, permitindo que o mesmo framework de assistente lida com uma ampla variedade de cenários, mantendo a consistência em seu comportamento principal.

// Retrieve an existing assistant definition by identifier
AzureOpenAIClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(new AzureCliCredential(), new Uri("<your endpoint>"));
AssistantClient assistantClient = client.GetAssistantClient();
Assistant assistant = await client.GetAssistantAsync();
OpenAIAssistantAgent agent = new(assistant, assistantClient, new KernelPromptTemplateFactory(), PromptTemplateConfig.SemanticKernelTemplateFormat)
{
    Arguments = new KernelArguments()
    {
        { "topic", "Dog" },
        { "length", "3" },
    }
}

# Create the client using Azure OpenAI resources and configuration
client, model = AzureAssistantAgent.setup_resources()

# Retrieve the assistant definition from the server based on the assistant ID
definition = await client.beta.assistants.retrieve(
    assistant_id="your-assistant-id",
)

# Create the AzureAssistantAgent instance using the client and the assistant definition
agent = AzureAssistantAgent(
    client=client,
    definition=definition,
    arguments=KernelArguments(topic="Dog", length="3"),
)

Recurso atualmente indisponível em Java.

Definição de agente a partir de um modelo de prompt

A mesma configuração de modelo de prompt usada para criar uma Função de Prompt do Kernel também pode ser utilizada para definir um agente. Isso permite uma abordagem unificada no gerenciamento dos prompts e agentes, promovendo consistência e reutilização em diferentes componentes. Ao externalizar as definições de agente da base de código, esse método simplifica o gerenciamento de vários agentes, tornando-os mais fáceis de atualizar e manter sem exigir alterações na lógica subjacente. Essa separação também aumenta a flexibilidade, permitindo que os desenvolvedores modifiquem o comportamento do agente ou introduzam novos agentes simplesmente atualizando a configuração, em vez de ajustar o código em si.

Modelo YAML

name: GenerateStory
template: |
  Tell a story about {{$topic}} that is {{$length}} sentences long.
template_format: semantic-kernel
description: A function that generates a story about a topic.
input_variables:
  - name: topic
    description: The topic of the story.
    is_required: true
  - name: length
    description: The number of sentences in the story.
    is_required: true

Inicialização do agente

// Read YAML resource
string generateStoryYaml = File.ReadAllText("./GenerateStory.yaml");
// Convert to a prompt template config
PromptTemplateConfig templateConfig = KernelFunctionYaml.ToPromptTemplateConfig(generateStoryYaml);

// Create agent with Instructions, Name and Description
// provided by the template config.
ChatCompletionAgent agent =
    new(templateConfig)
    {
        Kernel = this.CreateKernelWithChatCompletion(),
        // Provide default values for template parameters
        Arguments = new KernelArguments()
        {
            { "topic", "Dog" },
            { "length", "3" },
        }
    };

import yaml

from semantic_kernel.prompt_template import PromptTemplateConfig

# Read the YAML file
with open("./GenerateStory.yaml", "r", encoding="utf-8") as file:
    generate_story_yaml = file.read()

# Parse the YAML content
data = yaml.safe_load(generate_story_yaml)

# Use the parsed data to create a PromptTemplateConfig object
prompt_template_config = PromptTemplateConfig(**data)

agent = ChatCompletionAgent(
    service=AzureChatCompletion(), # or other supported AI services
    prompt_template_config=prompt_template_config,
    arguments=KernelArguments(topic="Dog", length="3"),
)

Recurso atualmente indisponível em Java.

Sobrescrevendo valores de modelo para invocação direta

Ao invocar um agente diretamente, os parâmetros do agente podem ser substituídos conforme necessário. Isso permite maior controle e personalização do comportamento do agente durante tarefas específicas, permitindo que você modifique suas instruções ou configurações em tempo real para atender a requisitos específicos.

// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;

ChatCompletionAgent agent =
    new()
    {
        Kernel = kernel,
        Name = "StoryTeller",
        Instructions = "Tell a story about {{$topic}} that is {{$length}} sentences long.",
        Arguments = new KernelArguments()
        {
            { "topic", "Dog" },
            { "length", "3" },
        }
    };

KernelArguments overrideArguments =
    new()
    {
        { "topic", "Cat" },
        { "length", "3" },
    });

// Generate the agent response(s)
await foreach (ChatMessageContent response in agent.InvokeAsync([], options: new() { KernelArguments = overrideArguments }))
{
  // Process agent response(s)...
}

agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    name="StoryTeller",
    instructions="Tell a story about {{$topic}} that is {{$length}} sentences long.",
    arguments=KernelArguments(topic="Dog", length="2"),
)

# Create a thread to maintain the conversation state
# If no threaded is created, a thread will be returned
# with the initial response
thread = None

override_arguments = KernelArguments(topic="Cat", length="3")

# Two ways to get a response from the agent

# Get the response which returns a ChatMessageContent directly
response = await agent.get_response(messages="user input", arguments=override_arguments)
thread = response.thread

# or use the invoke method to return an AsyncIterable of ChatMessageContent
async for response in agent.invoke(messages="user input", arguments=override_arguments):
    # process agent response(s)...
    thread = response.thread

Recurso atualmente indisponível em Java.

Instruções

Para obter um exemplo de ponta a ponta para criar um agente de um modelo de prompt , consulte:

Próximas etapas

Orquestração de agentes

  • Last updated on