Minha Jornada com o Agente de IA: Da Confusão à Criação

Oi, agente em treinamento! Emma aqui, de volta de mais uma exploração noturna pelo fascinante, e às vezes frustrante, mundo dos agentes de IA. Se você é como eu, provavelmente passou os últimos meses ouvindo sussurros (ou gritos) sobre agentes de IA e pensou: “Ok, isso parece legal, mas também… o que é isso, realmente, e como eu faço para que um faça algo por mim?”

Bem, você está no lugar certo. Hoje, não vamos apenas falar sobre o que são os agentes de IA *em teoria*. Vamos colocar a mão na massa e abordar uma pergunta que tem incomodado muitos de vocês (e a mim, até recentemente): Como construir um agente de IA simples que realmente possa navegar na internet por mim e responder perguntas específicas?

Esqueça a hype por um minuto. Estamos indo para o prático. Estamos indo para “eu realmente posso fazer isso funcionar no meu laptop.” Porque, vamos ser honestos, ver é acreditar, certo?

Meus Erros (e Conquistas) com Bots de Navegação

Quando comecei a mexer com a ideia de um agente que pudesse usar a internet, eu tinha visões grandiosas. Queria que ele pesquisasse tópicos complexos, comparasse preços em uma dúzia de sites e, basicamente, fosse meu assistente digital pessoal. O que consegui, inicialmente, foram muitos erros, alguns scrapers de web quebrados e uma profunda sensação de inadequação. Minhas primeiras tentativas foram como tentar ensinar uma criança a operar uma máquina complexa – muita empolgação, zero compreensão da mecânica subjacente.

O maior obstáculo? Fazer um modelo de IA interagir com a internet de maneira significativa e controlada. É uma coisa perguntar ao ChatGPT sobre algo que ele já sabe. É outra totalmente diferente pedir que ele encontre novas informações, as interprete e, em seguida, aja com base nisso. É aí que a parte do “agente” realmente entra em cena.

Após muitas tentativas e erros, percebi que a chave não era construir uma entidade supercomplexa e onisciente desde o início. Era começar pequeno, com uma tarefa muito específica, e construir a partir daí. E é exatamente isso que vamos fazer hoje. Vamos criar um agente de navegação básico que possa acessar um site específico, extrair algumas informações e retornar.

O que é um Agente de IA de Navegação?

Antes de explorarmos o código, vamos esclarecer rapidamente. Um agente de IA, em sua essência, é um programa de IA projetado para realizar uma tarefa específica de forma autônoma. Ele observa seu ambiente (no nosso caso, a internet), toma decisões com base em seus objetivos e, em seguida, executa ações. Um agente de IA *de navegação* utiliza especificamente capacidades de navegação na web como parte de seu conjunto de ferramentas.

Pense assim: você diz ao seu agente, “Encontre-me o clima atual em Londres.” Em vez de apenas usar seu conhecimento interno, um agente de navegação (idealmente) abriria um navegador, acessaria um site de clima, encontraria as informações e então as entregaria a você. É a diferença entre fazer uma pergunta a um bibliotecário cujo conhecimento você já conhece e pedir que ele encontre um livro, leia um capítulo específico e o resuma para você.

Para o nosso agente simples, usaremos algumas bibliotecas comuns do Python que tornam todo esse processo muito menos intimidador.

As Ferramentas que Vamos Precisar

Você não precisa de um supercomputador para isso. Apenas sua configuração de desenvolvimento regular. Aqui está o que usaremos:

• Python: Nossa linguagem de programação escolhida. (Estou usando a 3.9, mas 3.8+ deve funcionar bem.)
• requests: Uma biblioteca fantástica para fazer requisições HTTP (ou seja, buscar páginas web).
• BeautifulSoup (bs4): Este é nosso assistente de análise web. Ele nos ajuda a navegar e extrair dados de HTML.
• Uma API de Modelo de Linguagem Grande (LLM): Precisaremos de acesso a um LLM como os modelos GPT da OpenAI ou Claude da Anthropic. Para este tutorial, assumirei que você tem uma chave de API da OpenAI.

