ai-agents-for-beginners

Explorando Frameworks de Agentes de IA

(Clique na imagem acima para ver o vídeo desta lição)

Explorar Frameworks de Agentes de IA

Os frameworks de agentes de IA são plataformas de software projetadas para simplificar a criação, implementação e gestão de agentes de IA. Estes frameworks fornecem aos desenvolvedores componentes pré-construídos, abstrações e ferramentas que agilizam o desenvolvimento de sistemas de IA complexos.

Esses frameworks ajudam os desenvolvedores a focar nos aspectos únicos de suas aplicações, oferecendo abordagens padronizadas para desafios comuns no desenvolvimento de agentes de IA. Eles melhoram a escalabilidade, acessibilidade e eficiência na construção de sistemas de IA.

Introdução

Esta lição abordará:

Objetivos de aprendizagem

Os objetivos desta lição são ajudá-lo a compreender:

O que são Frameworks de Agentes de IA e o que permitem que os desenvolvedores façam?

Os frameworks tradicionais de IA podem ajudar a integrar IA nas suas aplicações e melhorar essas aplicações das seguintes formas:

Isso tudo parece ótimo, certo? Então, por que precisamos de um Framework de Agentes de IA?

Os frameworks de agentes de IA representam algo mais do que apenas frameworks de IA. Eles são projetados para permitir a criação de agentes inteligentes que podem interagir com utilizadores, outros agentes e o ambiente para alcançar objetivos específicos. Esses agentes podem exibir comportamento autónomo, tomar decisões e adaptar-se a condições em mudança. Vamos analisar algumas capacidades principais habilitadas pelos Frameworks de Agentes de IA:

Resumindo, os agentes permitem fazer mais, levar a automação ao próximo nível e criar sistemas mais inteligentes que podem adaptar-se e aprender com o ambiente.

Como prototipar rapidamente, iterar e melhorar as capacidades do agente?

Este é um cenário em rápida evolução, mas há algumas coisas comuns na maioria dos Frameworks de Agentes de IA que podem ajudar a prototipar e iterar rapidamente, nomeadamente componentes modulares, ferramentas colaborativas e aprendizagem em tempo real. Vamos explorar estes pontos:

Utilizar Componentes Modulares

SDKs como Microsoft Semantic Kernel e LangChain oferecem componentes pré-construídos, como conectores de IA, modelos de prompts e gestão de memória.

Como as equipas podem utilizá-los: As equipas podem montar rapidamente esses componentes para criar um protótipo funcional sem começar do zero, permitindo experimentação e iteração rápidas.

Como funciona na prática: Pode utilizar um parser pré-construído para extrair informações da entrada do utilizador, um módulo de memória para armazenar e recuperar dados, e um gerador de prompts para interagir com os utilizadores, tudo sem precisar construir esses componentes do zero.

Exemplo de código. Vamos ver exemplos de como pode utilizar um conector de IA pré-construído com Semantic Kernel Python e .Net que utiliza chamadas automáticas de função para que o modelo responda à entrada do utilizador:

# Semantic Kernel Python Example

import asyncio
from typing import Annotated

from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory
from semantic_kernel.functions import kernel_function
from semantic_kernel.kernel import Kernel

# Define a ChatHistory object to hold the conversation's context
chat_history = ChatHistory()
chat_history.add_user_message("I'd like to go to New York on January 1, 2025")


# Define a sample plugin that contains the function to book travel
class BookTravelPlugin:
    """A Sample Book Travel Plugin"""

    @kernel_function(name="book_flight", description="Book travel given location and date")
    async def book_flight(
        self, date: Annotated[str, "The date of travel"], location: Annotated[str, "The location to travel to"]
    ) -> str:
        return f"Travel was booked to {location} on {date}"

# Create the Kernel
kernel = Kernel()

# Add the sample plugin to the Kernel object
kernel.add_plugin(BookTravelPlugin(), plugin_name="book_travel")

# Define the Azure OpenAI AI Connector
chat_service = AzureChatCompletion(
    deployment_name="YOUR_DEPLOYMENT_NAME", 
    api_key="YOUR_API_KEY", 
    endpoint="https://<your-resource>.azure.openai.com/",
)

