Megosztás:

Szemantikus kernel–ügynök keretrendszer migrálási útmutatója

A Microsoft Agent Framework előnyei

  • Egyszerűsített API: Csökkentett összetettség és sablonkód.
  • Jobb teljesítmény: Optimalizált objektumlétrehozás és memóriahasználat.
  • Egységes felület: Konzisztens minták a különböző AI-szolgáltatók között.
  • Továbbfejlesztett fejlesztői élmény: Intuitívabb és felfedezhetőBB API-k.

A következő szakaszok összefoglalják a szemantikus kernelügynök-keretrendszer és a Microsoft Agent Framework közötti főbb különbségeket a kód migrálásához.

1. Névtérfrissítések

Szemantikus kernel

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

Ügynök-keretrendszer

Az Ügynök-keretrendszer névterei a következő alatt Microsoft.Agents.AIvannak: . Az Agent Framework az alapvető AI-üzeneteket és tartalomtípusokat Microsoft.Extensions.AI használja az összetevők közötti kommunikációhoz.

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

2. Az ügynöklétrehozás egyszerűsítése

Szemantikus kernel

A Szemantic Kernelben minden ügynök egy Kernel példánytól függ, és üres Kernel , ha nincs megadva.

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

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

Az Azure AI Foundryhez ügynökerőforrást kell létrehozni a felhőben, mielőtt létrehoz egy helyi ügynökosztályt, amely azt használja.

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

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

AzureAIAgent agent = new(definition, azureAgentClient);

Ügynök-keretrendszer

Az Ügynök-keretrendszerben az ügynöklétrehozás egyszerűbb lesz az összes fő szolgáltató által biztosított bővítményekkel.

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

Az üzemeltetett ügynökszolgáltatók esetében emellett a GetAIAgent metódus használatával is lekérheti az ügynököt egy meglévő üzemeltetett ügynöktől.

AIAgent azureFoundryAgent = await persistentAgentsClient.GetAIAgentAsync(agentId);

3. Ügynökszál létrehozása

Szemantikus kernel

A hívónak ismernie kell a szál típusát, és manuálisan kell létrehoznia.

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

Ügynök-keretrendszer

A szál létrehozásáért az ügynök felel.

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

4. Üzemeltetett ügynökszál törlése

Ez az eset kizárólag néhány AI-szolgáltatóra vonatkozik, amelyek továbbra is üzemeltetett szálakat biztosítanak.

Szemantikus kernel

A szálak törlési self módszerrel rendelkeznek.

OpenAI Assistants-szolgáltató:

await thread.DeleteAsync();

Ügynök-keretrendszer

Megjegyzés:

Az OpenAI-válaszok új beszélgetési modellt vezetnek be, amely leegyszerűsíti a beszélgetések kezelését. Ez a módosítás leegyszerűsíti az üzemeltetett szálak kezelését az elavult OpenAI Assistants-modellhez képest. További információt az OpenAI Assistants migrálási útmutatójában talál.

Az Agent Framework nem rendelkezik száltörlés API-val a típusban, mivel nem minden szolgáltató támogatja a AgentThread üzemeltetett szálakat vagy a szálak törlését. Ez a kialakítás egyre gyakoribbá válik, ahogy egyre több szolgáltató vált a válaszalapú architektúrákra.

Ha szükség van a szál törlésére, és a szolgáltató engedélyezi azt, a hívónak nyomon kell követnie a létrehozott szálakat, és később törölnie kell őket, ha szükséges, a szolgáltató SDK-ján keresztül.

OpenAI Assistants-szolgáltató:

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Eszközregisztráció

Szemantikus kernel

Ha egy függvényt eszközként szeretne elérhetővé tenni, az alábbiakat kell tennie:

  1. Díszítse a függvényt egy [KernelFunction] attribútummal.
  2. Legyen egy Plugin osztálya, vagy használja a KernelPluginFactory függvényt.
  3. Van egy Kernel , hogy adja hozzá a beépülő modult.
  4. Adja át az Kernel ügynöknek.
