Microsoft Intro to AI Agent: Exploración del marco del agente de IA

Los marcos de agentes de IA son plataformas de software diseñadas para simplificar la creación, despliegue y gestión de agentes de IA. Estos marcos proporcionan a los desarrolladores componentes, abstracciones y herramientas preconstruidos para simplificar el desarrollo de sistemas de IA complejos.

Estos marcos ayudan a los desarrolladores a centrarse en los aspectos exclusivos de sus aplicaciones proporcionando un enfoque estandarizado para los retos comunes en el desarrollo de agentes de IA. Mejoran la escalabilidad, accesibilidad y eficiencia de la creación de sistemas de IA.

breve

Este curso abarcará:

• ¿Qué son los marcos de agentes de IA y qué permiten hacer a los desarrolladores?
• ¿Cómo pueden los equipos utilizar estos marcos para crear rápidamente prototipos, iterar y mejorar las capacidades del Agente?
• ¿Cuál es la diferencia entre los marcos y herramientas creados por Microsoft AutoGen, Semantic Kernel y Azure AI Agent?
• ¿Es posible integrarlo directamente con las herramientas existentes del ecosistema Azure o necesito una solución independiente?
• ¿Qué es el servicio Azure AI Agents y cómo puede ayudar?

objetivo de aprendizaje

El objetivo de este curso es ayudarle a comprender:

• El papel de los marcos de agentes de IA en el desarrollo de la IA.
• Cómo construir agentes inteligentes con el AI Agent Framework.
• Características clave implementadas por el marco del Agente AI.
• Diferencias entre AutoGen, Semantic Kernel y Azure AI Agent Service.

¿Qué son los marcos de agentes de IA y qué permiten hacer a los desarrolladores?

Los marcos tradicionales de IA pueden ayudarle a integrar la IA en sus aplicaciones y mejorarlas:

• personalizadoLa IA puede analizar el comportamiento y las preferencias de los usuarios para ofrecerles recomendaciones, contenidos y experiencias personalizados. Por ejemplo, servicios de streaming como Netflix utilizan la IA para recomendar películas y programas basándose en el historial de visionado para aumentar el compromiso y la satisfacción del usuario.
• Automatización y eficaciaLa IA puede automatizar tareas repetitivas, agilizar los flujos de trabajo y mejorar la eficiencia operativa. Por ejemplo, las aplicaciones de atención al cliente utilizan chatbots basados en IA para gestionar consultas comunes, lo que reduce los tiempos de respuesta y permite a los agentes humanos gestionar cuestiones más complejas.
• Experiencia de usuario mejoradaLa IA puede mejorar la experiencia general del usuario proporcionando funciones inteligentes como el reconocimiento de voz, el procesamiento del lenguaje natural y el texto predictivo. Por ejemplo, asistentes virtuales como Siri y Google Assistant utilizan IA para comprender y responder a comandos de voz, facilitando a los usuarios la interacción con sus dispositivos.

Todo esto suena muy bien, ¿verdad? Entonces, ¿por qué necesitamos un marco para agentes de IA?

Los marcos de agentes de IA son algo más que marcos de IA. Están diseñados para crear agentes inteligentes que puedan interactuar con los usuarios, otros agentes y el entorno para alcanzar objetivos específicos, y que puedan mostrar un comportamiento autónomo, tomar decisiones y adaptarse a condiciones cambiantes. Echemos un vistazo a algunas de las características clave implementadas por los marcos de agentes de IA:

• Agente Colaboración y coordinaciónPermite la creación de múltiples agentes de IA que pueden trabajar juntos, comunicarse y coordinarse para resolver tareas complejas.
• Automatización y gestión de tareasFunciones: Proporciona mecanismos para automatizar flujos de trabajo de varios pasos, delegación de tareas y gestión dinámica de tareas entre Agentes.
• Comprensión del contexto y adaptaciónPermite al agente comprender el contexto, adaptarse a entornos cambiantes y tomar decisiones basadas en información en tiempo real.