Primeiro as coisas, vamos preparar nosso ambiente. Se você não tem essas bibliotecas instaladas, abra seu terminal ou prompt de comando e execute:

pip install requests beautifulsoup4 openai

E certifique-se de ter sua chave de API da OpenAI em mãos. Você precisará defini-la como uma variável de ambiente ou passá-la diretamente em seu script. Para simplificar, eu mostrarei diretamente, mas para produção, variáveis de ambiente são sempre melhores.

Nossa Missão: Encontrar um Artigo Específico em um Blog

Vamos estabelecer uma meta concreta e alcançável. A missão do nosso agente será:

1. Ir a um blog específico (vamos usar uma URL de blog fictícia por enquanto, ou mesmo agent101.net se você estiver se sentindo ousado!).
2. Encontrar um título de post que contenha uma palavra-chave específica (por exemplo, “iniciantes”).
3. Extrair a URL desse post.
4. Resumir o conteúdo desse post usando um LLM.

Esse é um ótimo ponto de partida porque combina interação web com entendimento de LLM. É como pedir ao seu assistente digital para “encontrar o artigo mais recente sobre agentes de IA para iniciantes no agent101.net e me dizer sobre o que é.”

Passo 1: Buscando a Página da Web

O primeiro passo para qualquer agente de navegação é “ver” a página da web. Vamos usar a biblioteca requests para isso. Vamos fazer um script simples:

import requests

def fetch_webpage(url):
 try:
 response = requests.get(url)
 response.raise_for_status() # Levanta um HTTPError para respostas ruins (4xx ou 5xx)
 return response.text
 except requests.exceptions.RequestException as e:
 print(f"Erro ao buscar URL {url}: {e}")
 return None

# Vamos usar uma URL de espaço reservado por enquanto.
# Substitua por uma URL real de blog que tenha artigos se quiser testar!
blog_url = "https://www.example-blog.com/articles" # Utilize uma URL real aqui!

html_content = fetch_webpage(blog_url)

if html_content:
 print("Conteúdo da página recuperado com sucesso.")
 # Vamos processar esse conteúdo no próximo passo
else:
 print("Falha ao recuperar a página web.")

Uma rápida nota sobre URLs: Para que isso funcione, você precisará de uma URL real de blog. Se você não tiver uma à mão, pode usar um site como `http://quotes.toscrape.com/` para testar scraping simples, mas para posts de blog, encontre um blog real. Mesmo este site, agent101.net, poderia funcionar se você adaptar os seletores CSS depois!

Passo 2: Analisando o HTML e Encontrando Links de Artigos

Agora que temos o HTML bruto, é como ter um livro gigante sem índice. BeautifulSoup é nosso indexador. Precisamos dizer a ele como encontrar os títulos dos artigos e seus links correspondentes.

Esta é a parte mais complicada porque a estrutura do HTML de cada site é diferente. Você precisará “inspecionar” o elemento no site alvo. Clique com o botão direito do mouse em um título de artigo no blog escolhido e selecione “Inspecionar” (ou “Inspecionar Elemento”). Procure por padrões comuns, como tags <h2> para títulos, ou tags <a> para links, frequentemente aninhadas dentro de uma <div> com um nome de classe específico.

Para demonstração, vamos assumir uma estrutura comum de blog onde os títulos dos artigos estão em tags <h2>, e seus links estão em uma tag <a> diretamente dentro ou precedendo-os.

from bs4 import BeautifulSoup

