Partager via

Guide de migration du noyau sémantique vers agent Framework

Avantages de Microsoft Agent Framework

  • API simplifiée : complexité réduite et code réutilisable.
  • Meilleures performances : optimisation de la création d’objets et de l’utilisation de la mémoire.
  • Interface unifiée : modèles cohérents entre différents fournisseurs d’INTELLIGENCE artificielle.
  • Expérience de développement améliorée : API plus intuitives et détectables.

Les sections suivantes résument les principales différences entre Semantic Kernel Agent Framework et Microsoft Agent Framework pour vous aider à migrer votre code.

1. Mises à jour de l’espace de noms

Noyau sémantique

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

Cadre d’agent

Les espaces de noms Agent Framework sont sous Microsoft.Agents.AI. Agent Framework utilise les principaux types de contenu et de message IA pour Microsoft.Extensions.AI la communication entre les composants.

using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

2. Simplification de la création de l’agent

Noyau sémantique

Chaque agent du noyau sémantique dépend d’une Kernel instance et a un élément vide Kernel s’il n’est pas fourni.

 Kernel kernel = Kernel
    .AddOpenAIChatClient(modelId, apiKey)
    .Build();

 ChatCompletionAgent agent = new() { Instructions = ParrotInstructions, Kernel = kernel };

Azure AI Foundry nécessite la création d’une ressource d’agent dans le cloud avant de créer une classe d’agent locale qui l’utilise.

PersistentAgentsClient azureAgentClient = AzureAIAgent.CreateAgentsClient(azureEndpoint, new AzureCliCredential());

PersistentAgent definition = await azureAgentClient.Administration.CreateAgentAsync(
    deploymentName,
    instructions: ParrotInstructions);

AzureAIAgent agent = new(definition, azureAgentClient);

Cadre d’agent

La création d’agent dans Agent Framework est simplifiée avec les extensions fournies par tous les principaux fournisseurs.

AIAgent openAIAgent = chatClient.CreateAIAgent(instructions: ParrotInstructions);
AIAgent azureFoundryAgent = await persistentAgentsClient.CreateAIAgentAsync(instructions: ParrotInstructions);
AIAgent openAIAssistantAgent = await assistantClient.CreateAIAgentAsync(instructions: ParrotInstructions);

En outre, pour les fournisseurs d’agents hébergés, vous pouvez également utiliser la GetAIAgent méthode pour récupérer un agent à partir d’un agent hébergé existant.

AIAgent azureFoundryAgent = await persistentAgentsClient.GetAIAgentAsync(agentId);

3. Création de threads d’agent

Noyau sémantique

L’appelant doit connaître le type de thread et le créer manuellement.

// Create a thread for the agent conversation.
AgentThread thread = new OpenAIAssistantAgentThread(this.AssistantClient);
AgentThread thread = new AzureAIAgentThread(this.Client);
AgentThread thread = new OpenAIResponseAgentThread(this.Client);

Cadre d’agent

L’agent est responsable de la création du thread.

// New.
AgentThread thread = agent.GetNewThread();

4. Nettoyage des threads de l’agent hébergé

Ce cas s’applique exclusivement à quelques fournisseurs d’IA qui fournissent toujours des threads hébergés.

Noyau sémantique

Les threads ont une self méthode de suppression.

Fournisseur d’assistants OpenAI :

await thread.DeleteAsync();

Cadre d’agent

Note

Les réponses OpenAI ont introduit un nouveau modèle de conversation qui simplifie la gestion des conversations. Cette modification simplifie la gestion des threads hébergés par rapport au modèle d’Assistants OpenAI déprécié. Pour plus d’informations, consultez le guide de migration des Assistants OpenAI.

Agent Framework n’a pas d’API de suppression de thread dans le AgentThread type, car tous les fournisseurs ne prennent pas en charge les threads hébergés ou la suppression de threads. Cette conception deviendra plus courante à mesure que d’autres fournisseurs passent aux architectures basées sur les réponses.