En resumen, los Agentes le permiten hacer más, llevar la automatización al siguiente nivel y crear sistemas más inteligentes que pueden adaptarse y aprender de su entorno.

¿Cómo puedo crear rápidamente prototipos, iterar y mejorar las capacidades del Agente?

Se trata de un campo en rápida evolución, pero la mayoría de los marcos de trabajo para agentes de IA tienen algunas cosas en común que pueden ayudarle a crear prototipos e iterar con rapidez: componentes modulares, herramientas de colaboración y aprendizaje en tiempo real. Analicémoslos:

• Uso de componentes modularesEl marco de la IA proporciona componentes predefinidos como sugerencias, analizadores sintácticos y gestión de memoria.
• Uso de herramientas de colaboraciónAgentes de diseño con funciones y tareas específicas para que puedan probar y mejorar los flujos de trabajo colaborativos.
• Aprendizaje en tiempo realSe consigue un bucle de retroalimentación en el que el Agente aprende de la interacción y adapta dinámicamente su comportamiento.

Uso de componentes modulares

Frameworks como LangChain y Microsoft Semantic Kernel proporcionan componentes preconstruidos como sugerencias, analizadores sintácticos y gestión de memoria.

¿Cómo utilizan los equipos estosLos equipos pueden ensamblar rápidamente estos componentes para crear un prototipo funcional sin tener que empezar desde cero, lo que permite una rápida experimentación e iteración.

Cómo funciona en la prácticaLos módulos de memoria permiten almacenar y recuperar datos, mientras que los generadores de mensajes permiten interactuar con los usuarios sin tener que crearlos desde cero.

código de ejemplo (informática). Veamos un ejemplo de cómo extraer información de la entrada del usuario utilizando un analizador pre-construido:

// Semantic Kernel 示例
ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go To New York");
// 定义一个包含预订旅行功能的插件
public class BookTravelPlugin(
IPizzaService pizzaService,
IUserContext userContext,
IPaymentService paymentService)
{
[KernelFunction("book_flight")]
[Description("Book travel given location and date")]
public async Task<Booking> BookFlight(
DateTime date,
string location,
)
{
// 根据日期、地点预订旅行
}
}
IKernelBuilder kernelBuilder = new KernelBuilder();
kernelBuilder..AddAzureOpenAIChatCompletion(
deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
apiKey: "YOUR_API_KEY",
endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel");
Kernel kernel = kernelBuilder.Build();
/*
在后台，它识别要调用的工具、它已经具有的参数 (location) 和它需要的参数 (date)
{
"tool_calls": [
{
"id": "call_abc123",
"type": "function",
"function": {
"name": "BookTravelPlugin-book_flight",
"arguments": "{\n\"location\": \"New York\",\n\"date\": \"\"\n}"
}
}
]
*/
ChatResponse response = await chatCompletion.GetChatMessageContentAsync(
chatHistory,
executionSettings: openAIPromptExecutionSettings,
kernel: kernel)
Console.WriteLine(response);
chatHistory.AddAssistantMessage(response);
// AI 响应："Before I can book your flight, I need to know your departure date. When are you planning to travel?"
// 也就是说，在前面的代码中，它找出了要调用的工具，它已经拥有的参数 (location) 以及它从用户输入中需要的参数 (date)，此时它最终会向用户询问缺失的信息

En este ejemplo se puede ver cómo se puede utilizar un analizador sintáctico predefinido para extraer información clave de los datos introducidos por el usuario, como el origen, el destino y la fecha de una solicitud de reserva de vuelo. Este enfoque modular permite centrarse en la lógica de alto nivel.

Uso de herramientas de colaboración

CrewAI y Microsoft AutoGen Marcos como éste facilitan la creación de múltiples Agentes que pueden trabajar juntos.

¿Cómo utilizan los equipos estosLos equipos pueden diseñar Agentes con funciones y tareas específicas, lo que les permite probar y mejorar los flujos de trabajo colaborativos y aumentar la eficacia general del sistema.

Cómo funciona en la prácticaAgentes: puede crear un equipo de Agentes, cada uno de los cuales tiene una función especializada, como la recuperación de datos, el análisis o la toma de decisiones. Estos Agentes pueden comunicarse y compartir información para alcanzar objetivos comunes, como responder a las consultas de los usuarios o completar tareas.

Código de ejemplo (AutoGen)::

# 创建 Agent，然后创建一个循环调度，让他们可以协同工作，在本例中是按顺序
# 数据检索 Agent
# 数据分析 Agent
# 决策 Agent
agent_retrieve = AssistantAgent(
name="dataretrieval",
model_client=model_client,
tools=[retrieve_tool],
system_message="Use tools to solve tasks."
)
agent_analyze = AssistantAgent(
name="dataanalysis",
model_client=model_client,
tools=[analyze_tool],
system_message="Use tools to solve tasks."
)
# 当用户说 "APPROVE" 时，对话结束
termination = TextMentionTermination("APPROVE")
user_proxy = UserProxyAgent("user_proxy", input_func=input)
team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)
stream = team.run_stream(task="Analyze data", max_turns=10)
# 在脚本中运行时使用 asyncio.run(...)。
await Console(stream)