def find_article_links(html_content, keyword):
 soup = BeautifulSoup(html_content, 'html.parser')
 article_data = []

 # Este é um exemplo genérico. Você precisará ajustar os seletores com base no site-alvo.
 # Padrões comuns: div com a classe 'article-item', h2 com a classe 'article-title', etc.
 # Suponhamos que os artigos estejam em elementos 'div' com a classe 'post'
 # e os títulos estejam nas tags 'h2' dentro dessas divs, com um link dentro.
 
 # Exemplo: Procure todas as tags 
 que possam conter títulos de artigos
 # Então verifique se estão vinculadas.
 
 # Uma abordagem mais sólida pode ser encontrar os contêineres primeiro:
 article_containers = soup.find_all('div', class_='article-card') # Ajuste esta classe!
 if not article_containers:
 # Fallback ou tente outro seletor se o primeiro não funcionar
 article_containers = soup.find_all('article') # Outra tag comum
 
 for container in article_containers:
 title_tag = container.find('h2') # Ou 'h3', 'a', etc.
 link_tag = container.find('a', href=True) # Encontre o primeiro link dentro do contêiner
 
 if title_tag and link_tag:
 title = title_tag.get_text(strip=True)
 href = link_tag['href']
 
 # Certifique-se de que a URL é absoluta se for relativa
 if href.startswith('/'):
 full_url = requests.compat.urljoin(blog_url, href)
 else:
 full_url = href

 if keyword.lower() in title.lower():
 article_data.append({'title': title, 'url': full_url})
 
 return article_data

# ... (código fetch_webpage anterior) ...

if html_content:
 search_keyword = "beginner" # Que artigo estamos procurando?
 found_articles = find_article_links(html_content, search_keyword)

 if found_articles:
 print(f"\nArtigos encontrados contendo '{search_keyword}':")
 for article in found_articles:
 print(f"- Título: {article['title']}\n URL: {article['url']}")
 # Para este exemplo, vamos apenas pegar o primeiro encontrado
 target_article = found_articles[0]
 else:
 print(f"\nNenhum artigo encontrado contendo '{search_keyword}'.")
 target_article = None
else:
 target_article = None

Personalização Crucial: As linhas como soup.find_all('div', class_='article-card') e container.find('h2') são espaços reservados. Você *deve* adaptar isso com base na estrutura HTML real do blog que está mirando. É aqui que inspecionar a página da web se torna essencial. Meu melhor conselho é começar amplo (por exemplo, `soup.find_all(‘a’)` para obter todos os links) e, em seguida, restringi-lo com classes ou IDs.

Passo 3: Extraindo Conteúdo do Artigo Alvo

Uma vez que temos a URL do nosso artigo alvo, precisamos buscar seu conteúdo e, em seguida, extrair o texto principal. Isso geralmente é mais fácil do que analisar uma página de índice, já que a maior parte do conteúdo dos artigos reside dentro de um tag <div> ou <article> principal.

# ... (código anterior) ...
import openai
import os

# Defina sua chave de API da OpenAI
# Melhor prática: os.environ.get("OPENAI_API_KEY")
# Para este exemplo, atribuição direta:
openai.api_key = "YOUR_OPENAI_API_KEY" # SUBSTITUA ISTO PELA SUA CHAVE REAL!

def extract_article_text(article_url):
 article_html = fetch_webpage(article_url)
 if not article_html:
 return None

 soup = BeautifulSoup(article_html, 'html.parser')

 # Isso depende fortemente da estrutura do site.
 # Padrões comuns: encontrar um div com a classe 'entry-content', 'article-body', 'main-content'
 # Ou apenas as tags 
 dentro da tag do artigo principal.
 
 # Vamos tentar encontrar áreas comuns de conteúdo.
 content_div = soup.find('div', class_='entry-content') # Comum para WordPress
 if not content_div:
 content_div = soup.find('article') # Outra boa tag geral
 if not content_div:
 # Como último recurso, apenas obtenha todas as tags de parágrafo
 paragraphs = soup.find_all('p')
 return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])

 # Se encontramos um div/artigo de conteúdo específico, extraímos todo o texto de parágrafo dele
 paragraphs = content_div.find_all('p')
 article_text = "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
 return article_text

if target_article:
 print(f"\nBuscando conteúdo para: {target_article['title']}")
 article_text_content = extract_article_text(target_article['url'])
 
 if article_text_content:
 # print(article_text_content[:500]) # Imprimir os primeiros 500 caracteres para verificar
 print("\nTexto do artigo extraído com sucesso. Indo para a sumarização.")
 else:
 print("Falha ao extrair o texto do artigo.")
 article_text_content = "" # Garanta que não seja None para o próximo passo
else:
 article_text_content = ""

Novamente, a linha soup.find('div', class_='entry-content') é seu alvo principal para personalização. Use o inspetor do seu navegador!

