Guia de IA de Autoação: Comece sua jornada para construir agentes de IA

Aprenda o básico sobre como criar agentes de IA. Descubra as ferramentas e técnicas necessárias para projetar e implementar esses sistemas inteligentes.

O setor de inteligência artificial está testemunhando rápidos desenvolvimentos. É impressionante e muitas vezes confuso.

Tenho estudado, aprendido e construído minha base nessa área da ciência de dados porque acredito que o futuro da ciência de dados está intimamente ligado ao desenvolvimento da IA generativa.

Parece que foi ontem que construí meu primeiro Agente de IAE duas semanas depois, havia muitos pacotes Python para escolher, sem mencionar as opções sem código que tiveram um desempenho muito bom, como n8n.

De meros modelos que podem conversar conosco a um tsunami de agentes de IA que estão em todos os lugares, pesquisando na internet, manipulando arquivos e executando projetos. Ciência de Dados Todo o processo (da exploração inicial de dados até a modelagem e avaliação) aconteceu em apenas alguns anos.

O que?

Vendo tudo isso, meus pensamentos foram: “Preciso me juntar o mais rápido possível.”. No final, é melhor surfar na onda do que ser engolido por ela.

Por esse motivo, decidi começar esta série de posts onde pretendo passar do básico para a construção do nosso primeiro agente de IA, chegando até conceitos mais complexos.

Chega de conversa e vamos lá.

Noções básicas do agente de IA

Um agente de IA é criado quando damos a um grande modelo de linguagem (LLM) a capacidade de interagir com ferramentas e executar ações que são úteis para nós. Em vez de ser apenas um chatbot, ele agora pode agendar compromissos, gerenciar nosso calendário, pesquisar na internet, escrever postagens em mídias sociais e a lista continua... Essa transformação o torna um assistente digital completo.

Agentes com tecnologia de IA podem fazer coisas úteis, não apenas conversar.

Mas como podemos dar esse poder a um grande modelo de linguagem (LLM)?

A resposta simples é usar uma API para interagir com o modelo de linguagem grande. Hoje em dia, há muitos pacotes Python para isso. Se você acompanha meu blog, verá que já experimentei alguns pacotes para criar agentes: Langchain, Agno (antigo Phidata) e CrewAI, por exemplo. Para esta série, vou ficar com Agno[1].

Primeiro, configure um ambiente virtual usando uv Ou Anaconda ou seu processador de ambiente favorito. Em seguida, instale os pacotes.

# Agno AI
pip install agno

# module to interact with Gemini
pip install google-generativeai

# Install these other packages that will be needed throughout the tutorial
 pip install agno groq lancedb sentence-transformers tantivy youtube-transcript-api

Uma observação rápida antes de continuarmos. Não se esqueça de obter sua chave de API do Google Gemini [2].

Criar um proxy simples é muito fácil. Todos os pacotes são muito semelhantes. Eles têm uma classe. Agent Ou algo semelhante que nos permita selecionar um modelo e começar a interagir com o modelo de linguagem maior de nossa escolha. Aqui estão os principais componentes desta categoria:

model:Conecte-se ao grande modelo de linguagem. Aqui escolheremos entre OpenAI, Gemini, Llama, Deepseek, etc.
descriptionEste parâmetro nos permite descrever o comportamento do agente. Isto é adicionado a system_message, que é um meio semelhante.
instructionsGosto de pensar em um agente como um funcionário ou assistente que gerenciamos. Para realizar uma tarefa, precisamos dar instruções sobre o que fazer. Aqui você pode fazer isso.
expected_outputAqui podemos fornecer instruções sobre a saída esperada.
toolsÉ isso que torna um grande modelo de linguagem um agente, permitindo que ele interaja com o mundo real usando essas ferramentas.

Agora, vamos criar um agente simples que não possui ferramentas, mas servirá para construir nossa intuição sobre a estrutura do código.

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Answer in a maximum of 2 sentences."],
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC in May?")

# Print response
print(response.content)

## ...

Espere temperaturas moderadas em Nova York durante maio, geralmente variando de 10°C a 21°C. Há possibilidade de chuva, por isso é aconselhável usar várias camadas de roupa e um guarda-chuva.