# Define the request settings to configure the model with auto-function calling
request_settings = AzureChatPromptExecutionSettings(function_choice_behavior=FunctionChoiceBehavior.Auto())


async def main():
    # Make the request to the model for the given chat history and request settings
    # The Kernel contains the sample that the model will request to invoke
    response = await chat_service.get_chat_message_content(
        chat_history=chat_history, settings=request_settings, kernel=kernel
    )
    assert response is not None

    """
    Note: In the auto function calling process, the model determines it can invoke the 
    `BookTravelPlugin` using the `book_flight` function, supplying the necessary arguments. 
    
    For example:

    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "BookTravelPlugin-book_flight",
                "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
            }
        }
    ]

    Since the location and date arguments are required (as defined by the kernel function), if the 
    model lacks either, it will prompt the user to provide them. For instance:

    User: Book me a flight to New York.
    Model: Sure, I'd love to help you book a flight. Could you please specify the date?
    User: I want to travel on January 1, 2025.
    Model: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels!
    """

    print(f"`{response}`")
    # Example AI Model Response: `Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽`

    # Add the model's response to our chat history context
    chat_history.add_assistant_message(response.content)


if __name__ == "__main__":
    asyncio.run(main())

// Semantic Kernel C# example

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using System.ComponentModel;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go to New York on January 1, 2025");

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel"); 
var kernel = kernelBuilder.Build();

var settings = new AzureOpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

var chatCompletion = kernel.GetRequiredService<IChatCompletionService>();

var response = await chatCompletion.GetChatMessageContentAsync(chatHistory, settings, kernel);

/*
Behind the scenes, the model recognizes the tool to call, what arguments it already has (location) and (date)
{

"tool_calls": [
    {
        "id": "call_abc123",
        "type": "function",
        "function": {
            "name": "BookTravelPlugin-book_flight",
            "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
        }
    }
]
*/

Console.WriteLine(response.Content);
chatHistory.AddMessage(response!.Role, response!.Content!);

// Example AI Model Response: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽

// Define a plugin that contains the function to book travel
public class BookTravelPlugin
{
    [KernelFunction("book_flight")]
    [Description("Book travel given location and date")]
    public async Task<string> BookFlight(DateTime date, string location)
    {
        return await Task.FromResult( $"Travel was booked to {location} on {date}");
    }
}

O que pode ver neste exemplo é como pode aproveitar um parser pré-construído para extrair informações-chave da entrada do utilizador, como origem, destino e data de um pedido de reserva de voo. Esta abordagem modular permite focar na lógica de alto nível.

Aproveitar Ferramentas Colaborativas

Frameworks como CrewAI, Microsoft AutoGen e Semantic Kernel facilitam a criação de múltiplos agentes que podem trabalhar juntos.

Como as equipas podem utilizá-los: As equipas podem projetar agentes com papéis e tarefas específicas, permitindo testar e refinar fluxos de trabalho colaborativos e melhorar a eficiência geral do sistema.

Como funciona na prática: Pode criar uma equipa de agentes onde cada agente tem uma função especializada, como recuperação de dados, análise ou tomada de decisão. Esses agentes podem comunicar e compartilhar informações para alcançar um objetivo comum, como responder a uma consulta do utilizador ou completar uma tarefa.

Exemplo de código (AutoGen):

# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making 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."
)

# conversation ends when user says "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)
# Use asyncio.run(...) when running in a script.
await Console(stream)

O que vê no código anterior é como pode criar uma tarefa que envolve múltiplos agentes trabalhando juntos para analisar dados. Cada agente desempenha uma função específica, e a tarefa é executada coordenando os agentes para alcançar o resultado desejado. Ao criar agentes dedicados com papéis especializados, pode melhorar a eficiência e o desempenho da tarefa.

Aprender em Tempo Real

Frameworks avançados fornecem capacidades para compreensão de contexto em tempo real e adaptação.

Como as equipas podem utilizá-los: As equipas podem implementar ciclos de feedback onde os agentes aprendem com interações e ajustam o seu comportamento dinamicamente, levando a melhorias contínuas e refinamento das capacidades.