Lo que ha visto en el código anterior es cómo crear una tarea que implica a varios Agentes trabajando juntos para analizar datos. Cada Agente realiza una función específica y coordina a los Agentes para que realicen la tarea y consigan los resultados deseados. Al crear Agentes dedicados con funciones especializadas, puede mejorar la eficacia y el rendimiento de la tarea.

Aprendizaje en tiempo real

El Marco Avanzado proporciona comprensión y adaptación contextual en tiempo real.

Cómo utilizan los equipos estos marcosLos equipos pueden implantar circuitos de retroalimentación que permitan a los Agentes aprender de las interacciones y ajustar dinámicamente sus comportamientos, lo que conduce a una mejora y un perfeccionamiento continuos de las capacidades.

aplicación prácticaLos Agentes pueden analizar los comentarios de los usuarios, los datos del entorno y los resultados de las tareas para actualizar su base de conocimientos, adaptar los algoritmos de toma de decisiones y mejorar su rendimiento a lo largo del tiempo. Este proceso de aprendizaje iterativo permite a los Agentes adaptarse a las condiciones cambiantes y a las preferencias de los usuarios, mejorando así la eficiencia global del sistema.

¿Cuál es la diferencia entre AutoGen, Semantic Kernel y el marco Azure AI Agent Service?

Hay muchas maneras de comparar estos marcos, pero veamos algunas diferencias clave en cuanto a su diseño, funcionalidad y casos de uso objetivo:

AutoGen

Marco de código abierto desarrollado por el laboratorio AI Frontiers de Microsoft Research. Se centra en sistemas distribuidos agentic Aplicaciones compatibles con múltiples modelos de grandes lenguajes (LLM) y SLM, herramientas y patrones avanzados de diseño multiagente.

El concepto central de AutoGen son los agentes, entidades autónomas que pueden percibir su entorno, tomar decisiones y emprender acciones para alcanzar objetivos específicos. Los agentes se comunican mediante mensajería asíncrona, lo que les permite trabajar de forma independiente y en paralelo, aumentando así la escalabilidad y capacidad de respuesta del sistema.

Los agentes se basan en modelos de actores. Según Wikipedia, actor es Los componentes básicos de la computación concurrente. En respuesta a un mensaje entrante, un actor puede: tomar decisiones locales, crear más actores, enviar más mensajes y determinar cómo responder al siguiente mensaje entrante..

caso práctico: Automatice la generación de código, las tareas de análisis de datos y cree inteligencias personalizadas (Agentes) para las funciones de planificación e investigación.

Estos son algunos de los conceptos básicos de AutoGen:

• Agentes. Un organismo inteligente (Agente) es una entidad de software que:
  • Comunicación mediante mensajesEstos mensajes pueden ser síncronos o asíncronos.
  • Mantener el propio estatusEste estado puede ser modificado por los mensajes entrantes.
  • operación ejecutable en respuesta a un mensaje recibido o a un cambio en su estado. Estas acciones pueden modificar el estado del Agente y tener efectos externos, como actualizar el registro de mensajes, enviar nuevos mensajes, ejecutar código o realizar llamadas a la API.

  A continuación se muestra un breve fragmento de código en el que puede crear un Agente con funcionalidad de chat:

  from autogen_agentchat.agents import AssistantAgent
  from autogen_agentchat.messages import TextMessage
  from autogen_ext.models.openai import OpenAIChatCompletionClient
  class MyAssistant(RoutedAgent):
  def __init__(self, name: str) -> None:
  super().__init__(name)
  model_client = OpenAIChatCompletionClient(model="gpt-4o")
  self._delegate = AssistantAgent(name, model_client=model_client)
      @message_handler
  async def handle_my_message_type(self, message: MyMessageType, ctx: MessageContext) -> None:
  print(f"{self.id.type} received message: {message.content}")
  response = await self._delegate.on_messages(
  [TextMessage(content=message.content, source="user")], ctx.cancellation_token
  )
  print(f"{self.id.type} responded: {response.chat_message.content}")
  

  En el código anterior, elMyAssistant se ha creado y heredado de RoutedAgent. Tiene un manejador de mensajes que imprime el contenido del mensaje y luego utiliza la función AssistantAgent Delegar el envío de la respuesta. Presta especial atención a cómo estamos delegando el AssistantAgent La instancia del self._delegate(matemáticas) géneroAssistantAgent es una inteligencia pre-construida (Agente) que puede manejar la complementación del chat.
  A continuación, comunique a AutoGen el tipo de Agente e inicie el programa:

  # main.py
  runtime = SingleThreadedAgentRuntime()
  await MyAgent.register(runtime, "my_agent", lambda: MyAgent())
  runtime.start()  # Start processing messages in the background.
  await runtime.send_message(MyMessageType("Hello, World!"), AgentId("my_agent", "default"))
  

  En el código anterior, los Agentes se registran con el runtime, y luego se envían mensajes al Agente, que produce la siguiente salida:

  # Output from the console:
  my_agent received message: Hello, World!
  my_assistant received message: Hello, World!
  my_assistant responded: Hello! How can I assist you today?
  

• MultiagentesAutoGen permite la creación de múltiples Agentes que pueden trabajar juntos para realizar tareas complejas. Los Agentes pueden comunicarse, compartir información y coordinar sus acciones para resolver problemas con mayor eficacia. Para crear un sistema Multi-Agente, se definen diferentes tipos de Agentes con funciones y roles especializados, como la recuperación de datos, el análisis, la toma de decisiones y la interacción con el usuario. Veamos qué aspecto tiene una creación de este tipo para poder entenderla:

editor_description = "Editor for planning and reviewing the content."
# Example of declaring an Agent
editor_agent_type = await EditorAgent.register(
runtime,
editor_topic_type,  # Using topic type as the agent type.
lambda: EditorAgent(
description=editor_description,
group_chat_topic_type=group_chat_topic_type,
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
),
)
# remaining declarations shortened for brevity
# Group chat
group_chat_manager_type = await GroupChatManager.register(
runtime,
"group_chat_manager",
lambda: GroupChatManager(
participant_topic_types=[writer_topic_type, illustrator_topic_type, editor_topic_type, user_topic_type],
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
participant_descriptions=[
writer_description, 
illustrator_description, 
editor_description, 
user_description
],
),
)

En el código anterior, tenemos un GroupChatManagerSe registra en el tiempo de ejecución. Este gestor se encarga de coordinar las interacciones entre los distintos tipos de Agentes, como escritores, ilustradores, editores y usuarios.