Passo 4: Resumindo com um LLM

Finalmente, o momento em que trazemos a inteligência artificial! Vamos fornecer o texto extraído a um LLM e pedir para resumir. É aqui que a “inteligência” do nosso agente realmente brilha.

# ... (código anterior) ...

def summarize_text_with_llm(text):
 if not text:
 return "Nenhum texto fornecido para sumarização."
 
 # Diminua o texto se estiver muito longo para a janela de contexto do modelo
 # O GPT-3.5-turbo tem uma janela de contexto de 16k, mas é uma boa prática mantê-lo razoável.
 # Para um iniciante, almejar 4000-8000 tokens é seguro.
 # Aproximadamente 1 token = 4 caracteres para texto em inglês.
 max_tokens_for_input = 12000 # Ajuste com base na capacidade do seu modelo e considerações de custo
 
 if len(text) > max_tokens_for_input * 4: # Estimativa grosseira de caracteres
 text = text[:max_tokens_for_input * 4]
 print(f"Atenção: Texto encurtado para ~{max_tokens_for_input} tokens para processamento do LLM.")

 try:
 response = openai.chat.completions.create(
 model="gpt-3.5-turbo", # Ou "gpt-4", "claude-3-opus-20240229", etc.
 messages=[
 {"role": "system", "content": "Você é um assistente útil que resume posts de blog de forma concisa."},
 {"role": "user", "content": f"Por favor, resuma o seguinte post de blog para mim:\n\n{text}"}
 ],
 temperature=0.7, # Controla a aleatoriedade. Menor para resumos mais focados.
 max_tokens=500 # Max tokens para o resumo em si
 )
 return response.choices[0].message.content.strip()
 except openai.APIError as e:
 print(f"Erro da API da OpenAI: {e}")
 return "Falha devido a erro de API."
 except Exception as e:
 print(f"Ocorreu um erro inesperado durante a sumarização: {e}")
 return "Falha devido a um erro inesperado."

if article_text_content:
 print("\nSolicitando sumarização do LLM...")
 summary = summarize_text_with_llm(article_text_content)
 print("\n--- Resumo do Artigo ---")
 print(summary)
else:
 print("\nNão é possível resumir: Nenhum conteúdo de artigo disponível.")

E aí está! Um agente de IA básico, mas funcional, que pode navegar, extrair e resumir. Isso não é mais teoria; é um pedaço tangível de código que você pode executar.

Juntando Tudo (Script Completo)

Aqui está o script completo para fácil cópia e teste. Lembre-se de substituir URLs de espaço reservado e sua chave de API da OpenAI!

import requests
from bs4 import BeautifulSoup
import openai
import os

# --- Configuração ---
# Substitua pela URL real do seu blog. Certifique-se de que tenha artigos!
TARGET_BLOG_URL = "https://www.example-blog.com/articles" 
SEARCH_KEYWORD = "beginner" # A palavra-chave para encontrar nos títulos dos artigos
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # SUBSTITUA ISSO! Ou use os.environ.get("OPENAI_API_KEY")

# Defina a chave da API do OpenAI
openai.api_key = OPENAI_API_KEY

# --- Funções Auxiliares ---
def fetch_webpage(url):
 """Recupera o conteúdo HTML de uma URL dada."""
 try:
 response = requests.get(url, timeout=10) # Adicionado um timeout
 response.raise_for_status() 
 return response.text
 except requests.exceptions.RequestException as e:
 print(f"Erro ao buscar a URL {url}: {e}")
 return None