Isso é ótimo. Usamos o modelo Gemini 1.5. Observe como ele responde com base nos dados com os quais foi treinado. Se pedirmos para ele nos dizer como está o tempo hoje, veremos uma resposta dizendo que ele não consegue acessar a Internet.

Vamos explorar os mediadores. instructions و expected_output. Agora queremos uma tabela com o mês, a estação e a temperatura média para a cidade de Nova York (NYC).

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Return a markdown table"],
    expected_output= "A table with month, season and average temperature",	
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC for each month of the year?")

# Print response
print(response.content)

E esse é o resultado.

o mês	estação	Temperatura média (°F)
janeiro	inverno	32
Fevereiro	inverno	35
Março	a primavera	44
Abril	a primavera	54
Maio	a primavera	63
Junho	O Verão	72
Julho	O Verão	77
Agosto	O Verão	76
Setembro	O outono	70
Outubro	O outono	58
Novembro	O outono	48
Dezembro	inverno	37

Ferramentas

As respostas acima são boas, mas é claro que não queremos usar modelos de linguagem grandes e poderosos (LLMs) para brincar com um chatbot ou nos contar notícias velhas, certo?

Queremos que seja uma ponte para automação, produtividade e conhecimento. Então, você vai adicionar Ferramentas capacidades aos nossos agentes de IA, construindo assim uma ponte com o mundo real. Exemplos comuns de agentes incluem: pesquisar na web, executar SQL, enviar e-mail ou chamar APIs.

Mas mais do que isso, podemos criar recursos personalizados para nossos agentes usando qualquer função Python como ferramenta, abrindo vastas possibilidades de integração com diferentes sistemas e processos.

Ferramentas São funções que um agente pode executar para realizar tarefas.

Em termos de código, adicionar um widget a um agente é simplesmente uma questão de usar o middleware. tools na categoria Agent.

Imagine uma empresa unipessoal (empresa unipessoal) no setor de saúde e bem-estar que deseja automatizar sua criação de conteúdo. Essa pessoa posta dicas de hábitos saudáveis todos os dias. Eu sei que criar conteúdo não é tão simples quanto parece. Requer criatividade, pesquisa e habilidades de redação. Então, se puder ser automatizado, ou pelo menos parte disso, economiza tempo.

Então, escrevemos este código para criar um agente muito simples que pode criar uma postagem simples no Instagram e salvá-la em um arquivo Markdown para revisão. Reduzimos o processo de pensar > pesquisar > escrever > revisar > publicar para revisar > publicar.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.tools.file import FileTools

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are a social media marketer specialized in creating engaging content.",
                  tools=[FileTools(
                      read_files=True, 
                      save_files=True
                      )],
                  show_tool_calls=True)

# Writing and saving a file
agent.print_response("""Write a short post for instagram with tips and tricks
                        that positions me as an authority in healthy eating 
                        and save it to a file named 'post.txt'.""",
                     markdown=True)

Como resultado, temos o seguinte.

Libere sua energia positiva comendo de forma saudável:

1. Priorize alimentos integrais: coma muitas frutas, vegetais, proteínas magras e grãos integrais. Eles são ricos em nutrientes e fazem você se sentir satisfeito e cheio de energia.

2. Coma com atenção: preste atenção aos sinais de fome e saciedade do seu corpo. Evite distrações enquanto come.

3. Beba bastante água: a água é essencial para a digestão, os níveis de energia e a saúde em geral..

4. Não se prive: permita-se comer alguns doces de vez em quando. A privação pode levar à alimentação excessiva mais tarde. Aproveite tudo com moderação!

5. Planeje com antecedência: prepare suas refeições ou lanches com antecedência para evitar tomar decisões prejudiciais à saúde.

#AlimentaçãoSaudável #EstiloDeVidaSaudável #Nutrição #AmantesDaComida #SaúdeEBemEstar #DicasSaudáveis #AlimentaçãoSaudável #PerdaDePeso #ReceitasSaudáveis #DicasNutricionais #SaúdeInstantânea #AlimentaçãoSaudável #AlimentaçãoConsciente #JornadaSaudável #CoachDeSaúde

