Agno: como criar seus próprios agentes de IA com Python

O que é um agente de IA?

Antes de entender o que é o Agno, vale dar um passo atrás e entender primeiramente o que é um agente de IA.

De forma simples, um agente de IA é como um assistente virtual que sabe agir sozinho. Ele usa inteligência artificial para tomar decisões, resolver problemas e realizar tarefas sem precisar que alguém fique mandando o tempo todo.

Esses agentes conseguem observar o que está acontecendo ao redor (como dados, mensagens, comandos), entender essas informações e agir com base nisso. Eles também aprendem com o tempo, o que significa que vão ficando melhores conforme interagem mais.Sabe quando você fala com a Alexa, recebe uma sugestão de filme na Netflix ou conversa com um chatbot no site de uma empresa? Tudo isso envolve agentes de IA. Eles estão mais presentes no nosso dia a dia do que a gente imagina.

O que são agentes de inteligência artificial?

O que é o Agno?

O Agno é um framework gratuito e aberto, ou seja, open source, que foi criado para facilitar a vida de quem quer desenvolver agentes de IA.

O grande diferencial do Agno é que ele deixa tudo mais simples quando você vai desenvolver um agente. Mesmo que você esteja começando na programação, dá para usar o Agno sem se perder. Ele tem uma estrutura clara, pode ser usado com Python (que é uma linguagem superpopular e fácil de aprender) e ainda vem com uma porção de ferramentas integradas. 

Além disso, ele já vem com várias funcionalidades prontas, como memória embutida (o agente consegue “lembrar” de coisas) e raciocínio estruturado (para que ele tome decisões de forma lógica).

Como funciona o Agno?

O Agno funciona como uma espécie de “central de controle” que organiza tudo o que um agente de IA precisa para agir sozinho. 

Ele é dividido em quatro partes principais, e cada uma tem uma função clara para ajudar o agente a pensar, decidir e agir.

1. Goals (Objetivos):

São os objetivos (goals) do agente. É o que você quer que ele faça. Pode ser algo simples, como responder perguntas, ou mais complexo, como organizar tarefas com base em dados. Os objetivos são o ponto de partida de tudo do Agno.

2. Tools (Ferramentas):

As ferramentas (tools) que o agente pode usar para realizar suas tarefas. Pode ser buscar algo na internet, ler um arquivo, consultar uma API ou até executar um código. Ele escolhe qual ferramenta usar com base no que precisa fazer.

3. Memory (Memória):

A memória guarda o que já aconteceu na conversa ou nas interações anteriores. Isso é útil para que o agente não esqueça do que foi falado antes e consiga dar respostas mais inteligentes e coerentes, lembrando do contexto.

4. Models (Modelos):

São os cérebros do agente como o GPT-4, por exemplo. Eles ajudam o agente a entender o que está acontecendo, interpretar os dados e decidir qual será o próximo passo.

Agora que você já conhece as quatro partes que fazem o Agno funcionar, que tal ver tudo isso ganhando vida?
No vídeo a seguir, eu apresento o Agno em detalhes e explico por que escolhi esse framework como meu principal aliado para criar agentes de Inteligência Artificial com Python.

Comparação: Agno vs LangChain vs CrewAI

Se você está pensando em criar um agente de IA, mas está perdido no meio de tantos nomes? LangChain, LangGraph, Agno, CrewAI… todos parecem fazer a mesma coisa, mas não se engane: cada um tem seu próprio jeito de pensar, agir e entregar resultados.

Veja o que muda de um para o outro e qual pode ser o melhor para o seu caso:

O papel das ferramentas (tools) em Agno

As ferramentas, ou tools, são como a caixa de utilidades de um agente de IA no Agno. Elas permitem que o agente vá além de só “entender e responder” e realmente execute ações no mundo real, como buscar informações, interagir com outros sistemas, manipular dados ou até rodar códigos.

O Agno já vem com mais de 80 ferramentas prontas, cobrindo vários tipos de tarefas, como:

• Pesquisar na internet (usando DuckDuckGo, Wikipedia, Arxiv e outros);
  
• Interagir com redes sociais e apps de comunicação (como Slack, Discord, WhatsApp, Telegram, Gmail);
  