• Tiempo de ejecución del agenteEl marco proporciona un entorno de ejecución que soporta la comunicación entre Agentes y refuerza los límites de seguridad y privacidad. El marco proporciona un entorno de ejecución que admite la comunicación entre Agentes, gestiona su identidad y ciclo de vida, y aplica límites de seguridad y privacidad. Esto significa que puede ejecutar sus Agentes en un entorno seguro y controlado, garantizando que puedan interactuar de forma segura y eficiente. Hay dos tiempos de ejecución de interés:
  • Tiempo de ejecución autónomo。对于单进程应用程序来说，这是一个不错的选择，其中所有智能体 (Agents) 都以相同的编程语言实现并在同一进程中运行。下面是它如何工作的图示：
    Stand-alone runtime
    应用程序堆栈
    智能体 (Agents) 通过运行时通过消息进行通信，运行时管理智能体 (Agents) 的生命周期
  • 分布式智能体运行时 (Distributed agent runtime)，适用于多进程应用程序，其中智能体 (Agents) 可以用不同的编程语言实现并在不同的机器上运行。下面是它如何工作的图示：
    Distributed runtime

Semantic Kernel + Agent Framework

Semantic Kernel 包含两个部分，Semantic Kernel Agent Framework 和 Semantic Kernel 本身。

让我们先谈谈 Semantic Kernel。它具有以下核心概念：

• 连接 (Connections)：这是与外部 AI 服务和数据源的接口。

using Microsoft.SemanticKernel;
// Create kernel
var builder = Kernel.CreateBuilder();
// Add a chat completion service:
builder.Services.AddAzureOpenAIChatCompletion(
"your-resource-name",
"your-endpoint",
"your-resource-key",
"deployment-model");
var kernel = builder.Build();

这里有一个简单的示例，说明如何创建内核并添加聊天补全服务。Semantic Kernel 创建与外部 AI 服务（在本例中为 Azure OpenAI 聊天补全）的连接。

• 插件 (Plugins)：封装应用程序可以使用的函数。既有现成的插件，也有您可以自己创建的插件。这里有一个名为“语义函数 (Semantic functions)”的概念。使其具有语义的原因是，您向其提供语义信息，以帮助 Semantic Kernel 确定需要调用此函数。下面是一个示例：

var userInput = Console.ReadLine();
// Define semantic function inline.
string skPrompt = @"Summarize the provided unstructured text in a sentence that is easy to understand.
Text to summarize: {{$userInput}}";
// Register the function
kernel.CreateSemanticFunction(
promptTemplate: skPrompt,
functionName: "SummarizeText",
pluginName: "SemanticFunctions"
);

在这里，您首先有一个模板提示 skPrompt，它为用户留出输入文本 $userInput 的空间。然后，您使用插件 SemanticFunctions 注册函数 SummarizeText。请注意函数的名称，该名称有助于 Semantic Kernel 了解函数的作用以及何时应调用它。

• 本机函数 (Native function)：还有本机函数，框架可以直接调用这些函数来执行任务。下面是此类函数从文件中检索内容的示例：

public class NativeFunctions {
[SKFunction, Description("Retrieve content from local file")]
public async Task<string> RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName);
if (content.Length <= maxSize) return content;
return content.Substring(0, maxSize);
}
}
//Import native function
string plugInName = "NativeFunction";
string functionName = "RetrieveLocalFile";
var nativeFunctions = new NativeFunctions();
kernel.ImportFunctions(nativeFunctions, plugInName);

• 规划器 (Planner)：规划器根据用户输入编排执行计划和策略。其思想是表达应该如何执行，然后将其作为 Semantic Kernel 遵循的指令。然后，它调用必要的函数来执行任务。下面是此类计划的示例：

string planDefinition = "Read content from a local file and summarize the content.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel);
string assetsFolder = @"../../assets";
string fileName = Path.Combine(assetsFolder,"docs","06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName);
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition);
// Execute the plan
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan);
Console.WriteLine($"Summarization: {kernelResult.GetValue<string>()}");

特别注意 planDefinition，这是规划器遵循的简单指令。然后根据此计划调用适当的函数，在本例中是我们的语义函数 SummarizeText 和本机函数 RetrieveLocalFile.

• 内存 (Memory)：抽象并简化 AI 应用程序的上下文管理。内存的思想是这是大语言模型 (LLM) 应该知道的东西。您可以将此信息存储在向量存储中，最终成为内存数据库或向量数据库或类似的东西。下面是一个非常简化的场景示例，其中 事实 (facts) 被添加到内存中：

