Compartir a través de

Guía de migración del kernel semántico al marco de agente

Ventajas de Microsoft Agent Framework

  • API simplificada: complejidad reducida y código reutilizable.
  • Mejor rendimiento: optimización de la creación de objetos y el uso de memoria.
  • Interfaz unificada: patrones coherentes en diferentes proveedores de IA.
  • Experiencia mejorada para desarrolladores: API más intuitivas y detectables.

En las secciones siguientes se resumen las diferencias clave entre el marco del agente de kernel semántico y microsoft Agent Framework para ayudarle a migrar el código.

1. Actualizaciones del espacio de nombres

Kernel semántico

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

Marco de trabajo del agente

Los espacios de nombres de Agent Framework se encuentran en Microsoft.Agents.AI. Agent Framework usa los tipos de contenido y mensajes de IA principales de Microsoft.Extensions.AI para la comunicación entre componentes.

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

2. Simplificación de la creación del agente

Kernel semántico

Cada agente del kernel semántico depende de una Kernel instancia y tiene un vacío Kernel si no se proporciona.

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

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

Azure AI Foundry requiere que se cree un recurso de agente en la nube antes de crear una clase de agente local que la use.

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

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

AzureAIAgent agent = new(definition, azureAgentClient);

Marco de trabajo del agente

La creación del agente en Agent Framework se simplifica con las extensiones proporcionadas por todos los proveedores principales.

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

Además, para los proveedores de agentes hospedados también puede usar el GetAIAgent método para recuperar un agente de un agente hospedado existente.

AIAgent azureFoundryAgent = await persistentAgentsClient.GetAIAgentAsync(agentId);

3. Creación de subprocesos del agente

Kernel semántico

El autor de la llamada debe conocer el tipo de subproceso y crearlo manualmente.

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

Marco de trabajo del agente

El agente es responsable de crear el subproceso.

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

4. Limpieza de subprocesos del agente hospedado

Este caso se aplica exclusivamente a algunos proveedores de inteligencia artificial que siguen proporcionando subprocesos hospedados.

Kernel semántico

Los subprocesos tienen un self método de eliminación.

Proveedor de asistentes de OpenAI:

await thread.DeleteAsync();

Marco de trabajo del agente

Nota:

Las respuestas de OpenAI introdujeron un nuevo modelo de conversación que simplifica el modo en que se controlan las conversaciones. Este cambio simplifica la administración de subprocesos hospedados en comparación con el modelo ahora en desuso de OpenAI Assistants. Para obtener más información, consulte la guía de migración de OpenAI Assistants.

Agent Framework no tiene una API de eliminación de subprocesos en el AgentThread tipo, ya que no todos los proveedores admiten subprocesos hospedados ni eliminación de subprocesos. Este diseño se volverá más común a medida que más proveedores cambien a las arquitecturas basadas en respuestas.

Si necesita eliminar subprocesos y el proveedor lo permite, el autor de la llamada debe realizar un seguimiento de los subprocesos creados y eliminarlos más adelante cuando sea necesario a través del SDK del proveedor.

Proveedor de asistentes de OpenAI:

await assistantClient.DeleteThreadAsync(thread.ConversationId);

5. Registro de herramientas

Kernel semántico

Para exponer una función como herramienta, debe hacer lo siguiente:

  1. Decora la función con un [KernelFunction] atributo .
  2. Tener una Plugin clase o usar para KernelPluginFactory ajustar la función.
  3. Tener un Kernel para agregar el complemento a.
  4. Pase al Kernel agente.
KernelFunction function = KernelFunctionFactory.CreateFromMethod(GetWeather);
KernelPlugin plugin = KernelPluginFactory.CreateFromFunctions("KernelPluginName", [function]);
Kernel kernel = ... // Create kernel
kernel.Plugins.Add(plugin);

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

Marco de trabajo del agente

En Agent Framework, en una sola llamada puede registrar herramientas directamente en el proceso de creación del agente.

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

6. Invocación de no streaming del agente

Las diferencias clave se pueden ver en los nombres de método de Invoke a Run, tipos devueltos y parámetros AgentRunOptions.

Kernel semántico

El no streaming usa un patrón IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> de streaming para devolver varios mensajes del agente.

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

Marco de trabajo del agente

