Créer un agent à partir d’un modèle de noyau sémantique

Article
03/06/2025

Important

Cette fonctionnalité se trouve dans la phase candidate de mise en production. Les fonctionnalités à ce stade sont presque complètes et généralement stables, bien qu’elles puissent subir des améliorations mineures ou des optimisations avant d’atteindre une disponibilité générale complète.

Modèles de sollicitation dans le noyau sémantique

Le rôle d’un agent est principalement mis en forme par les instructions qu’il reçoit, ce qui détermine son comportement et ses actions. À l'instar de l'appel d'un Kernelprompt, les instructions d'un agent peuvent inclure des paramètres de modèle (à la fois des valeurs et des fonctions) qui sont substitués dynamiquement pendant l'exécution. Cela permet des réponses flexibles et contextuelles, ce qui permet à l’agent d’ajuster sa sortie en fonction de l’entrée en temps réel.

En outre, un agent peut être configuré directement à l’aide d’une configuration de modèle d’invite, offrant aux développeurs une manière structurée et réutilisable de définir son comportement. Cette approche offre un outil puissant pour la normalisation et la personnalisation des instructions de l’agent, garantissant ainsi la cohérence entre différents cas d’usage tout en conservant l’adaptabilité dynamique.

Les agents sont actuellement indisponibles en Java.

Instructions de l’agent en tant que modèle

La création d’un agent avec des paramètres de modèle offre une plus grande flexibilité en permettant à ses instructions d’être facilement personnalisées en fonction de différents scénarios ou exigences. Cette approche permet de personnaliser le comportement de l’agent en remplaçant des valeurs ou des fonctions spécifiques dans le modèle, ce qui lui permet de s’adapter à une variété de tâches ou de contextes. En tirant parti des paramètres de modèle, les développeurs peuvent concevoir des agents plus polyvalents qui peuvent être configurés pour répondre à divers cas d’usage sans avoir à modifier la logique principale.

Agent d’achèvement de conversation

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

Les agents sont actuellement indisponibles en Java.

Agent Assistant d'OpenAI

Les instructions de modèle sont particulièrement puissantes lors de l’utilisation d’un OpenAIAssistantAgent. Avec cette approche, une définition d’assistant unique peut être créée et réutilisée plusieurs fois, chaque fois avec des valeurs de paramètres différentes adaptées à des tâches ou contextes spécifiques. Cela permet une configuration plus efficace, ce qui permet au même framework d’assistant de gérer un large éventail de scénarios tout en conservant la cohérence dans son comportement 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"),
)

Les agents sont actuellement indisponibles en Java.

Définition d’agent à partir d’un modèle de prompt

La même configuration de modèle d’invite utilisée pour créer une fonction d’invite de noyau peut également être utilisée pour définir un agent. Cela permet une approche unifiée de la gestion des invites et des agents, favorisant ainsi la cohérence et la réutilisation entre les différents composants. En externalisant les définitions d’agent à partir du codebase, cette méthode simplifie la gestion de plusieurs agents, ce qui facilite la mise à jour et la maintenance sans nécessiter de modifications apportées à la logique sous-jacente. Cette séparation améliore également la flexibilité, permettant aux développeurs de modifier le comportement de l’agent ou d’introduire de nouveaux agents en mettant simplement à jour la configuration, plutôt que d’ajuster le code lui-même.

Modèle 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

Initialisation de l’agent

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

Les agents sont actuellement indisponibles en Java.

Redéfinition des valeurs de modèle pour l'appel direct

Lors de l’appel d’un agent directement, sans utiliser AgentChat, les paramètres de l’agent peuvent être remplacés selon les besoins. Cela permet un contrôle et une personnalisation accrus du comportement de l’agent pendant des tâches spécifiques, ce qui vous permet de modifier ses instructions ou paramètres à la volée pour répondre à des exigences particulières.

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

Les agents sont actuellement indisponibles en Java.

Procédure

Pour voir un exemple complet de création d’un agent à partir d’un modèle d’invite , consultez :

guide pratique : ChatCompletionAgent

Configuration des agents avec des plug-ins

Partager via

Créer un agent à partir d’un modèle de noyau sémantique

Modèles de sollicitation dans le noyau sémantique

Instructions de l’agent en tant que modèle

Agent d’achèvement de conversation

Agent Assistant d'OpenAI

Définition d’agent à partir d’un modèle de prompt

Modèle YAML

Initialisation de l’agent

Redéfinition des valeurs de modèle pour l'appel direct

Procédure

Ressources supplémentaires

Partager via

Créer un agent à partir d’un modèle de noyau sémantique

Modèles de sollicitation dans le noyau sémantique

API associée :

Instructions de l’agent en tant que modèle

Agent d’achèvement de conversation

Agent Assistant d'OpenAI

Définition d’agent à partir d’un modèle de prompt

Modèle YAML

Initialisation de l’agent

Redéfinition des valeurs de modèle pour l'appel direct

Procédure

Ressources supplémentaires