KernelFunction function = KernelFunctionFactory.CreateFromMethod(GetWeather);
KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("KernelPluginName", [function]);
Kernel kernel = ... // Create kernel
kernel.Plugins.Add(plugin);

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

Ügynök-keretrendszer

Az Agent Frameworkben egyetlen hívásban közvetlenül regisztrálhat eszközöket az ügynöklétrehozás folyamatában.

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

6. Ügynök nem streamelési meghívása

A főbb különbségek a metódusnevekben láthatók a következőtől a visszatérési típusig InvokeRunés a paraméterekig AgentRunOptions.

Szemantikus kernel

A Nem streamelés egy streamelési mintát IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> használ több ügynöküzenet visszaadására.

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

Ügynök-keretrendszer

A nem streamelt szolgáltatás egyetlen AgentRunResponse olyan ügynökválaszt ad vissza, amely több üzenetet is tartalmazhat. A futtatás szöveges eredménye elérhető a (vagyAgentRunResponse.Text) fájlbanAgentRunResponse.ToString(). A válasz részeként létrehozott összes üzenet megjelenik a AgentRunResponse.Messages listában. Ilyenek lehetnek az eszközhívási üzenetek, a függvényeredmények, az érvelési frissítések és a végleges eredmények.

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

7. Ügynök streamelési meghívása

A fő különbségek a metódusok nevei InvokeRunközött vannak, a visszatérési típusok és a paraméterek AgentRunOptions.

Szemantikus kernel

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

Ügynök-keretrendszer

Az Agent Framework hasonló streamelési API-mintával rendelkezik, és a fő különbség az, hogy olyan objektumokat ad vissza AgentRunResponseUpdate , amelyek frissítésenként több ügynökhöz kapcsolódó információt tartalmaznak.

A rendszer az AIAgent alapjául szolgáló bármely szolgáltatás által előállított összes frissítést visszaadja. Az ügynök szöveges eredménye az értékek összefűzésével AgentRunResponse.Text érhető el.

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

8. Eszközfüggvény-aláírások

Probléma: A szemantikus kernel beépülő modul metódusainak attribútumokra van szükségük [KernelFunction] .

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

Megoldás: Az Agent Framework közvetlenül attribútumok nélkül is használhat metódusokat.

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

9. Beállítások konfigurálása

Probléma: Összetett beállítások beállítása a Szemantic Kernelben.

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

Megoldás: Egyszerűsített beállítások az Agent Frameworkben.

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

Fontos

Ez a példa azt mutatja be, hogy implementációspecifikus beállításokat ad át egy ChatClientAgent. Nem minden AIAgents támogatás ChatClientAgentRunOptions. ChatClientAgent az alapul szolgáló következtetési szolgáltatásokon alapuló ügynökök létrehozására szolgál, ezért támogatja az olyan következtetési lehetőségeket, mint a MaxOutputTokens.

10. Függőséginjektálás

Szemantikus kernel

Az Kernel ügynök létrehozásához regisztráció szükséges a szolgáltatástárolóban, mivel minden ügynök absztrakcióját inicializálni kell egy Kernel tulajdonsággal.

A Szemantikus Kernel a típust Agent használja az ügynökök alap absztrakciós osztályaként.

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

Ügynök-keretrendszer

Az Agent Framework az AIAgent alap absztrakciós osztályként adja meg a típust.

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

11. Ügynöktípus konszolidálása

Szemantikus kernel

A Szemantic Kernel meghatározott ügynökosztályokat biztosít különböző szolgáltatásokhoz, például:

  • ChatCompletionAgent a csevegés-befejezésalapú következtetési szolgáltatásokhoz.
  • OpenAIAssistantAgent az OpenAI Assistants szolgáltatással való használatra.
  • AzureAIAgent az Azure AI Foundry Agents szolgáltatással való használatra.

Ügynök-keretrendszer

Az Agent Framework egyetlen ügynöktípuson keresztül támogatja az összes említett szolgáltatást. ChatClientAgent

ChatClientAgent az ügynökök bármely mögöttes szolgáltatással történő létrehozására használhatók, amely egy olyan SDK-t biztosít, amely implementálja a IChatClient felületet.