Non-Streaming devuelve una única AgentRunResponse con la respuesta del agente que puede contener varios mensajes. El resultado de texto de la ejecución está disponible en AgentRunResponse.Text o AgentRunResponse.ToString(). Todos los mensajes creados como parte de la respuesta se devuelven en la AgentRunResponse.Messages lista. Esto puede incluir mensajes de llamada a herramientas, resultados de funciones, actualizaciones de razonamiento y resultados finales.

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

7. Invocación de streaming del agente

Las diferencias clave se encuentran en los nombres de método de Invoke a Run, tipos devueltos y parámetros AgentRunOptions.

Kernel semántico

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

Marco de trabajo del agente

Agent Framework tiene un patrón de API de streaming similar, con la diferencia clave de que devuelve AgentRunResponseUpdate objetos que incluyen más información relacionada con el agente por actualización.

Se devuelven todas las actualizaciones generadas por cualquier servicio subyacente a AIAgent. El resultado textual del agente está disponible mediante la concatenación de los AgentRunResponse.Text valores.

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

8. Firmas de función de herramienta

Problema: los métodos del complemento kernel semántico necesitan [KernelFunction] atributos.

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

Solución: Agent Framework puede usar métodos directamente sin atributos.

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

9. Configuración de opciones

Problema: Configuración de opciones complejas en kernel semántico.

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

Solución: opciones simplificadas en Agent Framework.

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

Importante

En este ejemplo se muestran cómo pasar opciones específicas de la implementación a .ChatClientAgent No todos AIAgents admiten ChatClientAgentRunOptions. ChatClientAgent se proporciona para compilar agentes basados en los servicios de inferencia subyacentes y, por lo tanto, admite opciones de inferencia como MaxOutputTokens.

10. Inserción de dependencias

Kernel semántico

Se requiere un Kernel registro en el contenedor de servicios para poder crear un agente, ya que cada abstracción del agente debe inicializarse con una Kernel propiedad .

El kernel semántico usa el Agent tipo como clase de abstracción base para agentes.

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

Marco de trabajo del agente

Agent Framework proporciona el AIAgent tipo como clase de abstracción base.

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

11. Consolidación de tipos de agente

Kernel semántico

El kernel semántico proporciona clases de agente específicas para varios servicios, por ejemplo:

  • ChatCompletionAgent para su uso con servicios de inferencia basados en la finalización de chat.
  • OpenAIAssistantAgent para su uso con el servicio OpenAI Assistants.
  • AzureAIAgent para su uso con el servicio Azure AI Foundry Agents.

Marco de trabajo del agente

Agent Framework admite todos los servicios mencionados a través de un solo tipo de agente, ChatClientAgent.

ChatClientAgent se puede usar para compilar agentes mediante cualquier servicio subyacente que proporcione un SDK que implemente la IChatClient interfaz.

Diferencias clave

Este es un resumen de las diferencias clave entre el marco del agente de kernel semántico y microsoft Agent Framework para ayudarle a migrar el código.

1. Empaquetar e importar actualizaciones

Kernel semántico

Los paquetes de kernel semántico se instalan como semantic-kernel y se importan como semantic_kernel. El paquete también tiene una serie de extras que puede instalar para instalar las diferentes dependencias para diferentes proveedores de IA y otras características.

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent

Marco de trabajo del agente

El paquete de Agent Framework se instala como agent-framework y se importa como agent_framework. Agent Framework se compila de forma diferente, tiene un paquete agent-framework-core principal que contiene la funcionalidad principal y, a continuación, hay varios paquetes que dependen de ese paquete principal, como agent-framework-azure-ai, agent-framework-mem0, agent-framework-copilotstudioetc. Al ejecutarlo pip install agent-framework --pre , se instalará el paquete principal y todos los paquetes, para que pueda empezar a trabajar rápidamente con todas las características. Cuando esté listo para reducir el número de paquetes porque sabe lo que necesita, solo puede instalar los paquetes que necesita, por ejemplo, si solo tiene previsto usar Azure AI Foundry y Mem0, solo puede instalar esos dos paquetes: pip install agent-framework-azure-ai agent-framework-mem0 --pre, agent-framework-core es una dependencia de esos dos, por lo que se instalará automáticamente.

Aunque los paquetes se dividen, las importaciones proceden de agent_frameworko son módulos. Por lo tanto, por ejemplo, para importar el cliente para Azure AI Foundry, haría lo siguiente:

from agent_framework.azure import AzureAIAgentClient

Muchos de los tipos más usados se importan directamente desde agent_framework:

from agent_framework import ChatMessage, ChatAgent

2. Consolidación de tipos de agente

Kernel semántico

El kernel semántico proporciona clases de agente específicas para varios servicios, por ejemplo, ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent, etc. Consulte Tipos de agente en kernel semántico.

Marco de trabajo del agente

En Agent Framework, la mayoría de los agentes se crean con el ChatAgent que se puede usar con todos los ChatClient servicios basados, como Azure AI Foundry, OpenAI ChatCompletion y Respuestas de OpenAI. Hay dos agentes adicionales: CopilotStudioAgent para su uso con Copilot Studio y A2AAgent para su uso con A2A.

Todos los agentes integrados se basan en BaseAgent (from agent_framework import BaseAgent). Y todos los agentes son coherentes con la AgentProtocol interfaz (from agent_framework import AgentProtocol).

3. Simplificación de la creación del agente

Kernel semántico

Cada agente del kernel semántico depende de una Kernel instancia y tendrá un vacío Kernel si no se proporciona.

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

Marco de trabajo del agente

La creación del agente en Agent Framework se puede realizar de dos maneras, directamente:

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

O bien, con los métodos de conveniencia proporcionados por los clientes de chat:

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

El método directo expone todos los parámetros posibles que puede establecer para el agente. Aunque el método de conveniencia tiene un subconjunto, todavía puede pasar el mismo conjunto de parámetros, ya que llama al método directo internamente.

4. Creación de subprocesos del agente

Kernel semántico

El autor de la llamada debe conocer el tipo de subproceso y crearlo manualmente.

from semantic_kernel.agents import ChatHistoryAgentThread

thread = ChatHistoryAgentThread()

Marco de trabajo del agente

Se le puede pedir al agente que cree un nuevo subproceso.

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

A continuación, se crea un subproceso de tres maneras:

  1. Si el agente tiene establecido thread_id (o conversation_id algo similar), creará un subproceso en el servicio subyacente con ese identificador. Una vez que un subproceso tiene , service_thread_idya no se puede usar para almacenar mensajes en la memoria. Esto solo se aplica a los agentes que tienen un concepto de subproceso del lado del servicio. como agentes de Azure AI Foundry y asistentes de OpenAI.
  2. Si el agente tiene un chat_message_store_factory conjunto, usará esa factoría para crear un almacén de mensajes y usarlo para crear un subproceso en memoria. A continuación, ya no se puede usar con un agente con el store parámetro establecido Trueen .
  3. Si no se establece ninguna de las configuraciones anteriores, se considera uninitialized y depende de cómo se use, se convertirá en un subproceso en memoria o en un subproceso de servicio.

Marco de trabajo del agente

Nota:

Las respuestas de OpenAI introdujeron un nuevo modelo de conversación que simplifica el modo en que se controlan las conversaciones. Esto simplifica la administración de subprocesos hospedados en comparación con el modelo ahora en desuso de OpenAI Assistants. Para obtener más información, consulte la guía de migración de OpenAI Assistants.

Agent Framework no tiene una API de eliminación de subprocesos en el AgentThread tipo, ya que no todos los proveedores admiten subprocesos hospedados o eliminación de subprocesos y esto se volverá más común a medida que más proveedores cambien a las arquitecturas basadas en respuestas.

Si necesita eliminar subprocesos y el proveedor lo permite, el autor de la llamada debe realizar un seguimiento de los subprocesos creados y eliminarlos más adelante cuando sea necesario a través del SDK del proveedor.

Proveedor de asistentes de OpenAI:

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

5. Registro de herramientas

Kernel semántico

Para exponer una función como herramienta, debe hacer lo siguiente:

  1. Decora la función con un @kernel_function decorador.
  2. Tener una Plugin clase o usar el generador de complementos de kernel para ajustar la función.
  3. Tener un Kernel para agregar el complemento a.
  4. Pase al Kernel agente.
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()],
)

Marco de trabajo del agente

En una sola llamada, puede registrar herramientas directamente en el proceso de creación del agente. Agent Framework no tiene el concepto de un complemento para encapsular varias funciones, pero todavía puede hacerlo si lo desea.

La manera más sencilla de crear una herramienta es simplemente crear una función de 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)