Si vous avez besoin d’une suppression de thread et que le fournisseur l’autorise, l’appelant doit suivre les threads créés et les supprimer ultérieurement si nécessaire via le Kit de développement logiciel (SDK) du fournisseur.

Fournisseur d’assistants OpenAI :

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Inscription de l’outil

Noyau sémantique

Pour exposer une fonction en tant qu’outil, vous devez :

  1. Décorez la fonction avec un [KernelFunction] attribut.
  2. Avoir une Plugin classe ou utiliser la KernelPluginFactory fonction pour encapsuler la fonction.
  3. Kernel Ajoutez votre plug-in.
  4. Passez l’agent Kernel .
KernelFunction function = KernelFunctionFactory.CreateFromMethod(GetWeather);
KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("KernelPluginName", [function]);
Kernel kernel = ... // Create kernel
kernel.Plugins.Add(plugin);

ChatCompletionAgent agent = new() { Kernel = kernel, ... };

Cadre d’agent

Dans Agent Framework, dans un seul appel, vous pouvez inscrire des outils directement dans le processus de création de l’agent.

AIAgent agent = chatClient.CreateAIAgent(tools: [AIFunctionFactory.Create(GetWeather)]);

6. Appel non en streaming de l’agent

Les principales différences peuvent être observées dans les noms de méthode d’à InvokeRun, de types de retour et de paramètres AgentRunOptions.

Noyau sémantique

Le non-streaming utilise un modèle IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> de diffusion en continu pour renvoyer plusieurs messages d’agent.

await foreach (AgentResponseItem<ChatMessageContent> result in agent.InvokeAsync(userInput, thread, agentOptions))
{
    Console.WriteLine(result.Message);
}

Cadre d’agent

Le non-streaming retourne un seul avec AgentRunResponse la réponse de l’agent qui peut contenir plusieurs messages. Le résultat du texte de l’exécution est disponible dans AgentRunResponse.Text ou AgentRunResponse.ToString(). Tous les messages créés dans le cadre de la réponse sont retournés dans la AgentRunResponse.Messages liste. Cela peut inclure des messages d’appel d’outil, des résultats de fonction, des mises à jour de raisonnement et des résultats finaux.

AgentRunResponse agentResponse = await agent.RunAsync(userInput, thread);

7. Appel de streaming de l’agent

Les principales différences sont dans les noms de méthode de Invoke vers Run, les types de retour et les paramètres AgentRunOptions.

Noyau sémantique

await foreach (StreamingChatMessageContent update in agent.InvokeStreamingAsync(userInput, thread))
{
    Console.Write(update);
}

Cadre d’agent

Agent Framework a un modèle d’API de diffusion en continu similaire, avec la différence clé étant qu’il retourne AgentRunResponseUpdate des objets qui incluent plus d’informations liées à l’agent par mise à jour.

Toutes les mises à jour produites par n’importe quel service sous-jacent à l’AIAgent sont retournées. Le résultat textuel de l’agent est disponible en concaténant les AgentRunResponse.Text valeurs.

await foreach (AgentRunResponseUpdate update in agent.RunStreamingAsync(userInput, thread))
{
    Console.Write(update); // Update is ToString() friendly
}

8. Signatures de fonction outil

Problème : les méthodes de plug-in de noyau sémantique ont besoin [KernelFunction] d’attributs.

public class MenuPlugin
{
    [KernelFunction] // Required.
    public static MenuItem[] GetMenu() => ...;
}

Solution : Agent Framework peut utiliser des méthodes directement sans attributs.

public class MenuTools
{
    [Description("Get menu items")] // Optional description.
    public static MenuItem[] GetMenu() => ...;
}

9. Configuration des options

Problème : configuration des options complexes dans le noyau sémantique.

OpenAIPromptExecutionSettings settings = new() { MaxTokens = 1000 };
AgentInvokeOptions options = new() { KernelArguments = new(settings) };

Solution : options simplifiées dans Agent Framework.

ChatClientAgentRunOptions options = new(new() { MaxOutputTokens = 1000 });

Important

