Delen via

Migratiehandleiding voor Semantic Kernel naar Agent Framework

Voordelen van Microsoft Agent Framework

  • Vereenvoudigde API: Verminderde complexiteit en standaardcode.
  • Betere prestaties: geoptimaliseerd object maken en geheugengebruik.
  • Unified Interface: consistente patronen voor verschillende AI-providers.
  • Verbeterde ontwikkelaarservaring: intuïtievere en detecteerbare API's.

In de volgende secties vindt u een overzicht van de belangrijkste verschillen tussen Semantic Kernel Agent Framework en Microsoft Agent Framework, zodat u uw code kunt migreren.

1. Naamruimte-updates

Semantische Kernel

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

Agentenraamwerk

Agent Framework-naamruimten bevinden zich onder Microsoft.Agents.AI. Agent Framework maakt gebruik van het kern-AI-bericht en inhoudstypen voor Microsoft.Extensions.AI communicatie tussen onderdelen.

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

2. Vereenvoudiging van agent maken

Semantische Kernel

Elke agent in Semantic Kernel is afhankelijk van een Kernel exemplaar en heeft een lege Kernel , indien niet opgegeven.

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

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

Voor Azure AI Foundry moet een agentresource worden gemaakt in de cloud voordat u een lokale agentklasse maakt die deze gebruikt.

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

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

AzureAIAgent agent = new(definition, azureAgentClient);

Agentenraamwerk

Het maken van agents in Agent Framework wordt eenvoudiger gemaakt met extensies die worden geleverd door alle hoofdproviders.

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

Daarnaast kunt u voor gehoste agentproviders ook de GetAIAgent methode gebruiken om een agent op te halen uit een bestaande gehoste agent.

AIAgent azureFoundryAgent = await persistentAgentsClient.GetAIAgentAsync(agentId);

3. Agent thread maken

Semantische Kernel

De aanroeper moet het threadtype kennen en handmatig maken.

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

Agentenraamwerk

De agent is verantwoordelijk voor het maken van de thread.

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

4. Gehoste agentthread opschonen

Dit geval geldt uitsluitend voor een aantal AI-providers die nog steeds gehoste threads bieden.

Semantische Kernel

Threads hebben een self verwijderingsmethode.

OpenAI Assistants Provider:

await thread.DeleteAsync();

Agentenraamwerk

Opmerking

OpenAI-antwoorden hebben een nieuw gespreksmodel geïntroduceerd dat vereenvoudigt hoe gesprekken worden verwerkt. Deze wijziging vereenvoudigt het beheer van gehoste threads in vergelijking met het nu afgeschafte Model openAI-assistenten. Zie de migratiehandleiding voor OpenAI-assistenten voor meer informatie.

Agent Framework heeft geen threadverwijderings-API in het AgentThread type, omdat niet alle providers gehoste threads of threadverwijdering ondersteunen. Dit ontwerp wordt gebruikelijker naarmate meer providers overstappen op architecturen op basis van antwoorden.

Als u threadverwijdering nodig hebt en de provider dit toestaat, moet de aanroeper de gemaakte threads bijhouden en deze later verwijderen wanneer dat nodig is via de SDK van de provider.

OpenAI Assistants Provider:

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Registratie van hulpprogramma's

Semantische Kernel

Als u een functie als hulpmiddel beschikbaar wilt maken, moet u het volgende doen:

  1. Verfraaid de functie met een [KernelFunction] kenmerk.
  2. Plugin Een klasse hebben of de KernelPluginFactory functie gebruiken om de functie te verpakken.
  3. Kernel Zorg ervoor dat u uw invoegtoepassing toevoegt.
  4. Geef de agent Kernel door.
KernelFunction function = KernelFunctionFactory.CreateFromMethod(GetWeather);
KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("KernelPluginName", [function]);
Kernel kernel = ... // Create kernel
kernel.Plugins.Add(plugin);

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

Agentenraamwerk

In Agent Framework kunt u in één aanroep hulpprogramma's rechtstreeks registreren in het proces voor het maken van de agent.

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

6. Agent niet-streaming aanroep

Belangrijke verschillen zijn te zien in de methodenamen van Invoke tot Run, retourtypen en parameters AgentRunOptions.

Semantische Kernel

De niet-streaming maakt gebruik van een streamingpatroon IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> voor het retourneren van meerdere agentberichten.

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

Agentenraamwerk

De niet-streaming retourneert één AgentRunResponse met het agentantwoord dat meerdere berichten kan bevatten. Het tekstresultaat van de uitvoering is beschikbaar in AgentRunResponse.Text of AgentRunResponse.ToString(). Alle berichten die zijn gemaakt als onderdeel van het antwoord, worden geretourneerd in de AgentRunResponse.Messages lijst. Dit kan onder andere berichten voor het aanroepen van hulpprogramma's, functieresultaten, redeneringsupdates en uiteindelijke resultaten zijn.

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

7. Agent streaming aanroep

De belangrijkste verschillen zijn in de methodenamen van Invoke tot Run, retourtypen en parameters AgentRunOptions.

Semantische Kernel

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

Agentenraamwerk

Agent Framework heeft een vergelijkbaar streaming-API-patroon, waarbij het belangrijkste verschil is dat het objecten retourneert AgentRunResponseUpdate die meer agentgerelateerde informatie per update bevatten.

Alle updates die worden geproduceerd door een service die onder de AIAgent vallen, worden geretourneerd. Het tekstresultaat van de agent is beschikbaar door de AgentRunResponse.Text waarden samen te stellen.

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

8. Functiehandtekeningen voor hulpprogramma's

Probleem: Semantische Kernel-invoegtoepassingsmethoden hebben kenmerken nodig [KernelFunction] .

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

Oplossing: Agent Framework kan methoden rechtstreeks zonder kenmerken gebruiken.

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

9. Configuratie van opties

Probleem: Complexe opties instellen in Semantische kernel.

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

Oplossing: Vereenvoudigde opties in Agent Framework.

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

Belangrijk

In dit voorbeeld ziet u hoe u implementatiespecifieke opties doorgeeft aan een ChatClientAgent. Niet alle AIAgents ondersteuning ChatClientAgentRunOptions. ChatClientAgent wordt geleverd om agents te bouwen op basis van onderliggende deductieservices en biedt daarom ondersteuning voor deductieopties zoals MaxOutputTokens.

10. Afhankelijkheidsinjectie

Semantische Kernel

Er Kernel is een registratie vereist in de servicecontainer om een agent te kunnen maken, omdat elke agentabstractie moet worden geïnitialiseerd met een Kernel eigenschap.

Semantische kernel gebruikt het Agent type als de basisabstractieklasse voor agents.

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

Agentenraamwerk

Agent Framework biedt het AIAgent type als de basisabstractieklasse.

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

11. Consolidatie van agenttypen

Semantische Kernel

Semantic Kernel biedt specifieke agentklassen voor verschillende services, bijvoorbeeld:

  • ChatCompletionAgent voor gebruik met deductieservices op basis van chatvoltooiing.
  • OpenAIAssistantAgent voor gebruik met de OpenAI Assistants-service.
  • AzureAIAgent voor gebruik met de Azure AI Foundry Agents-service.

Agentenraamwerk

Agent Framework ondersteunt alle genoemde services via één agenttype. ChatClientAgent

ChatClientAgent kan worden gebruikt om agents te bouwen met behulp van een onderliggende service die een SDK biedt waarmee de IChatClient interface wordt geïmplementeerd.

Belangrijkste verschillen

Hier volgt een overzicht van de belangrijkste verschillen tussen het Semantic Kernel Agent Framework en Microsoft Agent Framework om u te helpen uw code te migreren.

1. Pakket- en importupdates

Semantische Kernel

Semantische kernelpakketten worden geïnstalleerd als semantic-kernel en geïmporteerd als semantic_kernel. Het pakket heeft ook een aantal extras dat u kunt installeren om de verschillende afhankelijkheden voor verschillende AI-providers en andere functies te installeren.

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Agentenraamwerk

Het Agent Framework-pakket wordt geïnstalleerd als agent-framework en geïmporteerd als agent_framework. Agent Framework is anders opgebouwd, het heeft een kernpakket agent-framework-core dat de kernfunctionaliteit bevat en vervolgens zijn er meerdere pakketten die afhankelijk zijn van dat kernpakket, zoals agent-framework-azure-aiagent-framework-mem0, , agent-framework-copilotstudioenzovoort. Wanneer u het uitvoertpip install agent-framework --pre, worden het kernpakket en alle pakketten geïnstalleerd, zodat u snel aan de slag kunt met alle functies. Wanneer u klaar bent om het aantal pakketten te verminderen omdat u weet wat u nodig hebt, kunt u alleen de pakketten installeren die u nodig hebt. Als u bijvoorbeeld alleen Azure AI Foundry en Mem0 wilt gebruiken, kunt u alleen die twee pakketten installeren: pip install agent-framework-azure-ai agent-framework-mem0 --pre, agent-framework-core is een afhankelijkheid voor deze twee, dus wordt automatisch geïnstalleerd.

Hoewel de pakketten zijn gesplitst, zijn de importen allemaal afkomstig van agent_framework, of zijn het modules. Als u bijvoorbeeld de client voor Azure AI Foundry wilt importeren, doet u het volgende:

from agent_framework.azure import AzureAIAgentClient

Veel van de meest gebruikte typen worden rechtstreeks geïmporteerd uit agent_framework:

from agent_framework import ChatMessage, ChatAgent

2. Agenttypeconsolidatie

Semantische Kernel

Semantic Kernel biedt specifieke agentklassen voor verschillende services, bijvoorbeeld ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent, enzovoort. Zie Agenttypen in Semantische kernel.

Agentenraamwerk

In Agent Framework worden de meeste agents gebouwd met behulp van de ChatAgent agents die kunnen worden gebruikt met alle ChatClient gebaseerde services, zoals Azure AI Foundry, OpenAI ChatCompletion en OpenAI-antwoorden. Er zijn twee extra agents: CopilotStudioAgent voor gebruik met Copilot Studio en A2AAgent voor gebruik met A2A.

Alle ingebouwde agents zijn gebaseerd op de BaseAgent (from agent_framework import BaseAgent). En alle agents zijn consistent met de AgentProtocol (from agent_framework import AgentProtocol) interface.

3. Vereenvoudiging van agent maken

Semantische Kernel

Elke agent in Semantische kernel is afhankelijk van een Kernel exemplaar en heeft een lege Kernel als deze niet is opgegeven.

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

Agentenraamwerk

Het maken van agents in Agent Framework kan op twee manieren worden uitgevoerd:

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

Of met de gemaksmethoden van chatclients:

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

Met de directe methode worden alle mogelijke parameters weergegeven die u voor uw agent kunt instellen. Hoewel de gemaksmethode een subset heeft, kunt u nog steeds dezelfde set parameters doorgeven, omdat deze de directe methode intern aanroept.

4. Agentthread maken

Semantische Kernel

De aanroeper moet het threadtype kennen en handmatig maken.

from semantic_kernel.agents import ChatHistoryAgentThread

thread = ChatHistoryAgentThread()

Agentenraamwerk

De agent kan worden gevraagd om een nieuwe thread voor u te maken.

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

Vervolgens wordt er op drie manieren een thread gemaakt:

  1. Als de agent een thread_id (of conversation_id iets dergelijks) set heeft, wordt er een thread gemaakt in de onderliggende service met die id. Zodra een thread een service_thread_idheeft, kunt u deze niet meer gebruiken om berichten in het geheugen op te slaan. Dit geldt alleen voor agents met een threadconcept aan de servicezijde. zoals Azure AI Foundry Agents en OpenAI-assistenten.
  2. Als de agent een chat_message_store_factory set heeft, wordt die factory gebruikt om een berichtenarchief te maken en deze te gebruiken om een thread in het geheugen te maken. Het kan vervolgens niet meer worden gebruikt met een agent met de store parameter die is ingesteld op True.
  3. Als geen van de vorige instellingen is ingesteld, wordt deze overwogen uninitialized en afhankelijk van hoe deze wordt gebruikt, wordt het een thread in het geheugen of een servicethread.

Agentenraamwerk

Opmerking

OpenAI-antwoorden hebben een nieuw gespreksmodel geïntroduceerd dat vereenvoudigt hoe gesprekken worden verwerkt. Dit vereenvoudigt het beheer van gehoste threads in vergelijking met het nu afgeschafte OpenAI Assistant-model. Zie de migratiehandleiding voor OpenAI-assistenten voor meer informatie.

Agent Framework heeft geen threadverwijderings-API in het AgentThread type, omdat niet alle providers gehoste threads of threadverwijdering ondersteunen. Dit wordt gebruikelijker naarmate meer providers overstappen op op reacties gebaseerde architecturen.

Als u threadverwijdering nodig hebt en de provider dit toestaat, moet de aanroeper de gemaakte threads bijhouden en deze later verwijderen wanneer dat nodig is via de SDK van de provider.

OpenAI Assistants Provider:

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

5. Registratie van hulpprogramma's

Semantische Kernel

Als u een functie als hulpmiddel beschikbaar wilt maken, moet u het volgende doen:

  1. Verfraaid de functie met een @kernel_function decorator.
  2. Plugin Een klasse hebben of de kernel-plugin factory gebruiken om de functie te verpakken.
  3. Kernel Zorg ervoor dat u uw invoegtoepassing toevoegt.
  4. Geef de agent Kernel door.
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()],
)

Agentenraamwerk

In één aanroep kunt u hulpprogramma's rechtstreeks registreren in het proces voor het maken van de agent. Agent Framework heeft niet het concept van een invoegtoepassing voor het verpakken van meerdere functies, maar u kunt dat desgewenst nog steeds doen.

De eenvoudigste manier om een hulpprogramma te maken, is door alleen een Python-functie te maken:

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)

Opmerking

De tools parameter is aanwezig op zowel het maken van de agent, de als run de run_stream methoden, evenals de get_response en get_streaming_response methoden. Hiermee kunt u hulpprogramma's opgeven als een lijst of één functie.

De naam van de functie wordt vervolgens de naam van het hulpprogramma en de docstring wordt de beschrijving van het hulpprogramma, u kunt ook een beschrijving toevoegen aan de parameters:

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."

Ten slotte kunt u de decorator gebruiken om de naam en beschrijving van het hulpprogramma verder aan te passen:

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."

Dit werkt ook wanneer u een klasse met meerdere hulpprogramma's als methoden maakt.

Wanneer u de agent maakt, kunt u nu het functiehulpprogramma aan de agent opgeven door deze door te geven aan de tools parameter.

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)

Opmerking

De functies in de klas kunnen ook worden ingericht om @ai_function de naam en beschrijving van de hulpmiddelen aan te passen.

Dit mechanisme is ook handig voor hulpprogramma's die aanvullende invoer nodig hebben die niet kan worden geleverd door de LLM, zoals verbindingen, geheimen, enzovoort.

Compatibiliteit: KernelFunction gebruiken als Agent Framework-hulpprogramma's

Als u bestaande Semantische Kernel-code hebt met KernelFunction exemplaren (van prompts of van methoden), kunt u deze converteren naar Agent Framework-hulpprogramma's met behulp van de .as_agent_framework_tool methode.

Belangrijk

Voor deze functie is versie 1.38 of hoger vereist semantic-kernel .

KernelFunction gebruiken vanuit een promptsjabloon

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)

KernelFunction gebruiken vanuit een methode

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)

VectorStore gebruiken met create_search_function

U kunt ook vectorStore-integraties van Semantic Kernel gebruiken met Agent Framework. De create_search_function methode van een vectorarchiefverzameling retourneert een KernelFunction verzameling die kan worden geconverteerd naar een Agent Framework-hulpprogramma.

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)

Dit patroon werkt met elke Semantische Kernel VectorStore-connector (Azure AI Search, Qdrant, Pinecone, enzovoort), zodat u uw bestaande vectorzoekinfrastructuur kunt gebruiken met Agent Framework-agents.

Met deze compatibiliteitslaag kunt u uw code geleidelijk migreren van Semantic Kernel naar Agent Framework, waarbij u uw bestaande KernelFunction implementaties hergebruikt terwijl u gebruikmaakt van de vereenvoudigde agentcreatie- en uitvoeringspatronen van Agent Framework.

6. Agent niet-streaming aanroep

Belangrijke verschillen zijn te zien in de methodenamen van invoke tot, runretourtypen (bijvoorbeeld AgentRunResponse) en parameters.

Semantische Kernel

De niet-streamingaanroep maakt gebruik van een asynchroon iteratorpatroon voor het retourneren van meerdere agentberichten.

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

En er was een handige methode om het uiteindelijke antwoord op te halen:

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

Agentenraamwerk

De uitvoering Niet-streaming retourneert één AgentRunResponse met het agentantwoord dat meerdere berichten kan bevatten. Het tekstresultaat van de uitvoering is beschikbaar in response.text of str(response). Alle berichten die zijn gemaakt als onderdeel van het antwoord, worden geretourneerd in de response.messages lijst. Dit kan onder andere berichten voor het aanroepen van hulpprogramma's, functieresultaten, redeneringsupdates en uiteindelijke resultaten zijn.

agent = ...

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

7. Agent streaming aanroep

Belangrijke verschillen in de methodenamen van invoke tot en met run_streamretourtypen (AgentRunResponseUpdate) en parameters.

Semantische Kernel

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)

Agentenraamwerk

Vergelijkbaar streaming-API-patroon met het belangrijkste verschil dat het objecten retourneert AgentRunResponseUpdate , inclusief meer agentgerelateerde informatie per update.

Alle inhoud die wordt geproduceerd door een service onder de agent, wordt geretourneerd. Het uiteindelijke resultaat van de agent is beschikbaar door de update waarden te combineren in één antwoord.

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)

U kunt dat zelfs rechtstreeks doen:

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. Configuratie van opties

Probleem: Complexe opties instellen in Semantische kernel

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)

Oplossing: Vereenvoudigde opties in Agent Framework

Met Agent Framework kunnen alle parameters rechtstreeks worden doorgegeven aan de relevante methoden, zodat u niets extra's hoeft te importeren of optiesobjecten hoeft te maken, tenzij u dat wilt. Intern maakt het gebruik van een ChatOptions object waarvoor ChatClients en ChatAgents, die u ook kunt maken en doorgeven als u dat wilt. Dit wordt ook gemaakt in een ChatAgent om de opties vast te houden en kan per aanroep worden overschreven.

agent = ...

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

Opmerking

Het bovenstaande is specifiek voor een ChatAgent, omdat andere agents mogelijk verschillende opties hebben, moeten ze allemaal worden geaccepteerd messages als een parameter, omdat die is gedefinieerd in de AgentProtocol.

Volgende stappen

Snelstartgids

  • Last updated on