Nota:

El tools parámetro está presente tanto en la creación del agente, en los run métodos y run_stream como en los get_response métodos y get_streaming_response , permite proporcionar herramientas como una lista o una sola función.

A continuación, el nombre de la función se convertirá en el nombre de la herramienta y docstring se convertirá en la descripción de la herramienta; también puede agregar una descripción a los parámetros:

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

Por último, puede usar el decorador para personalizar aún más el nombre y la descripción de la herramienta:

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

Esto también funciona cuando se crea una clase con varias herramientas como métodos.

Al crear el agente, ahora puede proporcionar la herramienta de función al agente pasándola al tools parámetro .

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)

Nota:

Las funciones de la clase también se pueden decorar con @ai_function para personalizar el nombre y la descripción de las herramientas.

Este mecanismo también es útil para las herramientas que necesitan una entrada adicional que el LLM no puede proporcionar, como conexiones, secretos, etc.

Compatibilidad: uso de KernelFunction como herramientas de Agent Framework

Si tiene código kernel semántico existente con KernelFunction instancias (ya sea desde mensajes o desde métodos), puede convertirlos a herramientas de Agent Framework mediante el .as_agent_framework_tool método .

Importante

Esta característica requiere semantic-kernel la versión 1.38 o posterior.

Uso de KernelFunction desde una plantilla de solicitud

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)

Uso de KernelFunction desde un método

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)

Uso de VectorStore con create_search_function

También puede usar las integraciones de VectorStore del kernel semántico con Agent Framework. El create_search_function método de una colección de almacenes vectoriales devuelve un KernelFunction objeto que se puede convertir en una herramienta de 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)

Este patrón funciona con cualquier conector de VectorStore de kernel semántico (Azure AI Search, Qdrant, Pinecone, etc.), lo que le permite aprovechar la infraestructura de búsqueda vectorial existente con agentes de Agent Framework.

Esta capa de compatibilidad le permite migrar gradualmente el código de Kernel semántico a Agent Framework, reutilizando las implementaciones existentes KernelFunction mientras aprovecha los patrones simplificados de creación y ejecución del agente Framework.

6. Invocación de no streaming del agente

Las diferencias clave se pueden ver en los nombres de método de invoke a run, tipos devueltos (por ejemplo, AgentRunResponse) y parámetros.

Kernel semántico

La invocación que no es streaming usa un patrón de iterador asincrónico para devolver varios mensajes del agente.

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

Y hubo un método de conveniencia para obtener la respuesta final:

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

Marco de trabajo del agente

La ejecución sin streaming devuelve una única AgentRunResponse con la respuesta del agente que puede contener varios mensajes. El resultado de texto de la ejecución está disponible en response.text o str(response). Todos los mensajes creados como parte de la respuesta se devuelven en la response.messages lista. Esto puede incluir mensajes de llamada a herramientas, resultados de funciones, actualizaciones de razonamiento y resultados finales.

agent = ...

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

7. Invocación de streaming del agente

Diferencias clave en los nombres de método de invoke a run_stream, tipos devueltos (AgentRunResponseUpdate) y parámetros.

Kernel semántico

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)

Marco de trabajo del agente

Un patrón de API de streaming similar con la diferencia clave es que devuelve AgentRunResponseUpdate objetos que incluyen más información relacionada con el agente por actualización.

Se devuelve todo el contenido generado por cualquier servicio subyacente al Agente. El resultado final del agente está disponible mediante la combinación de los update valores en una única respuesta.

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)

Incluso puede hacerlo directamente:

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. Configuración de opciones

Problema: Configuración de opciones complejas en kernel semántico

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)

Solución: opciones simplificadas en Agent Framework

Agent Framework permite pasar todos los parámetros directamente a los métodos pertinentes, de modo que no tenga que importar nada adicional ni crear objetos de opciones, a menos que desee. Internamente, usa un ChatOptions objeto para ChatClients y ChatAgents, que también puede crear y pasar si desea. Esto también se crea en para ChatAgent contener las opciones y se puede invalidar por llamada.

agent = ...

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

Nota:

Lo anterior es específico de , ChatAgentya que otros agentes pueden tener diferentes opciones, todos deben aceptarse messages como parámetro, ya que se define en .AgentProtocol

Pasos siguientes

Guía de inicio rápido

  • Last updated on