var facts = new Dictionary<string,string>();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/azure/machine-learning/",
@"Azure Machine Learning is a cloud service for accelerating and
managing the machine learning project lifecycle. Machine learning professionals,
data scientists, and engineers can use it in their day-to-day workflows"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/azure/azure-sql/",
@"Azure SQL is a family of managed, secure, and intelligent products
that use the SQL Server database engine in the Azure cloud."
);
string memoryCollectionName = "SummarizedAzureDocs";
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
collection: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value,
externalId: fact.Key.Split(";")[2].Trim(),
externalSourceName: "Azure Documentation"
);
}

然后，这些事实 (facts) 存储在内存集合 SummarizedAzureDocs 中。这是一个非常简化的示例，但您可以看到如何将信息存储在内存中以供大语言模型 (LLM) 使用。

这就是 Semantic Kernel 框架的基础知识，那么 Agent Framework 呢？

Azure AI Agent Service

Azure AI Agent Service 是一个较新的成员，在 Microsoft Ignite 2024 上推出。它允许开发和部署具有更灵活模型的 AI 智能体 (Agents)，例如直接调用开源大语言模型 (LLMs)，如 Llama 3、Mistral 和 Cohere。

Azure AI Agent Service 提供了更强大的企业安全机制和数据存储方法，使其适用于企业应用程序。

它可以与 AutoGen 和 Semantic Kernel 等多智能体 (Multi-Agent) 编排框架开箱即用。

此服务目前处于公开预览阶段，支持 Python 和 C# 来构建智能体 (Agents)

核心概念

Azure AI Agent Service 具有以下核心概念：

• 智能体 (Agent)。Azure AI Agent Service 与 Azure AI Foundry 集成。在 AI Foundry 中，AI 智能体 (Agent) 充当“智能”微服务，可用于回答问题 (RAG)、执行操作或完全自动化工作流程。它通过将生成式 AI 模型的功能与允许其访问和与真实世界数据源交互的工具相结合来实现这一点。下面是一个智能体 (Agent) 的示例：

agent = project_client.agents.create_agent(
model="gpt-4o-mini",
name="my-agent",
instructions="You are helpful agent",
tools=code_interpreter.definitions,
tool_resources=code_interpreter.resources,
)

在此示例中，创建了一个具有模型 gpt-4o-mini、名称 my-agent 和指令 You are helpful agent 的智能体 (Agent)。该智能体 (Agent) 配备了工具和资源来执行代码解释任务。

• 线程和消息 (Thread and messages)。线程是另一个重要的概念。它表示智能体 (Agent) 和用户之间的对话或交互。线程可用于跟踪对话进度、存储上下文信息以及管理交互状态。下面是一个线程的示例：

thread = project_client.agents.create_thread()
message = project_client.agents.create_message(
thread_id=thread.id,
role="user",
content="Could you please create a bar chart for the operating profit using the following data and provide the file to me? Company A: $1.2 million, Company B: $2.5 million, Company C: $3.0 million, Company D: $1.8 million",
)
# Ask the agent to perform work on the thread
run = project_client.agents.create_and_process_run(thread_id=thread.id, agent_id=agent.id)
# Fetch and log all messages to see the agent's response
messages = project_client.agents.list_messages(thread_id=thread.id)
print(f"Messages: {messages}")

在前面的代码中，创建了一个线程。此后，向线程发送一条消息。通过调用 create_and_process_run，要求智能体 (Agent) 在线程上执行工作。最后，获取并记录消息以查看智能体 (Agent) 的响应。消息指示用户和智能体 (Agent) 之间对话的进度。同样重要的是要理解，消息可以是不同的类型，例如文本、图像或文件，即智能体 (Agents) 的工作导致了例如图像或文本响应。作为开发人员，您可以使用此信息来进一步处理响应或将其呈现给用户。

• 与其他 AI 框架集成。Azure AI Agent Service 可以与其他框架（如 AutoGen 和 Semantic Kernel）进行交互，这意味着您可以在其中一个框架中构建应用程序的一部分，例如将 Agent Service 用作编排器，或者您可以在 Agent Service 中构建所有内容。

caso práctico：Azure AI Agent Service 专为需要安全、可扩展和灵活的 AI 智能体 (Agent) 部署的企业应用程序而设计。

这些框架之间有什么区别？

听起来这些框架之间有很多重叠，但在它们的设计、功能和目标用例方面存在一些关键差异：

• AutoGen：专注于事件驱动、分布式的 agentic 应用程序，支持多个大语言模型 (LLMs) 和 SLM、工具以及高级多智能体 (Multi-Agent) 设计模式。
• Semantic Kernel：专注于通过捕获更深层次的语义含义来理解和生成类似人类的文本内容。它旨在自动化复杂的工作流程并根据项目目标启动任务。
• Azure AI Agent Service：提供更灵活的模型，例如直接调用开源大语言模型 (LLMs)，如 Llama 3、Mistral 和 Cohere。它提供更强大的企业安全机制和数据存储方法，使其适用于企业应用程序。

仍然不确定选择哪一个？

caso práctico

让我们通过一些常见的用例来看看我们是否可以帮助您：

问：我的团队正在开发一个涉及自动化代码生成和数据分析任务的项目。我们应该使用哪个框架？

答：AutoGen 在这种情况下是一个不错的选择，因为它专注于事件驱动、分布式的 agentic 应用程序，并支持高级多智能体 (Multi-Agent) 设计模式。

问：对于此用例，是什么让 AutoGen 比 Semantic Kernel 和 Azure AI Agent Service 更好？

答：AutoGen 专为事件驱动、分布式的 agentic 应用程序而设计，使其非常适合自动化代码生成和数据分析任务。它提供了高效构建复杂多智能体 (Multi-Agent) 系统所需的工具和功能。

问：听起来 Azure AI Agent Service 在这里也可以工作，它有代码生成等工具？

答：是的，Azure AI Agent Service 也支持代码生成和数据分析任务，但它可能更适合需要安全、可扩展和灵活的 AI 智能体 (Agent) 部署的企业应用程序。AutoGen 更专注于事件驱动、分布式的 agentic 应用程序和高级多智能体 (Multi-Agent) 设计模式。

问：所以你是说如果我想进入企业级，我应该选择 Azure AI Agent Service？

答：是的，Azure AI Agent Service 专为需要安全、可扩展和灵活的 AI 智能体 (Agent) 部署的企业应用程序而设计。它提供更强大的企业安全机制和数据存储方法，使其适用于企业用例。

让我们在表格中总结一下关键区别：

这些框架中每一个的理想用例是什么？

• AutoGen：事件驱动、分布式的 agentic 应用程序，高级多智能体 (Multi-Agent) 设计模式。非常适合自动化代码生成、数据分析任务。
• Semantic Kernel：理解和生成类人文本内容，自动化复杂的工作流程，根据项目目标启动任务。非常适合自然语言理解、内容生成。
• Azure AI Agent Service：灵活的模型、企业安全机制、数据存储方法。非常适合在企业应用程序中进行安全、可扩展和灵活的 AI 智能体 (Agent) 部署。

我可以直接集成我现有的 Azure 生态系统工具，还是需要独立的解决方案？

答案是肯定的，您可以直接将现有的 Azure 生态系统工具与 Azure AI Agent Service 集成，特别是因为它旨在与其他 Azure 服务无缝协作。例如，您可以集成 Bing、Azure AI 搜索和 Azure Functions。还与 Azure AI Foundry 进行了深度集成。

对于 AutoGen 和 Semantic Kernel，您也可以与 Azure 服务集成，但这可能需要您从代码中调用 Azure 服务。另一种集成方法是使用 Azure SDK 从您的智能体 (Agents) 与 Azure 服务进行交互。此外，如前所述，您可以使用 Azure AI Agent Service 作为在 AutoGen 或 Semantic Kernel 中构建的智能体 (Agents) 的编排器，这将使您可以轻松访问 Azure 生态系统。