Cet exemple montre comment passer des options spécifiques à l’implémentation à un ChatClientAgent. La prise en charge n’est pas toutes prise AIAgents en charge ChatClientAgentRunOptions. ChatClientAgent est fourni pour générer des agents basés sur des services d’inférence sous-jacents, et prend donc en charge les options d’inférence comme MaxOutputTokens.

10. Injection de dépendances

Noyau sémantique

Une Kernel inscription est requise dans le conteneur de service pour pouvoir créer un agent, car chaque abstraction de l’agent doit être initialisée avec une Kernel propriété.

Le noyau sémantique utilise le Agent type comme classe d’abstraction de base pour les agents.

services.AddKernel().AddProvider(...);
serviceContainer.AddKeyedSingleton<SemanticKernel.Agents.Agent>(
    TutorName,
    (sp, key) =>
        new ChatCompletionAgent()
        {
            // Passing the kernel is required.
            Kernel = sp.GetRequiredService<Kernel>(),
        });

Cadre d’agent

Agent Framework fournit le AIAgent type comme classe d’abstraction de base.

services.AddKeyedSingleton<AIAgent>(() => client.CreateAIAgent(...));

11. Consolidation du type d’agent

Noyau sémantique

Le noyau sémantique fournit des classes d’agent spécifiques pour différents services, par exemple :

  • ChatCompletionAgent pour une utilisation avec les services d’inférence basés sur la saisie semi-automatique.
  • OpenAIAssistantAgent pour une utilisation avec le service Assistants OpenAI.
  • AzureAIAgent pour une utilisation avec le service Azure AI Foundry Agents.

Cadre d’agent

Agent Framework prend en charge tous les services mentionnés via un type d’agent unique. ChatClientAgent

ChatClientAgent peut être utilisé pour générer des agents à l’aide de n’importe quel service sous-jacent qui fournit un Kit de développement logiciel (SDK) qui implémente l’interface IChatClient .

Principales différences

Voici un résumé des principales différences entre l’infrastructure de l’agent de noyau sémantique et Microsoft Agent Framework pour vous aider à migrer votre code.

1. Empaqueter et importer des mises à jour

Noyau sémantique

Les packages de noyau sémantique sont installés en tant que et importés en tant que semantic-kernelsemantic_kernel. Le package comporte également un certain nombre de extras fonctionnalités que vous pouvez installer pour installer les différentes dépendances pour différents fournisseurs d’INTELLIGENCE artificielle et d’autres fonctionnalités.

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Cadre d’agent

Le package Agent Framework est installé comme et importé en tant que agent-frameworkagent_framework. Agent Framework est généré différemment, il a un package agent-framework-core de base qui contient les fonctionnalités principales, puis il existe plusieurs packages qui s’appuient sur ce package principal, tels que agent-framework-azure-ai, , agent-framework-mem0agent-framework-copilotstudio, etc. Lorsque vous l’exécutez, pip install agent-framework --pre vous allez installer le package principal et tous les packages, afin que vous puissiez commencer rapidement à utiliser toutes les fonctionnalités. Lorsque vous êtes prêt à réduire le nombre de packages, car vous savez ce dont vous avez besoin, vous pouvez installer uniquement les packages dont vous avez besoin. Par exemple, si vous envisagez uniquement d’utiliser Azure AI Foundry et Mem0, vous ne pouvez installer que ces deux packages : pip install agent-framework-azure-ai agent-framework-mem0 --preest agent-framework-core une dépendance à ces deux packages. Par conséquent, sera automatiquement installé.

Même si les packages sont divisés, les importations proviennent toutes des agent_frameworkmodules. Par exemple, pour importer le client pour Azure AI Foundry, vous devez :

from agent_framework.azure import AzureAIAgentClient

La plupart des types les plus couramment utilisés sont importés directement à partir de agent_framework:

from agent_framework import ChatMessage, ChatAgent

2. Consolidation du type d’agent

Noyau sémantique

Le noyau sémantique fournit des classes d’agent spécifiques pour différents services, par exemple, ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent, etc. Consultez les types d’agent dans le noyau sémantique.