Főbb különbségek

Az alábbiakban összefoglaljuk a szemantikus kernelügynök-keretrendszer és a Microsoft Agent Framework közötti főbb különbségeket a kód migrálásához.

1. Frissítések csomagolása és importálása

Szemantikus kernel

A szemantikus kernelcsomagok telepítése semantic-kernel és importálása a következőként semantic_kerneltörténik: . A csomag számos extras olyan elemet is tartalmaz, amelyet a különböző AI-szolgáltatók és egyéb funkciók különböző függőségeinek telepítéséhez telepíthet.

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Ügynök-keretrendszer

Az Agent Framework-csomag telepítése agent-framework és importálása a következőképpen agent_frameworktörténik: . Az Agent Framework másképpen van felépítve, egy magcsomaggal agent-framework-core rendelkezik, amely tartalmazza az alapvető funkciókat, majd több csomag is létezik, amelyek az adott alapcsomagra támaszkodnak, például agent-framework-azure-ai, agent-framework-mem0, agent-framework-copilotstudiostb. A futtatáskor pip install agent-framework --pre telepíti az alapcsomagot és az összes csomagot, hogy gyorsan elkezdhesse az összes funkciót. Ha készen áll a csomagok számának csökkentésére, mert tudja, hogy mire van szüksége, csak a szükséges csomagokat telepítheti, így például ha csak az Azure AI Foundryt és a Mem0-et tervezi használni, csak ezt a két csomagot telepítheti: pip install agent-framework-azure-ai agent-framework-mem0 --prea két agent-framework-core csomag függősége, ezért a rendszer automatikusan telepíti.

Annak ellenére, hogy a csomagok fel vannak osztva, az importálások mind a modulokból származnak agent_framework. Így például az Azure AI Foundry ügyfél importálásához a következőt kell tennie:

from agent_framework.azure import AzureAIAgentClient

A leggyakrabban használt típusok közül sok közvetlenül a következőből agent_frameworkimportálható:

from agent_framework import ChatMessage, ChatAgent

2. Ügynöktípus konszolidálása

Szemantikus kernel

A Szemantic Kernel speciális ügynökosztályokat biztosít különböző szolgáltatásokhoz, például ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent stb. Lásd az ügynöktípusokat a Szemantikus Kernelben.

Ügynök-keretrendszer

Az Ügynök-keretrendszerben az ügynökök többsége az összes alapszolgáltatáshoz használható, például az ChatAgent Azure AI Foundry, az OpenAI ChatCompletion és az ChatClient OpenAI-válaszok használatával épül fel. Két további ügynök van: CopilotStudioAgent a Copilot Studióval és A2AAgent az A2A-val való használatra.

Az összes beépített ügynök a BaseAgent (from agent_framework import BaseAgent) függvényen alapul. És minden ügynök összhangban van a AgentProtocol (from agent_framework import AgentProtocol) felülettel.

3. Az ügynökök létrehozásának egyszerűsítése

Szemantikus kernel

A Szemantic Kernel minden ügynöke egy Kernel példánytól függ, és üres Kernel lesz, ha nincs megadva.

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

Ügynök-keretrendszer

Az ügynöklétrehozás az Agent Frameworkben kétféleképpen végezhető el, közvetlenül:

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

Vagy a csevegési ügyfelek által biztosított kényelmi módszerekkel:

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

A közvetlen módszer elérhetővé teszi az ügynökhöz beállítható összes lehetséges paramétert. Bár a kényelmi metódusnak van egy részhalmaza, továbbra is ugyanabban a paraméterkészletben adhat át, mivel belsőleg hívja meg a közvetlen metódust.

4. Ügynökszál létrehozása

Szemantikus kernel

A hívónak ismernie kell a szál típusát, és manuálisan kell létrehoznia.

from semantic_kernel.agents import ChatHistoryAgentThread

thread = ChatHistoryAgentThread()

Ügynök-keretrendszer

Az ügynök felkérhető, hogy hozzon létre egy új szálat.

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

