Compartir a través de


Creación de un agente a partir de una plantilla de kernel semántica

Importante

Esta característica está en la fase candidata para lanzamiento. Las características de esta fase son casi completas y, por lo general, estables, aunque pueden someterse a pequeños refinamientos o optimizaciones antes de alcanzar la disponibilidad general completa.

Plantillas de entrada en Kernel Semántico

El rol de un agente se configura principalmente por las instrucciones que recibe, lo que dicta su comportamiento y sus acciones. De forma similar a invocar una solicitud, las instrucciones de un Kernelagente pueden incluir parámetros con plantilla (tanto valores como funciones) que se sustituyen dinámicamente durante la ejecución. Esto permite respuestas flexibles y compatibles con el contexto, lo que permite al agente ajustar su salida en función de la entrada en tiempo real.

Además, un agente se puede configurar directamente mediante una configuración de plantilla de solicitud, lo que proporciona a los desarrolladores una manera estructurada y reutilizable de definir su comportamiento. Este enfoque ofrece una herramienta eficaz para estandarizar y personalizar las instrucciones del agente, garantizando la coherencia en varios casos de uso, a la vez que mantiene la adaptabilidad dinámica.

Los agentes no están disponibles actualmente en Java.

Instrucciones del agente como plantilla

La creación de un agente con parámetros de plantilla proporciona una mayor flexibilidad al permitir que sus instrucciones se personalicen fácilmente en función de diferentes escenarios o requisitos. Este enfoque permite que el comportamiento del agente se adapte sustituyendo valores o funciones específicos en la plantilla, lo que permite adaptarlo a una variedad de tareas o contextos. Al aprovechar los parámetros de plantilla, los desarrolladores pueden diseñar agentes más versátiles que se pueden configurar para satisfacer diversos casos de uso sin necesidad de modificar la lógica principal.

Agente de finalización de chat

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

Los agentes no están disponibles actualmente en Java.

Asistente de OpenAI

Las instrucciones con plantilla son especialmente eficaces cuando se trabaja con un OpenAIAssistantAgent. Con este enfoque, se puede crear y reutilizar varias veces una sola definición de asistente, cada vez con valores de parámetro diferentes adaptados a tareas o contextos específicos. Esto permite una configuración más eficaz, lo que permite que el mismo marco de trabajo del asistente controle una amplia gama de escenarios a la vez que mantiene la coherencia en su comportamiento 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"),
)

Los agentes no están disponibles actualmente en Java.

Definición del agente de una plantilla de aviso

La misma configuración de plantilla de solicitud que se usa para crear una función de solicitud de kernel también se puede aprovechar para definir un agente. Esto permite un enfoque unificado en la administración de mensajes y agentes, lo que promueve la coherencia y la reutilización en distintos componentes. Al externalizar las definiciones de agente desde el código base, este método simplifica la administración de varios agentes, lo que facilita la actualización y el mantenimiento sin necesidad de realizar cambios en la lógica subyacente. Esta separación también mejora la flexibilidad, lo que permite a los desarrolladores modificar el comportamiento del agente o introducir nuevos agentes simplemente actualizando la configuración, en lugar de ajustar el propio código.

Plantilla de 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

Inicialización del 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"),
)

Los agentes no están disponibles actualmente en Java.

Anulación de valores de plantilla para invocación directa

Al invocar directamente un agente, sin usar AgentChat, los parámetros del agente se pueden invalidar según sea necesario. Esto permite un mayor control y personalización del comportamiento del agente durante tareas específicas, lo que le permite modificar sus instrucciones o configuraciones sobre la marcha para satisfacer determinados requisitos.

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

// Create a ChatHistory object to maintain the conversation state.
ChatHistory chat = [];

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

// Generate the agent response(s)
await foreach (ChatMessageContent response in agent.InvokeAsync(chat, 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 chat history to maintain the conversation state
chat = ChatHistory()

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(chat, arguments=override_arguments)

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

Los agentes no están disponibles actualmente en Java.

Procedimiento

Para obtener un ejemplo completo de cómo crear un agente a partir de una plantilla de prompt , consulte: