Introdução ao agente de IA da Microsoft: explorando a estrutura do agente de IA

As estruturas do AI Agent são plataformas de software projetadas para simplificar a criação, a implantação e o gerenciamento de AI Agents. Essas estruturas fornecem aos desenvolvedores componentes pré-construídos, abstrações e ferramentas para simplificar o desenvolvimento de sistemas complexos de IA.

Essas estruturas ajudam os desenvolvedores a se concentrarem nos aspectos exclusivos de seus aplicativos, fornecendo uma abordagem padronizada para desafios comuns no desenvolvimento de agentes de IA. Eles aumentam a escalabilidade, a acessibilidade e a eficiência da criação de sistemas de IA.

breve

Este curso abrangerá:

• O que são estruturas de agentes de IA e o que elas permitem que os desenvolvedores façam?
• Como as equipes podem usar essas estruturas para criar rapidamente protótipos, iterar e aprimorar os recursos do Agente?
• Qual é a diferença entre as estruturas e ferramentas criadas pelo Microsoft AutoGen, Semantic Kernel e Azure AI Agent?
• É possível integrar-se diretamente às ferramentas existentes do ecossistema do Azure ou preciso de uma solução autônoma?
• O que é o serviço Azure AI Agents e como ele pode ajudar?

meta de aprendizado

O objetivo deste curso é ajudá-lo a entender:

• A função das estruturas de agentes de IA no desenvolvimento de IA.
• Como criar agentes inteligentes com a AI Agent Framework.
• Principais recursos implementados pela estrutura do AI Agent.
• Diferenças entre AutoGen, Semantic Kernel e Azure AI Agent Service.

O que são estruturas de agentes de IA e o que elas permitem que os desenvolvedores façam?

As estruturas tradicionais de IA podem ajudá-lo a integrar a IA em seus aplicativos e torná-los melhores:

• personalizadoIA: a IA pode analisar o comportamento e as preferências do usuário para oferecer recomendações, conteúdo e experiências personalizados. Por exemplo, serviços de streaming como a Netflix usam a IA para recomendar filmes e programas com base no histórico de visualização para aumentar o envolvimento e a satisfação do usuário.
• Automação e eficiênciaA IA pode automatizar tarefas repetitivas, otimizar fluxos de trabalho e melhorar a eficiência operacional. Por exemplo, os aplicativos de atendimento ao cliente usam chatbots orientados por IA para lidar com consultas comuns, reduzindo os tempos de resposta e permitindo que os agentes humanos lidem com problemas mais complexos.
• Experiência aprimorada do usuárioIA: a IA pode melhorar a experiência geral do usuário fornecendo recursos inteligentes, como reconhecimento de fala, processamento de linguagem natural e texto preditivo. Por exemplo, assistentes virtuais como a Siri e o Google Assistant usam IA para entender e responder a comandos de voz, facilitando a interação dos usuários com seus dispositivos.

Tudo isso parece ótimo, certo? Então, por que precisamos de uma estrutura de agente de IA?

As estruturas de agentes de IA são mais do que simples estruturas de IA. Elas são projetadas para criar agentes inteligentes que podem interagir com o usuário, com outros agentes e com o ambiente para atingir objetivos específicos e que podem apresentar comportamento autônomo, tomar decisões e se adaptar às mudanças nas condições. Vamos dar uma olhada em alguns dos principais recursos implementados pelas estruturas de agentes de IA:

• Colaboração e coordenação de agentesSuporte à criação de vários agentes de IA que podem trabalhar juntos, comunicar-se e coordenar-se para resolver tarefas complexas.
• Automação e gerenciamento de tarefasMecanismos de automação de fluxos de trabalho de várias etapas, delegação de tarefas e gerenciamento dinâmico de tarefas entre agentes
• Compreensão e adaptação contextualPermite que o agente compreenda o contexto, adapte-se a ambientes em constante mudança e tome decisões com base em informações em tempo real.

Em resumo, os agentes permitem que você faça mais, leve a automação para o próximo nível e crie sistemas mais inteligentes que podem se adaptar e aprender com o ambiente.

Como posso criar protótipos, iterar e aprimorar rapidamente os recursos do Agente?

É um campo em rápida evolução, mas a maioria das estruturas de agentes de IA tem algumas coisas em comum que podem ajudá-lo a criar protótipos e iterar rapidamente, ou seja, componentes modulares, ferramentas de colaboração e aprendizado em tempo real. Vamos nos aprofundar nesses aspectos:

• Uso de componentes modularesEstrutura de IA: A estrutura de IA fornece componentes pré-construídos, como dicas, analisadores e gerenciamento de memória.
• Uso de ferramentas de colaboraçãoDesign Agents com funções e tarefas específicas para que possam testar e melhorar os fluxos de trabalho colaborativos.
• Aprendizagem em tempo realO agente aprende com a interação e adapta dinamicamente seu comportamento.

Uso de componentes modulares

Estruturas como LangChain e Microsoft Semantic Kernel fornecem componentes pré-construídos, como dicas, analisadores e gerenciamento de memória.

Como as equipes usam essesAs equipes podem montar rapidamente esses componentes para criar um protótipo funcional sem precisar começar do zero, o que permite a experimentação e a iteração rápidas.

Como funciona na práticaAnálise de dados: Você pode usar analisadores pré-criados para extrair informações da entrada do usuário, módulos na memória para armazenar e recuperar dados e geradores de avisos para interagir com os usuários, tudo isso sem precisar criar esses componentes do zero.

Código de amostra (computação). Vamos ver um exemplo de como extrair informações da entrada do usuário usando um analisador pré-criado:

// 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)，此时它最终会向用户询问缺失的信息

Neste exemplo, é possível ver como um analisador pré-construído pode ser usado para extrair informações importantes da entrada do usuário, como a origem, o destino e a data de uma solicitação de reserva de voo. Essa abordagem modular permite que você se concentre na lógica de alto nível.

Uso de ferramentas de colaboração

CrewAI e Microsoft AutoGen Estruturas como essa facilitam a criação de vários agentes que podem trabalhar juntos.

Como as equipes usam essesAs equipes podem projetar Agents com funções e tarefas específicas, o que lhes permite testar e melhorar os fluxos de trabalho colaborativos e aumentar a eficiência geral do sistema.

Como funciona na práticaAgentes: Você pode criar uma equipe de agentes, cada um com uma função especializada, como recuperação de dados, análise ou tomada de decisões. Esses agentes podem se comunicar e compartilhar informações para atingir objetivos comuns, como responder a consultas de usuários ou concluir tarefas.

Código de amostra (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)

O que você viu no código anterior é como criar uma tarefa que envolve vários agentes trabalhando juntos para analisar dados. Cada Agent executa uma função específica e coordena os Agents para executar a tarefa e obter os resultados desejados. Ao criar Agentes dedicados com funções especializadas, você pode aumentar a eficiência e o desempenho da tarefa.

Aprendizagem em tempo real

A estrutura avançada oferece compreensão e adaptação contextual em tempo real.

Como as equipes usam essas estruturasAs equipes podem implementar loops de feedback que permitem que os agentes aprendam com as interações e ajustem dinamicamente seus comportamentos, levando à melhoria contínua e ao refinamento dos recursos.

aplicação práticaAgentes: os agentes podem analisar o feedback do usuário, os dados ambientais e os resultados das tarefas para atualizar sua base de conhecimento, adaptar os algoritmos de tomada de decisão e melhorar o desempenho ao longo do tempo. Esse processo de aprendizado iterativo permite que os agentes se adaptem às condições e às preferências do usuário em constante mudança, melhorando assim a eficiência geral do sistema.

Qual é a diferença entre o AutoGen, o Semantic Kernel e a estrutura do Azure AI Agent Service?

Há muitas maneiras de comparar essas estruturas, mas vamos examinar algumas das principais diferenças em termos de design, funcionalidade e casos de uso-alvo:

AutoGen

Estrutura de código aberto desenvolvida pelo AI Frontiers Lab da Microsoft Research. Concentra-se em sistemas distribuídos e orientados por eventos agêntico Aplicativos que suportam vários modelos de linguagem grande (LLMs) e SLMs, ferramentas e padrões avançados de design multiagente.

O conceito central do AutoGen são os agentes, que são entidades autônomas capazes de detectar seu ambiente, tomar decisões e realizar ações para atingir objetivos específicos. Os agentes se comunicam por meio de mensagens assíncronas, o que lhes permite trabalhar de forma independente e em paralelo, aumentando assim a escalabilidade e a capacidade de resposta do sistema.

Os agentes são baseados em modelos de atores. De acordo com a Wikipedia, ator é Os blocos de construção básicos da computação simultânea. Em resposta a uma mensagem recebida, um ator pode: tomar decisões locais, criar mais atores, enviar mais mensagens e determinar como responder à próxima mensagem recebida..

caso de usoAutomatize a geração de códigos, as tarefas de análise de dados e crie inteligências personalizadas (agentes) para funções de planejamento e pesquisa.

Estes são alguns dos conceitos básicos importantes do AutoGen:

• Agentes. Um corpo inteligente (Agente) é uma entidade de software que:
  • Comunicação por meio de mensagensEssas mensagens podem ser síncronas ou assíncronas.
  • Manutenção do statusEsse estado pode ser modificado por mensagens recebidas.
  • operação executável em resposta a uma mensagem recebida ou a uma alteração em seu estado. Essas ações podem modificar o estado do Agente e ter efeitos externos, como a atualização do registro de mensagens, o envio de novas mensagens, a execução de código ou a realização de chamadas de API.

  Abaixo está um pequeno trecho de código no qual você pode criar um agente com funcionalidade de bate-papo:

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

  No código anterior, oMyAssistant foi criado e herdado de RoutedAgent. Ele tem um manipulador de mensagens que imprime o conteúdo da mensagem e, em seguida, usa o AssistantAgent Delegar o envio da resposta. Preste atenção especial em como estamos delegando o AssistantAgent A instância do self._delegate(matemática) gêneroAssistantAgent é uma inteligência pré-construída (Agente) que pode lidar com a complementação de bate-papo.
  Em seguida, informe o AutoGen sobre o tipo de agente e inicie o 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"))
  

  No código anterior, os agentes são registrados com o tempo de execução e, em seguida, as mensagens são enviadas ao agente para produzir a seguinte saída:

  # 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?
  

• Agentes múltiplosO AutoGen suporta a criação de vários agentes que podem trabalhar juntos para realizar tarefas complexas. Os agentes podem se comunicar, compartilhar informações e coordenar suas ações para resolver problemas com mais eficiência. Para criar um sistema Multi-Agent, você define diferentes tipos de Agents com funções e papéis especializados, como recuperação de dados, análise, tomada de decisões e interação com o usuário. Vamos ver como é essa criação para que possamos entendê-la:

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
],
),
)

No código anterior, temos um GroupChatManagerEle é registrado no tempo de execução. Esse gerente é responsável por coordenar as interações entre diferentes tipos de agentes, como escritores, ilustradores, editores e usuários.

• Tempo de execução do agenteA estrutura oferece um ambiente de tempo de execução que suporta a comunicação entre os agentes e impõe limites de segurança e privacidade. A estrutura oferece um ambiente de tempo de execução que suporta a comunicação entre os agentes, gerencia a identidade e o ciclo de vida deles e impõe limites de segurança e privacidade. Isso significa que você pode executar seus agentes em um ambiente seguro e controlado, garantindo que eles possam interagir com segurança e eficiência. Há dois tempos de execução de interesse:
  • Tempo de execução autônomoEssa é uma boa opção para aplicativos de processo único em que todos os Agentes são implementados na mesma linguagem de programação e executados no mesmo processo. Essa é uma boa opção para aplicativos de processo único em que todos os agentes são implementados na mesma linguagem de programação e executados no mesmo processo. Aqui está um diagrama de como ele funciona:
    Tempo de execução autônomo
    pilha de aplicativos
    Os agentes se comunicam por meio de mensagens através do tempo de execução, que gerencia o ciclo de vida dos agentes.
  • Tempo de execução do agente distribuídoIsso é aplicável a aplicativos multiprocessos em que os agentes podem ser implementados em diferentes linguagens de programação e executados em diferentes máquinas. Aqui está uma ilustração de como isso funciona:
    Tempo de execução distribuído

Kernel semântico + estrutura de agente

O Semantic Kernel consiste em duas partes: a estrutura do agente do Semantic Kernel e o próprio Semantic Kernel.

Vamos falar um pouco sobre o Semantic Kernel. Ele tem os seguintes conceitos principais:

• ConexõesInterface com serviços externos de IA e fontes de dados: Essa é a interface com serviços externos de IA e fontes de dados.

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

Aqui está um exemplo simples de como criar um kernel e adicionar um serviço de conclusão de bate-papo. O Semantic Kernel cria uma conexão com um serviço de IA externo, neste caso o Azure OpenAI Chat Completion.

• PluginsPlug-ins: Encapsula funções que podem ser usadas por um aplicativo. Há plug-ins prontos e plug-ins que você mesmo pode criar. Há um conceito chamado Funções semânticas. O motivo de ser semântico é que você fornece informações semânticas para ajudar o Semantic Kernel a determinar que precisa chamar a função. Aqui está um exemplo:

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

Aqui você começa com uma dica de modelo skPromptEle permite que o usuário insira o texto $userInput do plug-in. Em seguida, você usa o plug-in SemanticFunctions função registrada SummarizeText. Observe o nome da função, que ajuda o Semantic Kernel a entender o que a função faz e quando ela deve ser chamada.

• Função nativaFunções nativas: Há também funções nativas que a estrutura pode chamar diretamente para executar tarefas. A seguir, um exemplo de tais funções que recuperam o conteúdo de um arquivo:

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

• PlanejadorPlanejador: O planejador orquestra planos e políticas de execução com base na entrada do usuário. A ideia é expressar como a execução deve ser feita e, em seguida, transformá-la em uma instrução a ser seguida pelo Semantic Kernel. Em seguida, ele chama as funções necessárias para executar as tarefas. A seguir, um exemplo de um plano desse tipo:

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>()}");

atenção especial planDefinitionque é a instrução simples seguida pelo planejador. A função apropriada é então chamada de acordo com esse plano, nesse caso, nossa função semântica SummarizeText e funções nativas RetrieveLocalFile.

• MemóriaResumo e simplificação do gerenciamento de contexto para aplicativos de IA. A ideia da memória é que isso é algo que o Modelo de Linguagem Grande (LLM) deve saber. Você pode armazenar essas informações em um armazenamento de vetores, que eventualmente se torna um banco de dados na memória ou um banco de dados de vetores ou algo semelhante. Aqui está um exemplo muito simplificado de um cenário em que o Fatos é adicionado à memória:

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

Os fatos são então armazenados na coleção de memória SummarizedAzureDocs na memória. Esse é um exemplo muito simplificado, mas você pode ver como as informações podem ser armazenadas na memória para uso no Modelo de Linguagem Grande (LLM).

Esses são os princípios básicos da estrutura do Semantic Kernel. E quanto à estrutura do agente?

Serviço de agente de IA do Azure

O Azure AI Agent Service é um membro mais recente, apresentado no Microsoft Ignite 2024. Ele permite o desenvolvimento e a implantação de agentes de IA com modelos mais flexíveis, como a invocação direta de LLMs (Large Language Models) de código aberto, como Llama 3, Mistral e Cohere.

O Azure AI Agent Service fornece mecanismos de segurança empresarial e métodos de armazenamento de dados mais fortes que o tornam adequado para aplicativos empresariais.

Ele funciona imediatamente com estruturas de orquestração multiagente, como o AutoGen e o Semantic Kernel.

Esse serviço está atualmente em visualização pública e oferece suporte a Python e C# para a criação de agentes.

Conceitos básicos

O Serviço de Agente de IA do Azure tem os seguintes conceitos principais:

• AgenteO Serviço de Agente de IA do Azure se integra ao Azure AI Foundry. No AI Foundry, os AI Intelligentsia (agentes) atuam como microsserviços "inteligentes" que podem ser usados para responder a perguntas (RAG), realizar operações ou automatizar completamente os fluxos de trabalho. Ele faz isso combinando os recursos de modelos de IA generativos com ferramentas que permitem acessar e interagir com fontes de dados do mundo real. Abaixo está um exemplo de um agente:

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

Neste exemplo, um modelo é criado com o modelo gpt-4o-miniNome my-agent e diretrizes You are helpful agent O agente está equipado com ferramentas e recursos para realizar tarefas de interpretação de código. O agente está equipado com ferramentas e recursos para realizar tarefas de interpretação de código.

• Tópicos e mensagens. Thread é outro conceito importante. Ele representa um diálogo ou uma interação entre um agente e um usuário. Os threads podem ser usados para rastrear o progresso de um diálogo, armazenar informações contextuais e gerenciar o estado de uma interação. Aqui está um exemplo de thread:

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

No código anterior, foi criado um thread. Depois disso, uma mensagem é enviada para o thread. Uma mensagem é enviada para o thread chamando a função create_and_process_runO agente é solicitado a executar o trabalho no thread. Por fim, as mensagens são capturadas e registradas para ver a resposta do Agente. As mensagens indicam o progresso do diálogo entre o usuário e o Agente. Também é importante entender que as mensagens podem ser de diferentes tipos, como texto, imagens ou arquivos, em que o trabalho dos agentes resulta, por exemplo, em uma imagem ou resposta de texto. Como desenvolvedor, você pode usar essas informações para processar ainda mais a resposta ou apresentá-la ao usuário.

• Integração com outras estruturas de IAO Serviço de Agente de IA do Azure pode interagir com outras estruturas, como AutoGen e Semantic Kernel, o que significa que você pode criar parte do seu aplicativo em uma das estruturas, como usar o Serviço de Agente como um orquestrador, ou pode criar tudo no Serviço de Agente.

caso de usoServiço de Agente de IA do Azure: o Serviço de Agente de IA do Azure foi projetado para aplicativos corporativos que exigem implantação segura, escalonável e flexível de inteligências de IA (agentes).

Qual é a diferença entre essas estruturas?

Parece que há muita sobreposição entre essas estruturas, mas há algumas diferenças importantes em seu design, funcionalidade e casos de uso alvo:

• AutoGenFoco em aplicativos agênticos distribuídos e orientados por eventos, com suporte a vários modelos de linguagem grande (LLMs) e SLMs, ferramentas e padrões avançados de design multiagente.
• Núcleo semânticoSoftware de gerenciamento de texto: concentra-se na compreensão e na geração de conteúdo de texto semelhante ao humano, capturando um significado semântico mais profundo. Ele foi projetado para automatizar fluxos de trabalho complexos e iniciar tarefas com base nas metas do projeto.
• Serviço de agente de IA do AzureFornece modelos mais flexíveis, como chamadas diretas para LLMs (Large Language Models) de código aberto, como Llama 3, Mistral e Cohere. Fornece mecanismos de segurança empresarial e métodos de armazenamento de dados mais robustos, tornando-o adequado para aplicativos empresariais.

Ainda não tem certeza de qual escolher?

caso de uso

Vamos analisar alguns casos de uso comuns para ver se podemos ajudá-lo:

P: Minha equipe está desenvolvendo um projeto que envolve geração automatizada de código e tarefas de análise de dados. Qual estrutura devemos usar?

R: O AutoGen é uma boa opção nesse caso porque se concentra em aplicativos agênticos distribuídos e orientados por eventos e oferece suporte a padrões avançados de design Multi-Agent.

P: O que torna o AutoGen melhor do que o Semantic Kernel e o Azure AI Agent Service para esse caso de uso?

R: O AutoGen foi projetado para aplicativos agênticos distribuídos e orientados por eventos, o que o torna ideal para automatizar a geração de código e as tarefas de análise de dados. Ele fornece as ferramentas e os recursos necessários para a criação eficiente de sistemas multiagentes complexos.

P: Parece que o Serviço de Agente de IA do Azure também funciona aqui, e ele tem ferramentas para geração de código e coisas do gênero?

R: Sim, o Azure AI Agent Service também oferece suporte a tarefas de geração de código e análise de dados, mas pode ser mais adequado para aplicativos corporativos que exigem implantações seguras, escalonáveis e flexíveis de agentes de IA. O autoGen é mais focado em aplicativos agênticos distribuídos e orientados por eventos e em padrões avançados de design Multi-Agent. O AutoGen está mais focado em aplicativos agênticos distribuídos e orientados a eventos e em padrões avançados de design multiagente.

P: Então você está dizendo que, se eu quiser entrar na empresa, devo optar pelo Azure AI Agent Service?

R: Sim, o Azure AI Agent Service foi projetado para aplicativos corporativos que exigem implantação segura, escalonável e flexível de inteligências de IA (agentes). Ele fornece mecanismos de segurança corporativa mais fortes e métodos de armazenamento de dados que o tornam adequado para casos de uso corporativo.

Vamos resumir as principais diferenças em uma tabela:

Qual é o caso de uso ideal para cada uma dessas estruturas?

• AutoGenAplicativos agênticos distribuídos e orientados por eventos, padrão avançado de design Multi-Agent. Ideal para geração automatizada de códigos e tarefas de análise de dados.
• Núcleo semânticoCompreenda e gere conteúdo de texto semelhante ao humano, automatize fluxos de trabalho complexos e inicie tarefas com base nas metas do projeto. Ideal para compreensão de linguagem natural e geração de conteúdo.
• Serviço de agente de IA do AzureModelos flexíveis, mecanismos de segurança empresarial e métodos de armazenamento de dados. Ideal para a implantação segura, dimensionável e flexível de inteligências de IA (agentes) em aplicativos corporativos.

Posso me integrar diretamente às minhas ferramentas existentes do ecossistema do Azure ou preciso de uma solução autônoma?

A resposta é sim, você pode integrar suas ferramentas existentes do ecossistema do Azure diretamente com o Azure AI Agent Service, especialmente porque ele foi projetado para funcionar perfeitamente com outros serviços do Azure. Por exemplo, você pode integrar o Bing, o Azure AI Search e o Azure Functions. Também há uma profunda integração com o Azure AI Foundry.

Para o AutoGen e o Semantic Kernel, você também pode se integrar aos serviços do Azure, mas isso pode exigir que você chame os serviços do Azure a partir do código. Outro método de integração é usar o SDK do Azure para interagir com os serviços do Azure a partir de seus agentes. Além disso, conforme mencionado anteriormente, você pode usar o Azure AI Agent Service como um orquestrador para agentes criados no AutoGen ou no Semantic Kernel, o que lhe dará acesso fácil ao ecossistema do Azure.