• Ler e manipular dados em formatos como CSV, SQL, JSON, etc;
  
• Executar códigos Python ou comandos no terminal;
  
• Fazer scraping para coletar dados de sites;
  
• Usar APIs externas para tarefas específicas.

E o melhor: você também pode criar suas próprias ferramentas personalizadas com funções simples em Python, dizendo exatamente como o agente deve usá-las. Isso deixa o Agno muito flexível e adaptável a diferentes necessidades.

Na prática, as tools permitem criar agentes que, por exemplo:

• Pesquisam respostas em fontes abertas;
• Enviam mensagens automáticas no Slack ou WhatsApp;
• Consultam bancos de dados para encontrar informações;
• Fazem cálculos ou processam dados sob demanda;
• Coletam informações atualizadas da web para apoiar decisões.

É por causa dessa arquitetura baseada em ferramentas que os agentes no Agno conseguem atuar em áreas tão variadas, desde atendimento ao cliente até automação de processos, monitoramento de redes sociais e análise de dados.

O que são instruções (goals) em Agno?

No Agno, os goals ou objetivos são basicamente as instruções que dizem ao agente de IA o que ele precisa fazer. É como se fossem a “missão” dele: o que ele deve buscar, quais passos seguir e como priorizar suas ações para chegar lá.

Você é quem define esses objetivos. Pode ser algo superdireto, como “responder dúvidas sobre um tema específico”, ou mais elaborado, como “coletar dados na internet, organizar em um relatório e enviar por e-mail”. Os goals servem como guia para todas as decisões que o agente toma ao longo do processo.

Alguns exemplos práticos de goals que você pode dar ao Agno:

• Responder perguntas de forma clara e detalhada sobre um assunto;
• Automatizar o agendamento de reuniões usando o calendário e apps de comunicação;
• Pesquisar e coletar dados atualizados para gerar relatórios;
• Monitorar redes sociais e enviar alertas quando a marca for mencionada;
• Executar códigos Python para cálculos ou análises de dados;
• Organizar um fluxo de atendimento ao cliente, filtrando e encaminhando solicitações;
• Dividir tarefas complexas em subtarefas e priorizar cada uma delas até chegar no objetivo final.

Models (Modelos) no Agno

Os models no Agno são como o “cérebro pensante” do agente. Eles usam Grandes Modelos de Linguagem (LLMs), como o GPT-4, para interpretar o que está acontecendo, entender os objetivos e o histórico e decidir qual será o próximo passo.

É esse modelo que conecta todas as partes: ele lê os objetivos (goals), analisa o que já foi registrado na memória e escolhe a melhor ferramenta (tool) para usar em cada momento. E ele faz isso o tempo todo, ajustando a estratégia conforme as coisas vão acontecendo.

Na prática, o modelo ajuda o agente a:

• Entender quais são as metas definidas para ele;
• Usar o histórico salvo na memória para manter coerência nas respostas;
• Escolher a ferramenta mais adequada para a tarefa;
• Planejar e executar ações, criando subtarefas quando necessário;
• Ajustar as decisões com base no feedback que recebe;
• Atualizar a memória para as próximas interações;

Pense nele como a parte “racional” do agente: é quem avalia o cenário, toma decisões e garante que tudo o que está sendo feito realmente leve o agente na direção certa.

Criando seu primeiro agente com Agno

Agora que você já tem uma boa compreensão do que são agentes de IA e como o Agno funciona, vamos ao que interessa: como criar seu primeiro agente!

Passo a passo para configurar o ambiente

Passo 1: configurar o ambiente: 

Antes de tudo, você precisa ter o Python instalado (versão 3.8 ou superior). Depois, vamos criar um ambiente virtual, isso evita que as dependências do projeto se misturem com as de outros que você tenha no computador.

1. Crie o ambiente virtual

python3 -m venv .venv

2. Ative o ambiente virtual

• Linux/macOS:

source .venv/bin/activate

• Windows:

.venv\Scripts\activate

3. Instale o Agno

pip install -U agno

Exemplo prático de criação de um agente simples

Passo 2: criando o agente