Claro, poderíamos complicar ainda mais criando uma equipe com outros agentes para pesquisar a lista de sites em busca de conteúdo, um verificador e revisor de conteúdo e outro para criar uma imagem para a postagem. Mas acho que você entendeu a ideia geral de como adicionar tool إلى Agent.

Outro tipo de ferramenta que podemos adicionar é: uma ferramenta ferramenta de função. Podemos usar uma função Python para atuar como uma ferramenta para um grande modelo de linguagem (LLM). Só não se esqueça de adicionar dicas de tipo como: video_id:str, para que o modelo saiba o que usar como entrada para a função. Caso contrário, você poderá ver um erro.

Vamos ver rapidamente como isso funciona.

Agora queremos que nosso agente consiga obter um vídeo específico do YouTube e resumi-lo. Para executar essa tarefa, basta criar uma função que baixa a transcrição do vídeo do YT e a passa para o modelo para sumarização.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from youtube_transcript_api import YouTubeTranscriptApi

# Get YT transcript
def get_yt_transcript(video_id:str) -> str:
      
    """
    Use this function to get the transcript from a YouTube video using the video id.

    Parameters
    ----------
    video_id : str
        The id of the YouTube video.
    Returns
    -------
    str
        The transcript of the video.
    """

    # Instantiate
    ytt_api = YouTubeTranscriptApi()
    # Fetch
    yt = ytt_api.fetch(video_id)
    # Return
    return ''.join([line.text for line in yt])

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are an assistant that summarizes YouTube videos.",
                  tools=[get_yt_transcript],
                  expected_output= "A summary of the video with the 5 main points and 2 questions for me to test my understanding.",
                  markdown=True,
                  show_tool_calls=True)

# Run agent
agent.print_response("""Summarize the text of the video with the id 'hrZSfMly_Ck' """,
                     markdown=True)

Então você obtém um resultado.

Agentes com capacidade de raciocínio

Outra ótima opção que o Agno oferece é a capacidade de criar agentes que podem analisar uma situação antes de responder a uma pergunta. Esta é a ferramenta de raciocínio. verificar Tipos de agentes de IA e seus usos: uma explicação detalhada.

Criaremos um agente de raciocínio usando o modelo Qwen-qwq-32b do Alibaba. Observe que a única diferença aqui, além do modelo, é que estamos adicionando o widget. ReasoningTools(). Esta ferramenta permite que o agente pense logicamente antes de fornecer respostas.

Propriedade significa adding_instructions=True Fornecer ao agente instruções detalhadas, aumentando a confiabilidade e a precisão do uso da ferramenta. Ao definir esta propriedade, o resultado será: False Forçar o agente a confiar em seu próprio raciocínio, o que pode ser mais propenso a erros. Isso permite que as capacidades do modelo sejam avaliadas de forma independente.

# Imports
import os
from agno.agent import Agent
from agno.models.groq import Groq
from agno.tools.reasoning import ReasoningTools

# Create agent with reasoning
agent = Agent(
    model= Groq(id="qwen-qwq-32b",
                  api_key = os.environ.get("GROQ_API_KEY")),
                  description= "You are an experienced math teacher.",
                  tools=[ReasoningTools(add_instructions=True)],
                  show_tool_calls=True)

# Writing and saving a file
agent.print_response("""Explain the concept of sin and cosine in simple terms.""",
                     stream=True,
                     show_full_reasoning=True,
                     markdown=True)

Abaixo estão as saídas.

agente fornecido pelo conhecimento

Esta ferramenta é a maneira mais fácil de criar um sistema de Geração Aumentada de Recuperação (RAG). Com esse recurso, você pode direcionar o agente para um site ou lista de sites, e ele adicionará o conteúdo a um banco de dados de vetores. Depois disso, o conteúdo se torna pesquisável. Quando solicitado, o agente pode usar o conteúdo como parte da resposta. Essa tecnologia aumenta a precisão e a confiabilidade das respostas da IA.

Neste exemplo simples, adicionei uma página do meu site e perguntei ao agente quais livros estavam listados lá. Isso explica como o agente pode acessar e usar as informações.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.knowledge.url import UrlKnowledge
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.embedder.sentence_transformer import SentenceTransformerEmbedder