Cadre d’agent

Dans Agent Framework, la majorité des agents sont créés à l’aide de ce ChatAgent qui peut être utilisé avec tous les ChatClient services basés, tels qu’Azure AI Foundry, OpenAI ChatCompletion et OpenAI Responses. Il existe deux agents supplémentaires : CopilotStudioAgent pour une utilisation avec Copilot Studio et A2AAgent pour une utilisation avec A2A.

Tous les agents intégrés sont basés sur BaseAgent (from agent_framework import BaseAgent). Et tous les agents sont cohérents avec l’interface AgentProtocol (from agent_framework import AgentProtocol).

3. Simplification de la création de l’agent

Noyau sémantique

Chaque agent du noyau sémantique dépend d’une Kernel instance et aura une valeur vide Kernel si elle n’est pas fournie.

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(),
    name="Support",
    instructions="Answer in one sentence.",
)

Cadre d’agent

La création de l’agent dans Agent Framework peut être effectuée de deux manières , directement :

from agent_framework.azure import AzureAIAgentClient
from agent_framework import ChatMessage, ChatAgent

agent = ChatAgent(chat_client=AzureAIAgentClient(credential=AzureCliCredential()), instructions="You are a helpful assistant")

Ou, avec les méthodes pratiques fournies par les clients de conversation :

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential
agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(instructions="You are a helpful assistant")

La méthode directe expose tous les paramètres possibles que vous pouvez définir pour votre agent. Bien que la méthode pratique possède un sous-ensemble, vous pouvez toujours passer le même ensemble de paramètres, car elle appelle la méthode directe en interne.

4. Création de threads d’agent

Noyau sémantique

L’appelant doit connaître le type de thread et le créer manuellement.

from semantic_kernel.agents import ChatHistoryAgentThread

thread = ChatHistoryAgentThread()

Cadre d’agent

L’agent peut être invité à créer un thread pour vous.

agent = ...
thread = agent.get_new_thread()

Un thread est ensuite créé de trois façons :

  1. Si l’agent a un thread_id ensemble (ou conversation_id quelque chose de similaire), il crée un thread dans le service sous-jacent avec cet ID. Une fois qu’un thread a un service_thread_idthread, vous ne pouvez plus l’utiliser pour stocker des messages en mémoire. Cela s’applique uniquement aux agents qui ont un concept de thread côté service. comme les agents Azure AI Foundry et les assistants OpenAI.
  2. Si l’agent a un chat_message_store_factory ensemble, il utilise cette fabrique pour créer un magasin de messages et l’utiliser pour créer un thread en mémoire. Il ne peut plus être utilisé avec un agent avec le store paramètre défini sur True.
  3. Si aucun des paramètres précédents n’est défini, il est pris en compte uninitialized et selon la façon dont il est utilisé, il devient un thread en mémoire ou un thread de service.

Cadre d’agent

Note

Les réponses OpenAI ont introduit un nouveau modèle de conversation qui simplifie la gestion des conversations. Cela simplifie la gestion des threads hébergés par rapport au modèle d’Assistants OpenAI désormais déconseillé. Pour plus d’informations, consultez le guide de migration des Assistants OpenAI.

Agent Framework n’a pas d’API de suppression de thread dans le AgentThread type, car tous les fournisseurs ne prennent pas en charge les threads hébergés ou la suppression de threads. Cela deviendra plus courant à mesure que d’autres fournisseurs passent aux architectures basées sur les réponses.

Si vous avez besoin de suppression de threads et que le fournisseur l’autorise, l’appelant doit suivre les threads créés et les supprimer ultérieurement si nécessaire via le kit sdk du fournisseur.

Fournisseur d’assistants OpenAI :

# OpenAI Assistants threads have self-deletion method in Semantic Kernel
await thread.delete_async()

5. Inscription de l’outil

Noyau sémantique