Ezután létrejön egy szál a következő három módszer egyikével:

  1. Ha az ügynök rendelkezik thread_id (vagy conversation_id hasonló) készlettel, akkor létrehoz egy szálat az alapul szolgáló szolgáltatásban az azonosítóval. Ha egy szál rendelkezik egy service_thread_idüzenettel, többé nem használhatja arra, hogy üzeneteket tároljon a memóriában. Ez csak a szolgáltatásoldali szál koncepcióval rendelkező ügynökökre vonatkozik. például az Azure AI Foundry-ügynökök és az OpenAI-asszisztensek.
  2. Ha az ügynök rendelkezik egy chat_message_store_factory készlettel, akkor a gyár használatával létrehoz egy üzenettárolót, és ezzel létrehoz egy memórián belüli szálat. Ezután már nem használható olyan ügynökkel, amelynek paramétere a store következő True.
  3. Ha a korábbi beállítások egyikét sem állítja be, akkor a rendszer figyelembe veszi uninitialized , és a használat módjától függően memórián belüli vagy szolgáltatásszál lesz belőle.

Ügynök-keretrendszer

Megjegyzés:

Az OpenAI-válaszok új beszélgetési modellt vezetnek be, amely leegyszerűsíti a beszélgetések kezelését. Ez leegyszerűsíti az üzemeltetett szál kezelését az elavult OpenAI Assistants-modellhez képest. További információt az OpenAI Assistants migrálási útmutatójában talál.

Az Agent Framework nem rendelkezik száltörlési API-val a típusban, mivel nem minden szolgáltató támogatja a AgentThread üzemeltetett szálakat vagy a szálak törlését, és ez gyakoribbá válik, mivel egyre több szolgáltató vált válaszalapú architektúrákra.

Ha szükség van a szál törlésére, és ezt a szolgáltató engedélyezi, a hívónak nyomon kell követnie a létrehozott szálakat, és később törölnie kell őket, ha szükséges, a szolgáltató sdk-ján keresztül.

OpenAI Assistants-szolgáltató:

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

5. Eszközregisztráció

Szemantikus kernel

Ha egy függvényt eszközként szeretne elérhetővé tenni, az alábbiakat kell tennie:

  1. Díszítse a funkciót egy @kernel_function dekoratőrrel.
  2. Legyen osztálya Plugin , vagy használja a kernel beépülő modulgyárat a függvény burkolásához.
  3. Van egy Kernel , hogy adja hozzá a beépülő modult.
  4. Adja át az Kernel ügynöknek.
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()],
)

Ügynök-keretrendszer

Egyetlen hívásban közvetlenül regisztrálhat eszközöket az ügynöklétrehozás folyamatában. Az Agent Framework nem rendelkezik olyan beépülő modul fogalmával, amely több függvényt is körbefuttat, de szükség esetén ezt továbbra is megteheti.

Az eszköz létrehozásának legegyszerűbb módja egy Python-függvény létrehozása:

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)

Megjegyzés:

A tools paraméter az ügynöklétrehozáson, a runrun_stream metódusokon és a metódusokon, valamint a get_responseget_streaming_response metódusokon is jelen van, lehetővé teszi az eszközök listaként vagy egyetlen függvényként való biztosítását.

Ezután a függvény neve lesz az eszköz neve, és a dokumentumírás az eszköz leírásává válik, a paraméterekhez leírást is hozzáadhat:

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

Végül használhatja a dekoratőrt az eszköz nevének és leírásának további testreszabásához:

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

Ez akkor is működik, ha több eszközzel rendelkező osztályt hoz létre metódusként.

Az ügynök létrehozásakor a függvényeszközt átadhatja az ügynöknek a tools paraméternek.

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)

Megjegyzés:

Az osztályon belüli függvények az eszközök nevének és leírásának testreszabásához @ai_function is díszíthetők.

Ez a mechanizmus olyan eszközök esetében is hasznos, amelyekhez további bemenetre van szükség, amelyeket az LLM nem tud megadni, például kapcsolatok, titkos kódok stb.