def find_article_links(html_content, base_url, keyword):
 """Analisa o HTML para encontrar títulos e URLs de artigos que correspondam a uma palavra-chave."""
 soup = BeautifulSoup(html_content, 'html.parser')
 article_data = []

 # --- PONTO DE PERSONALIZAÇÃO 1: Ajuste esses seletores para o seu blog alvo ---
 # Inspecione a página do blog para encontrar as tags HTML e classes corretas para contêineres de artigos, títulos e links.
 article_containers = soup.find_all('div', class_='article-card') # Comum para cartões de artigo/visualizações
 if not article_containers:
 article_containers = soup.find_all('article') # Outra tag comum para artigos individuais
 if not article_containers:
 print("Aviso: Não foi possível encontrar tags de contêiner de artigo comuns. Tentando uma busca mais ampla.")
 # Fallback: apenas procure por todos os links que possam ser links para artigos
 all_links = soup.find_all('a', href=True)
 for link in all_links:
 title_text = link.get_text(strip=True)
 if keyword.lower() in title_text.lower():
 href = link['href']
 full_url = requests.compat.urljoin(base_url, href)
 article_data.append({'title': title_text, 'url': full_url})
 return article_data # Retorna cedo se apenas links amplos forem encontrados

 for container in article_containers:
 # Procura pelo título e link dentro de cada contêiner
 title_tag = container.find(['h2', 'h3', 'a']) # Títulos costumam estar em h2/h3 ou diretamente vinculados
 link_tag = container.find('a', href=True)
 
 if title_tag and link_tag:
 title = title_tag.get_text(strip=True)
 href = link_tag['href']
 
 # Construa a URL completa se for relativa
 full_url = requests.compat.urljoin(base_url, href)

 if keyword.lower() in title.lower():
 article_data.append({'title': title, 'url': full_url})
 
 return article_data

def extract_article_text(article_url):
 """Recupera uma página de artigo e extrai seu conteúdo textual principal."""
 article_html = fetch_webpage(article_url)
 if not article_html:
 return None

 soup = BeautifulSoup(article_html, 'html.parser')
 
 # --- PONTO DE PERSONALIZAÇÃO 2: Ajuste esses seletores para o conteúdo principal do artigo ---
 # Procure pela área de conteúdo principal do artigo (por exemplo, div com classe 'entry-content', 'article-body')
 content_area = soup.find('div', class_='entry-content') 
 if not content_area:
 content_area = soup.find('article', class_='main-article-content') # Outro padrão comum
 if not content_area:
 content_area = soup.find('div', id='content') # Mais um ID comum

 if content_area:
 paragraphs = content_area.find_all('p')
 return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
 else:
 # Fallback: pegue todas as tags de parágrafo se a área de conteúdo específica não for encontrada
 print(f"Aviso: Área de conteúdo específica não encontrada para {article_url}. Extraindo todos os parágrafos.")
 paragraphs = soup.find_all('p')
 return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])

def summarize_text_with_llm(text):
 """Usa um LLM para resumir o texto fornecido."""
 if not text or len(text.strip()) < 50: # Comprimento mínimo de texto para tentar resumir
 return "Conteúdo insuficiente para resumo."
 
 # Truncamento simples para permanecer dentro dos limites típicos da janela de contexto
 # Considere usar um contador de tokens apropriado para mais precisão, se necessário
 max_chars_for_llm = 40000 # Aproximadamente 10k tokens para GPT-3.5-turbo 16k context
 if len(text) > max_chars_for_llm:
 print(f"Aviso: Texto truncado de {len(text)} para {max_chars_for_llm} caracteres para LLM.")
 text = text[:max_chars_for_llm]

 try:
 response = openai.chat.completions.create(
 model="gpt-3.5-turbo", # Você pode usar "gpt-4" se tiver acesso e quiser qualidade melhor
 messages=[
 {"role": "system", "content": "Você é um assistente útil que resume postagens de blog de forma concisa e clara."},
 {"role": "user", "content": f"Por favor, forneça um resumo conciso da seguinte postagem de blog, destacando os pontos principais:\n\n{text}"}
 ],
 temperature=0.6, # Um pouco menos aleatório para resumos
 max_tokens=600 # Máximo de tokens para o resumo gerado
 )
 return response.choices[0].message.content.strip()
 except openai.APIError as e:
 print(f"Erro na API do OpenAI: {e}")
 return f"Falha devido a erro na API: {e}"
 except Exception as e:
 print(f"Ocorreu um erro inesperado durante o resumo: {e}")
 return f"Falha devido a um erro inesperado: {e}"