Pour exposer une fonction en tant qu’outil, vous devez :

  1. Décorez la fonction avec un @kernel_function décorateur.
  2. Avoir une Plugin classe ou utiliser la fabrique de plug-in du noyau pour encapsuler la fonction.
  3. Kernel Ajoutez votre plug-in.
  4. Passez l’agent Kernel .
from semantic_kernel.functions import kernel_function

class SpecialsPlugin:
    @kernel_function(name="specials", description="List daily specials")
    def specials(self) -> str:
        return "Clam chowder, Cobb salad, Chai tea"

agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(),
    name="Host",
    instructions="Answer menu questions accurately.",
    plugins=[SpecialsPlugin()],
)

Cadre d’agent

Dans un seul appel, vous pouvez inscrire des outils directement dans le processus de création de l’agent. Agent Framework n’a pas le concept d’un plug-in pour encapsuler plusieurs fonctions, mais vous pouvez toujours le faire si vous le souhaitez.

La façon la plus simple de créer un outil consiste simplement à créer une fonction Python :

def get_weather(location: str) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

agent = chat_client.create_agent(tools=get_weather)

Note

Le tools paramètre est présent à la fois sur la création de l’agent, les run méthodesrun_stream, ainsi que les méthodes et get_response les get_streaming_response méthodes, il vous permet de fournir des outils à la fois en tant que liste ou une seule fonction.

Le nom de la fonction devient ensuite le nom de l’outil, et la documentation devient la description de l’outil, vous pouvez également ajouter une description aux paramètres :

from typing import Annotated

def get_weather(location: Annotated[str, "The location to get the weather for."]) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

Enfin, vous pouvez utiliser le décorateur pour personnaliser davantage le nom et la description de l’outil :

from typing import Annotated
from agent_framework import ai_function

@ai_function(name="weather_tool", description="Retrieves weather information for any location")
def get_weather(location: Annotated[str, "The location to get the weather for."])
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny."

Cela fonctionne également lorsque vous créez une classe avec plusieurs outils en tant que méthodes.

Lors de la création de l’agent, vous pouvez maintenant fournir l’outil de fonction à l’agent en le transmettant au tools paramètre.

class Plugin:

    def __init__(self, initial_state: str):
        self.state: list[str] = [initial_state]

    def get_weather(self, location: Annotated[str, "The location to get the weather for."]) -> str:
        """Get the weather for a given location."""
        self.state.append(f"Requested weather for {location}. ")
        return f"The weather in {location} is sunny."

    def get_weather_details(self, location: Annotated[str, "The location to get the weather details for."]) -> str:
        """Get detailed weather for a given location."""
        self.state.append(f"Requested detailed weather for {location}. ")
        return f"The weather in {location} is sunny with a high of 25°C and a low of 15°C."

plugin = Plugin("Initial state")
agent = chat_client.create_agent(tools=[plugin.get_weather, plugin.get_weather_details])

... # use the agent

print("Plugin state:", plugin.state)

Note

Les fonctions de la classe peuvent également être décorées pour @ai_function personnaliser le nom et la description des outils.

Ce mécanisme est également utile pour les outils qui ont besoin d’une entrée supplémentaire qui ne peut pas être fournie par le LLM, comme les connexions, les secrets, etc.

Compatibilité : Utilisation de KernelFunction en tant qu’outils Agent Framework

Si vous disposez d’un code de noyau sémantique existant avec KernelFunction des instances (à partir d’invites ou de méthodes), vous pouvez les convertir en outils Agent Framework à l’aide de la .as_agent_framework_tool méthode.

Important

Cette fonctionnalité nécessite semantic-kernel la version 1.38 ou ultérieure.

Utilisation de KernelFunction à partir d’un modèle d’invite

from semantic_kernel import Kernel
from semantic_kernel.functions import KernelFunctionFromPrompt
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.prompt_template import KernelPromptTemplate, PromptTemplateConfig
from agent_framework.openai import OpenAIResponsesClient

# Create a kernel with services and plugins
kernel = Kernel()
# will get the api_key and model_id from the environment
kernel.add_service(OpenAIChatCompletion(service_id="default"))