# Load webpage to the knowledge base
agent_knowledge = UrlKnowledge(
    urls=["https://gustavorsantos.me/?page_id=47"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="projects",
        search_type=SearchType.hybrid,
        # Use Sentence Transformer for embeddings
        embedder=SentenceTransformerEmbedder(),
    ),
)

# Create agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    instructions=[
        "Use tables to display data.",
        "Search your knowledge before answering the question.",
        "Only inlcude the content from the agent_knowledge base table 'projects'",
        "Only include the output in your response. No other text.",
    ],
    knowledge=agent_knowledge,
    add_datetime_to_instructions=True,
    markdown=True,
)

if __name__ == "__main__":
    # Load the knowledge base, you can comment out after first run
    # Set recreate to True to recreate the knowledge base if needed
    agent.knowledge.load(recreate=False)
    agent.print_response(
        "What are the two books listed in the 'agent_knowledge'",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

Agente habilitado para memória

O último tipo que abordaremos neste artigo é o agente habilitado para memória, um conceito fundamental no campo de agentes de IA.

Esse tipo de agente tem a capacidade de armazenar e recuperar informações sobre usuários de interações anteriores, permitindo que ele entenda as preferências do usuário e personalize suas respostas. Essa memória torna o agente mais eficaz em interações subsequentes.

Vamos ver este exemplo em que direi algumas coisas ao agente e pedirei recomendações com base nessa interação. Isso demonstra como um agente habilitado para memória pode melhorar a experiência do usuário.

# imports
import os
from agno.agent import Agent
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.memory.v2.memory import Memory
from agno.models.google import Gemini
from rich.pretty import pprint

# User Name
user_id = "data_scientist"

# Creating a memory database
memory = Memory(
    db=SqliteMemoryDb(table_name="memory", 
                      db_file="tmp/memory.db"),
    model=Gemini(id="gemini-2.0-flash", 
                 api_key=os.environ.get("GEMINI_API_KEY"))
                 )

# Clear the memory before start
memory.clear()

# Create the agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    user_id=user_id,
    memory=memory,
    # Enable the Agent to dynamically create and manage user memories
    enable_agentic_memory=True,
    add_datetime_to_instructions=True,
    markdown=True,
)

# Run the code
if __name__ == "__main__":
    agent.print_response("My name is Gustavo and I am a Data Scientist learning about AI Agents.")
    memories = memory.get_user_memories(user_id=user_id)
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("What topic should I study about?")
    agent.print_response("I write articles for Towards Data Science.")
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("Where should I post my next article?")

Com isso concluímos este primeiro artigo sobre Agentes de inteligência artificial. Esperamos que isso tenha fornecido uma visão geral útil dos diferentes tipos de agentes de IA.

Antes de sair

Este artigo contém muitas informações. Demos o primeiro passo na escada de aprendizado do agente de IA. Eu sei que pode ser confuso, há tanta informação por aí que pode ser difícil saber por onde começar e o que estudar.

Minha sugestão é que você siga o mesmo caminho que eu estou seguindo. Um passo de cada vez, escolha apenas alguns pacotes como Agno e CrewAI, aprofunde-se neles e aprenda a criar agentes mais complexos a cada vez. Essa abordagem gradual é melhor para compreender conceitos complexos de IA.

Neste artigo, começamos do zero, aprendendo como interagir de forma simples com um grande modelo de linguagem (LLM), até criar agentes com memória ou até mesmo criar um sistema simples de aumento de recuperação (RAG) para um agente de IA. Essas habilidades básicas são essenciais para entender como os agentes de IA funcionam.

Obviamente, há muita coisa que você pode fazer com apenas um agente. Verifique a referência [4] para exemplos avançados.

Com essas habilidades simples, você certamente estará à frente de muita gente, e já há muita coisa que você pode fazer. Basta usar a sua criatividade, por que não? Peça ajuda a um grande modelo de linguagem para construir algo incrível! Use ferramentas de IA para aprimorar sua criatividade.

No próximo artigo, aprenderemos mais sobre agentes de IA e sua avaliação. Fique ligado!