Como funciona na prática: Os agentes podem analisar feedback dos utilizadores, dados ambientais e resultados de tarefas para atualizar a sua base de conhecimento, ajustar algoritmos de tomada de decisão e melhorar o desempenho ao longo do tempo. Este processo de aprendizagem iterativa permite que os agentes se adaptem a condições em mudança e preferências dos utilizadores, melhorando a eficácia geral do sistema.

Quais são as diferenças entre os frameworks AutoGen, Semantic Kernel e Azure AI Agent Service?

Existem várias formas de comparar esses frameworks, mas vamos analisar algumas diferenças principais em termos de design, capacidades e casos de uso alvo:

AutoGen

AutoGen é um framework de código aberto desenvolvido pelo AI Frontiers Lab da Microsoft Research. Ele foca em aplicações distribuídas e orientadas por eventos, permitindo múltiplos LLMs e SLMs, ferramentas e padrões avançados de design multi-agente.

AutoGen é construído em torno do conceito central de agentes, que são entidades autónomas capazes de perceber o ambiente, tomar decisões e realizar ações para alcançar objetivos específicos. Os agentes comunicam-se através de mensagens assíncronas, permitindo que trabalhem de forma independente e em paralelo, aumentando a escalabilidade e a capacidade de resposta do sistema.

De acordo com a Wikipedia, um ator é o bloco básico de construção da computação concorrente. 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.

Casos de Uso: Automação de geração de código, tarefas de análise de dados e construção de agentes personalizados para funções de planeamento e pesquisa.

Aqui estão alguns conceitos centrais importantes do AutoGen:

Semantic Kernel + Framework de Agentes

Semantic Kernel é um SDK de Orquestração de IA pronto para empresas. Ele consiste em conectores de IA e memória, juntamente com um Framework de Agentes.

Vamos primeiro abordar alguns componentes principais:

Azure AI Agent Service

O Azure AI Agent Service é uma adição mais recente, introduzida no Microsoft Ignite 2024. Ele permite o desenvolvimento e a implementação de agentes de IA com modelos mais flexíveis, como a chamada direta a LLMs de código aberto, como Llama 3, Mistral e Cohere.

O Azure AI Agent Service oferece mecanismos de segurança empresarial mais robustos e métodos de armazenamento de dados, tornando-o adequado para aplicações empresariais.

Funciona de forma nativa com frameworks de orquestração de múltiplos agentes, como AutoGen e Semantic Kernel.

Este serviço está atualmente em Public Preview e suporta Python e C# para a criação de agentes.

Usando o Semantic Kernel em Python, podemos criar um Azure AI Agent com um plugin definido pelo utilizador:

import asyncio
from typing import Annotated

from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings, AzureAIAgentThread
from semantic_kernel.contents import ChatMessageContent
from semantic_kernel.contents import AuthorRole
from semantic_kernel.functions import kernel_function


# Define a sample plugin for the sample
class MenuPlugin:
    """A sample Menu Plugin used for the concept sample."""

    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
        return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

    @kernel_function(description="Provides the price of the requested menu item.")
    def get_item_price(
        self, menu_item: Annotated[str, "The name of the menu item."]
    ) -> Annotated[str, "Returns the price of the menu item."]:
        return "$9.99"


async def main() -> None:
    ai_agent_settings = AzureAIAgentSettings.create()

    async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(
            credential=creds,
            conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
        ) as client,
    ):
        # Create agent definition
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            name="Host",
            instructions="Answer questions about the menu.",
        )

        # Create the AzureAI Agent using the defined client and agent definition
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],
        )

        # Create a thread to hold the conversation
        # If no thread is provided, a new thread will be
        # created and returned with the initial response
        thread: AzureAIAgentThread | None = None

        user_inputs = [
            "Hello",
            "What is the special soup?",
            "How much does that cost?",
            "Thank you",
        ]

        try:
            for user_input in user_inputs:
                print(f"# User: '{user_input}'")
                # Invoke the agent for the specified thread
                response = await agent.get_response(
                    messages=user_input,
                    thread_id=thread,
                )
                print(f"# {response.name}: {response.content}")
                thread = response.thread
        finally:
            await thread.delete() if thread else None
            await client.agents.delete_agent(agent.id)


if __name__ == "__main__":
    asyncio.run(main())

Conceitos principais

O Azure AI Agent Service possui os seguintes conceitos principais:

Casos de Uso: O Azure AI Agent Service foi projetado para aplicações empresariais que exigem uma implementação de agentes de IA segura, escalável e flexível.

Qual é a diferença entre estes frameworks?

Pode parecer que há muita sobreposição entre estes frameworks, mas existem algumas diferenças-chave em termos de design, capacidades e casos de uso alvo:

Ainda não tem a certeza de qual escolher?

Casos de Uso

Vamos ver se conseguimos ajudá-lo ao passar por alguns casos de uso comuns:

P: Estou a experimentar, aprender e construir aplicações de agentes como prova de conceito, e quero ser capaz de construir e experimentar rapidamente.

R: O AutoGen seria uma boa escolha para este cenário, pois foca-se em aplicações baseadas em eventos e distribuídas e suporta padrões avançados de design de múltiplos agentes.

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

R: O AutoGen foi especificamente projetado para aplicações baseadas em eventos e distribuídas, tornando-o bem adequado para automatizar tarefas de geração de código e análise de dados. Ele fornece as ferramentas e capacidades necessárias para construir sistemas complexos de múltiplos agentes de forma eficiente.

P: Parece que o Azure AI Agent Service também poderia funcionar aqui, pois tem ferramentas para geração de código e mais?

R: Sim, o Azure AI Agent Service é uma plataforma de serviço para agentes e adiciona capacidades integradas para múltiplos modelos, Azure AI Search, Bing Search e Azure Functions. Facilita a construção dos seus agentes no Foundry Portal e a sua implementação em escala.

P: Ainda estou confuso, dê-me apenas uma opção.

R: Uma ótima escolha é construir a sua aplicação no Semantic Kernel primeiro e depois usar o Azure AI Agent Service para implementar o seu agente. Esta abordagem permite-lhe persistir facilmente os seus agentes enquanto aproveita o poder de construir sistemas de múltiplos agentes no Semantic Kernel. Além disso, o Semantic Kernel tem um conector no AutoGen, tornando fácil usar ambos os frameworks juntos.

Vamos resumir as principais diferenças numa tabela:

Framework Foco Conceitos Principais Casos de Uso
AutoGen Aplicações baseadas em eventos e distribuídas Agentes, Personas, Funções, Dados Geração de código, tarefas de análise de dados
Semantic Kernel Compreensão e geração de conteúdo semelhante ao humano Agentes, Componentes Modulares, Colaboração Compreensão de linguagem natural, geração de conteúdo
Azure AI Agent Service Modelos flexíveis, segurança empresarial, Geração de código, Chamadas de ferramentas Modularidade, Colaboração, Orquestração de Processos Implementação de agentes de IA segura, escalável e flexível

Qual é o caso de uso ideal para cada um destes frameworks?

Posso integrar diretamente as minhas ferramentas existentes do ecossistema Azure ou preciso de soluções independentes?

A resposta é sim, pode integrar diretamente as suas ferramentas existentes do ecossistema Azure com o Azure AI Agent Service, especialmente porque foi construído para funcionar perfeitamente com outros serviços Azure. Por exemplo, pode integrar o Bing, Azure AI Search e Azure Functions. Há também uma integração profunda com o Azure AI Foundry.

Para o AutoGen e o Semantic Kernel, também pode integrar com serviços Azure, mas pode ser necessário chamar os serviços Azure a partir do seu código. Outra forma de integrar é usar os SDKs Azure para interagir com os serviços Azure a partir dos seus agentes. Além disso, como mencionado, pode usar o Azure AI Agent Service como um orquestrador para os seus agentes construídos no AutoGen ou Semantic Kernel, o que daria fácil acesso ao ecossistema Azure.

Tem mais perguntas sobre frameworks de agentes de IA?

Junte-se ao Discord do Azure AI Foundry para se encontrar com outros aprendizes, participar em horários de atendimento e obter respostas às suas perguntas sobre Agentes de IA.

Referências

Aula Anterior

Introdução a Agentes de IA e Casos de Uso de Agentes

Próxima Aula

Compreender Padrões de Design de Agentes

Aviso Legal:
Este documento foi traduzido utilizando o serviço de tradução automática Co-op Translator. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte oficial. Para informações críticas, recomenda-se uma tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.

This site is open source. Improve this page.