# Create a function from a prompt template that uses plugin functions
function_definition = """
Today is: {{time.date}}
Current time is: {{time.time}}

Answer to the following questions using JSON syntax, including the data used.
Is it morning, afternoon, evening, or night (morning/afternoon/evening/night)?
Is it weekend time (weekend/not weekend)?
"""

prompt_template_config = PromptTemplateConfig(template=function_definition)
prompt_template = KernelPromptTemplate(prompt_template_config=prompt_template_config)

# Create a KernelFunction from the prompt
kernel_function = KernelFunctionFromPrompt(
    description="Determine the kind of day based on the current time and date.",
    plugin_name="TimePlugin",
    prompt_execution_settings=OpenAIChatPromptExecutionSettings(service_id="default", max_tokens=100),
    function_name="kind_of_day",
    prompt_template=prompt_template,
)

# Convert the KernelFunction to an Agent Framework tool
agent_tool = kernel_function.as_agent_framework_tool(kernel=kernel)

# Use the tool with an Agent Framework agent
agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(tools=agent_tool)
response = await agent.run("What kind of day is it?")
print(response.text)

Utilisation de KernelFunction à partir d’une méthode

from semantic_kernel.functions import kernel_function
from agent_framework.openai import OpenAIResponsesClient

# Create a plugin class with kernel functions
@kernel_function(name="get_weather", description="Get the weather for a location")
def get_weather(self, location: str) -> str:
    return f"The weather in {location} is sunny."

# Get the KernelFunction and convert it to an Agent Framework tool
agent_tool = get_weather.as_agent_framework_tool()

# Use the tool with an Agent Framework agent
agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(tools=agent_tool)
response = await agent.run("What's the weather in Seattle?")
print(response.text)

Utilisation de VectorStore avec create_search_function

Vous pouvez également utiliser les intégrations VectorStore du noyau sémantique à Agent Framework. La create_search_function méthode d’une collection de magasins vectoriels retourne une KernelFunction valeur qui peut être convertie en outil Agent Framework.

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAITextEmbedding
from semantic_kernel.connectors.azure_ai_search import AzureAISearchCollection
from semantic_kernel.functions import KernelParameterMetadata
from agent_framework.openai import OpenAIResponsesClient

# Define your data model
class HotelSampleClass:
    HotelId: str
    HotelName: str
    Description: str
    # ... other fields

# Create an Azure AI Search collection
collection = AzureAISearchCollection[str, HotelSampleClass](
    record_type=HotelSampleClass,
    embedding_generator=OpenAITextEmbedding()
)

async with collection:
    await collection.ensure_collection_exists()
    # Load your records into the collection
    # await collection.upsert(records)

    # Create a search function from the collection
    search_function = collection.create_search_function(
        description="A hotel search engine, allows searching for hotels in specific cities.",
        search_type="keyword_hybrid",
        filter=lambda x: x.Address.Country == "USA",
        parameters=[
            KernelParameterMetadata(
                name="query",
                description="What to search for.",
                type="str",
                is_required=True,
                type_object=str,
            ),
            KernelParameterMetadata(
                name="city",
                description="The city that you want to search for a hotel in.",
                type="str",
                type_object=str,
            ),
            KernelParameterMetadata(
                name="top",
                description="Number of results to return.",
                type="int",
                default_value=5,
                type_object=int,
            ),
        ],
        string_mapper=lambda x: f"(hotel_id: {x.record.HotelId}) {x.record.HotelName} - {x.record.Description}",
    )

    # Convert the search function to an Agent Framework tool
    search_tool = search_function.as_agent_framework_tool()

    # Use the tool with an Agent Framework agent
    agent = OpenAIResponsesClient(model_id="gpt-4o").create_agent(
        instructions="You are a travel agent that helps people find hotels.",
        tools=search_tool
    )
    response = await agent.run("Find me a hotel in Seattle")
    print(response.text)

Ce modèle fonctionne avec n’importe quel connecteur VectorStore de noyau sémantique (Recherche Azure AI, Qdrant, Pinecone, etc.), ce qui vous permet de tirer parti de votre infrastructure de recherche vectorielle existante avec les agents Agent Framework.