Agora vem a parte divertida. Vamos criar um agente que:

• Busca informações na internet usando o DuckDuckGo;
• Mantém o contexto da conversa (para não esquecer do que foi dito antes);
• Responde perguntas sobre qualquer assunto.

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.memory.memory import BufferMemory
def criar_agente_info(stream_response=True):
    memoria = BufferMemory(max_tokens=512)
    agente = Agent(
        name="Info Agent",
        role="Assistente para buscar e fornecer informações detalhadas e confiáveis",
        model=OpenAIChat(id="o3-mini"),
        tools=[DuckDuckGoTools()],
        instructions=(
            "Forneça respostas detalhadas, claras e baseadas em fontes confiáveis. "
            "Use a ferramenta DuckDuckGo para obter dados atualizados. "
            "Lembre-se do contexto das interações anteriores."
        ),
        memory=memoria,
        show_tool_calls=True,
        markdown=True,
        stream=stream_response,
    )
    return agente
Passo 3: interagindo com o agente
def interagir_com_agente(agente):
    print("Pergunte algo para o agente (digite 'sair' para encerrar):")
    while True:
        try:
            pergunta = input("\nVocê: ").strip()
            if pergunta.lower() in {"sair", "exit", "quit"}:
                print("Encerrando a interação. Até mais!")
                break
            agente.print_response(pergunta, stream=True)
        except KeyboardInterrupt:
            print("\nInteração interrompida.")
            break
        except Exception as e:
            print(f"Erro: {e}")
            break
if __name__ == "__main__":
    meu_agente = criar_agente_info(stream_response=True)
    interagir_com_agente(meu_agente)

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.memory.memory import BufferMemory

def criar_agente_info(stream_response=True):
    memoria = BufferMemory(max_tokens=512)

    agente = Agent(
        name="Info Agent",
        role="Assistente para buscar e fornecer informações detalhadas e confiáveis",
        model=OpenAIChat(id="o3-mini"),
        tools=[DuckDuckGoTools()],
        instructions=(
            "Forneça respostas detalhadas, claras e baseadas em fontes confiáveis. "
            "Use a ferramenta DuckDuckGo para obter dados atualizados. "
            "Lembre-se do contexto das interações anteriores."
        ),
        memory=memoria,
        show_tool_calls=True,
        markdown=True,
        stream=stream_response,
    )
    return agente
Passo 3: interagindo com o agente
def interagir_com_agente(agente):
    print("Pergunte algo para o agente (digite 'sair' para encerrar):")
    while True:
        try:
            pergunta = input("\nVocê: ").strip()
            if pergunta.lower() in {"sair", "exit", "quit"}:
                print("Encerrando a interação. Até mais!")
                break

            agente.print_response(pergunta, stream=True)

        except KeyboardInterrupt:
            print("\nInteração interrompida.")
            break
        except Exception as e:
            print(f"Erro: {e}")
            break

if __name__ == "__main__":
    meu_agente = criar_agente_info(stream_response=True)
    interagir_com_agente(meu_agente)

Como funciona na prática

Quando você rodar esse script, o agente vai ficar esperando sua pergunta. Se precisar buscar algo na internet, ele usa a ferramenta DuckDuckGo, mantém o contexto da conversa e responde de forma clara e estruturada.

Dê o próximo passo: crie seus próprios agentes de IA com Agno

Agora que você já entendeu como o Agno funciona, viu exemplos práticos e até comparou com outras ferramentas, está na hora de colocar a mão na massa.
Na Trilha Aplicações IA: Criando Agentes de IA com Agno, você vai aprender, passo a passo, a configurar, programar e personalizar seus próprios agentes de inteligência artificial usando Python e o poder do Agno.

Você sairá sabendo:

• Como criar agentes inteligentes do zero;
• Como usar e personalizar as ferramentas (tools) para executar tarefas reais;
• Como dar objetivos claros (goals) para que seus agentes trabalhem de forma autônoma;
• Como aplicar tudo isso para automação, análise de dados, atendimento e muito mais.

Comece hoje mesmo a criar inteligência artificial sob seu comando!

Trilha completa

Criando Agentes com Agno