Kompatibilitás: A KernelFunction használata ügynök-keretrendszer-eszközökként

Ha már rendelkezik példányokkal rendelkező Szemantic Kernel-kóddal KernelFunction (parancssorból vagy metódusból), a metódus használatával .as_agent_framework_tool konvertálhatja őket Agent Framework-eszközökké.

Fontos

Ehhez a funkcióhoz az 1.38-es vagy újabb verzió szükséges semantic-kernel .

KernelFunction használata parancssori sablonból

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 használata metódusból

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)

A VectorStore használata create_search_function

Használhatja a Szemantic Kernel VectorStore-integrációját is az Agent Frameworkdel. A create_search_function vektortár-gyűjtemény metódusa egy KernelFunction ügynök-keretrendszer eszközzé konvertálható metódust ad vissza.

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)

Ez a minta bármilyen Szemantikus Kernel VectorStore-összekötővel (Azure AI Search, Qdrant, Pinecone stb.) működik, így a meglévő vektorkeresési infrastruktúrát az Agent Framework-ügynökökkel használhatja.

Ez a kompatibilitási réteg lehetővé teszi, hogy fokozatosan migrálja a kódot a Szemantic Kernelből az Agent Frameworkbe, és a meglévő KernelFunction implementációkat használja újra, miközben kihasználja az Agent Framework egyszerűsített ügynöklétrehozási és végrehajtási mintáit.

6. Ügynök nem streamelési meghívása

A fő különbségek a metódusok neveiben invokerun, a visszatérési típusokban (például AgentRunResponse) és a paraméterekben láthatók.

Szemantikus kernel

A nem streamelt meghívás aszinkron iterátormintát használ több ügynöküzenet visszaadására.

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

És volt egy egyszerű módszer a végső válasz lekérésére:

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

Ügynök-keretrendszer

A nem streamelt futtatás egyetlen AgentRunResponse olyan ügynökválaszt ad vissza, amely több üzenetet tartalmazhat. A futtatás szöveges eredménye elérhető a (vagyresponse.text) fájlbanstr(response). A válasz részeként létrehozott összes üzenet megjelenik a response.messages listában. Ilyenek lehetnek az eszközhívási üzenetek, a függvényeredmények, az érvelési frissítések és a végleges eredmények.

agent = ...

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

7. Ügynök streamelési meghívása

A metódusnevek főbb eltérései a következőtől invokerun_stream, a visszaadott típusoktól (AgentRunResponseUpdate) és a paraméterektől.

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

Ügynök-keretrendszer

Hasonló streamelési API-minta, amelynek fő különbsége az, hogy az objektumokat AgentRunResponseUpdate adja vissza, beleértve az ügynökkel kapcsolatos további információkat frissítésenként.

A rendszer az ügynök alapjául szolgáló bármely szolgáltatás által előállított összes tartalmat visszaadja. Az ügynök végeredménye az értékek egyetlen válaszba való kombinálásával update érhető el.

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)

Ezt közvetlenül is megteheti:

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. Beállítások konfigurálása

Probléma: Összetett beállítások beállítása a Szemantic Kernelben

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)

Megoldás: Egyszerűsített beállítások az Agent Frameworkben

Az Agent Framework lehetővé teszi az összes paraméter közvetlen átadását a megfelelő metódusoknak, így nem kell semmilyen extra importálást végeznie, és semmilyen beállításobjektumot sem kell létrehoznia, hacsak nem szeretné. Belsőleg egy ChatOptions objektumot ChatClientsChatAgentshasznál, amelyet igény szerint létrehozhat és átadhat is. Ez a beállítások tárolására is létrejön, ChatAgent és hívásonként felül lehet bírálni.

agent = ...

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

Megjegyzés:

A fentiek egy adottra ChatAgentvonatkoznak messages , mivel más ügynököknek eltérő lehetőségeik lehetnek, mindegyiknek paraméterként kell elfogadnia őket, mivel ez a paraméterben AgentProtocolvan definiálva.

Következő lépések

Rövid útmutató

  • Last updated on