Cette couche de compatibilité vous permet de migrer progressivement votre code du noyau sémantique vers Agent Framework, en réutilisant vos implémentations existantes KernelFunction tout en tirant parti des modèles simplifiés de création et d’exécution de l’agent Framework.

6. Appel non en streaming de l’agent

Les principales différences peuvent être observées dans les noms de méthode de invoke vers run, les types de retour (par exemple, AgentRunResponse) et les paramètres.

Noyau sémantique

L’appel non-streaming utilise un modèle d’itérateur asynchrone pour retourner plusieurs messages d’agent.

async for response in agent.invoke(
    messages=user_input,
    thread=thread,
):
    print(f"# {response.role}: {response}")
    thread = response.thread

Et il y avait une méthode pratique pour obtenir la réponse finale :

response = await agent.get_response(messages="How do I reset my bike tire?", thread=thread)
print(f"# {response.role}: {response}")

Cadre d’agent

L’exécution sans diffusion en continu retourne une seule AgentRunResponse avec la réponse de l’agent qui peut contenir plusieurs messages. Le résultat du texte de l’exécution est disponible dans response.text ou str(response). Tous les messages créés dans le cadre de la réponse sont retournés dans la response.messages liste. Cela peut inclure des messages d’appel d’outil, des résultats de fonction, des mises à jour de raisonnement et des résultats finaux.

agent = ...

response = await agent.run(user_input, thread)
print("Agent response:", response.text)

7. Appel de streaming de l’agent

Différences clés entre les noms de invoke méthode et run_streamles types de retour (AgentRunResponseUpdate) et les paramètres.

Noyau sémantique

async for update in agent.invoke_stream(
    messages="Draft a 2 sentence blurb.",
    thread=thread,
):
    if update.message:
        print(update.message.content, end="", flush=True)

Cadre d’agent

Modèle d’API de diffusion en continu similaire avec la différence clé étant qu’il retourne AgentRunResponseUpdate des objets, y compris d’autres informations associées à l’agent par mise à jour.

Tout le contenu produit par n’importe quel service sous-jacent à l’agent est retourné. Le résultat final de l’agent est disponible en combinant les update valeurs en une seule réponse.

from agent_framework import AgentRunResponse
agent = ...
updates = []
async for update in agent.run_stream(user_input, thread):
    updates.append(update)
    print(update.text)

full_response = AgentRunResponse.from_agent_run_response_updates(updates)
print("Full agent response:", full_response.text)

Vous pouvez même le faire directement :

from agent_framework import AgentRunResponse
agent = ...
full_response = AgentRunResponse.from_agent_response_generator(agent.run_stream(user_input, thread))
print("Full agent response:", full_response.text)

8. Configuration des options

Problème : configuration des options complexes dans le noyau sémantique

from semantic_kernel.connectors.ai.open_ai import OpenAIPromptExecutionSettings

settings = OpenAIPromptExecutionSettings(max_tokens=1000)
arguments = KernelArguments(settings)

response = await agent.get_response(user_input, thread=thread, arguments=arguments)

Solution : Options simplifiées dans Agent Framework

Agent Framework permet de transmettre tous les paramètres directement aux méthodes appropriées, de sorte que vous n’avez pas besoin d’importer d’autres éléments ou de créer des objets d’options, sauf si vous souhaitez. En interne, il utilise un ChatOptions objet pour ChatClients et ChatAgents, que vous pouvez également créer et transmettre si vous le souhaitez. Cela est également créé dans un ChatAgent pour contenir les options et peut être remplacé par appel.

agent = ...

response = await agent.run(user_input, thread, max_tokens=1000, frequency_penalty=0.5)

Note

L’élément ci-dessus est spécifique à un ChatAgent, car d’autres agents peuvent avoir des options différentes, ils doivent tous accepter messages comme paramètre, car cela est défini dans le AgentProtocol.

Étapes suivantes

Guide de démarrage rapide

  • Last updated on