# --- Lógica Principal do Agente ---
def run_browser_agent():
 print(f"Iniciando agente do navegador para {TARGET_BLOG_URL} para encontrar artigos sobre '{SEARCH_KEYWORD}'...")

 # Etapa 1: Buscar a página principal do blog
 blog_html = fetch_webpage(TARGET_BLOG_URL)
 if not blog_html:
 print("Agente falhou ao buscar a página principal do blog. Saindo.")
 return

 # Etapa 2: Encontrar artigos correspondentes à palavra-chave
 found_articles = find_article_links(blog_html, TARGET_BLOG_URL, SEARCH_KEYWORD)

 if not found_articles:
 print(f"Nenhum artigo encontrado contendo '{SEARCH_KEYWORD}' em {TARGET_BLOG_URL}. Agente finalizado.")
 return

 print(f"\nEncontrados {len(found_articles)} artigos potenciais contendo '{SEARCH_KEYWORD}':")
 for i, article in enumerate(found_articles):
 print(f"{i+1}. Título: {article['title']}\n URL: {article['url']}")
 
 # Para este exemplo, vamos processar o primeiro artigo encontrado
 target_article = found_articles[0]
 print(f"\nProcessando o primeiro artigo encontrado: '{target_article['title']}' em {target_article['url']}")

 # Etapa 3: Extrair conteúdo do artigo alvo
 article_content = extract_article_text(target_article['url'])

 if not article_content:
 print(f"Agente falhou ao extrair conteúdo de {target_article['url']}. Não é possível resumir.")
 return

 print(f"\nConteúdo do artigo extraído (primeiros 200 caracteres): {article_content[:200]}...")

 # Etapa 4: Resumir o conteúdo usando LLM
 print("\nSolicitando LLM para o artigo...")
 summary = summarize_text_with_llm(article_content)

 print("\n--- Relatório Final do Agente ---")
 print(f"Título do Artigo: {target_article['title']}")
 print(f"URL do Artigo: {target_article['url']}")
 print("\nResumo:")
 print(summary)
 print("\n--- Tarefa do Agente Concluída ---")

if __name__ == "__main__":
 run_browser_agent()

Insights Ações para Sua Própria Jornada de Agentes

Este pequeno projeto é apenas a ponta do iceberg, mas mostra a mecânica central. Aqui está o que eu aprendi e o que você deve ter em mente:

1. Comece Pequeno, Pense Específico: Não tente construir o Skynet no primeiro dia. Escolha uma tarefa muito estreita e alcançável para seu agente. “Encontre uma receita de lasanha vegana” é melhor do que “cozinhe o jantar para mim.”
2. Web Scraping é o Velho Oeste: Cada site é diferente. Você VAI gastar tempo inspecionando elementos no seu navegador para obter os seletores CSS ou XPath corretos. Este é o trabalho duro, mas é essencial. Os sites mudam, então seu agente pode precisar de ajustes ocasionais.
3. Tratamento de Erros é Seu Amigo: As coisas vão dar errado. Os sites irão ficar fora do ar, sua internet irá cair, chamadas de API irão falhar. Adicione try-except para lidar com esses problemas de forma elegante.
4. LLMs são Inteligentes, mas Precisam de Orientação: A qualidade da saída do seu LLM depende muito do seu prompt. Seja claro, conciso e diga exatamente o que você espera. Além disso, esteja ciente dos limites da janela de contexto e dos custos.
5. Esta é uma Fundamento: Nós construímos um agente de turno único. Agentes reais geralmente envolvem múltiplas etapas, lógica condicional (por exemplo, “se eu encontrar isso, então faça aquilo”), e memória. Mas você já tem os blocos de construção agora.

Minha esperança é que ver este agente simples ganhar vida desmistifique um pouco o conceito de “agente de IA”. Não é mágica; é apenas automação inteligente construída com ferramentas existentes. Vá em frente, mexa e construa seus próprios pequenos ajudantes digitais!

Feliz codificação,

Emma Walsh, agent101.net

Artigos Relacionados

• Como Agentes de IA Dominam Múltiplas Linguagens com Suavidade
• Eu Tornei Meu Agente de IA Útil (Aqui Está Como)
• Eu Construí um Agente de IA em 2026: Minha Opinião Honesta

🕒 Published: April 1, 2026