Olá, agente em formação! Aqui é a Emma, de volta ao agent101.net, e hoje vamos explorar algo que está fervendo sob a superfície há um tempo, mas que finalmente está começando a ganhar vida: fazer com que agentes de IA ajam por você, mesmo que você seja iniciante. Mais especificamente, vamos falar sobre como obter um agente de IA simples para monitorar uma parte específica da internet por você e informar quando algo muda. Pense nisso como seu cachorro de caça digital pessoal, porém muito menos incômodo.
Há meses venho testando várias ferramentas de IA, tentando empurrá-las além da simples redação de poemas divertidos ou do resumo de artigos. Queria que elas fossem proativas. Queria que fossem… agentes! Mas toda vez que assistia a um tutorial, sentia como se precisasse de um diploma em ciência da computação e de um final de semana livre apenas para configurar o ambiente. Frustrante, não?
Então, algumas semanas atrás, eu estava tentando acompanhar o lançamento de um produto específico – um novo dispositivo de casa inteligente que eu precisava desesperadamente ter. Era uma daquelas coisas que surgem sem muito aviso, e o estoque desaparece em minutos. Atualizar a página a cada cinco minutos estava me deixando maluca. Meus dedos doíam, meus olhos estavam embaçados, e meu consumo de café estava perigosamente alto. Foi nesse momento que tive uma revelação: esse é exatamente o tipo de tarefa repetitiva, que exige vigilância, para a qual um agente de IA é perfeito. E eu encontrei uma maneira de fazer isso que, mesmo eu, como uma blogueira de tecnologia autoproclamada que “de vez em quando se perde em YAML”, consegui lidar. Sem frameworks sofisticados, sem bibliotecas obscuras, apenas um pouco de Python e uma boa compreensão do que um assistente de IA pode fazer por você.
Hoje, vamos criar um agente de IA simples que monitora uma página da web por uma mudança específica e te avisa. Não se trata de construir o próximo Skynet; trata-se de resolver um problema real do dia a dia com uma pitada de magia de IA. E acredite em mim, se eu consigo fazer isso, você também consegue.
O que é um agente de IA de monitoramento simples?
Basicamente, um agente de IA de monitoramento é apenas um programa que observa algo e reage quando certas condições são atendidas. No nosso caso, ele vai monitorar uma página da web. Por que “agente de IA” e não apenas “script”? Bem, a parte “IA” entra em cena quando começamos a pensar em como ele interpreta as mudanças e como decide o que é importante. Para este tutorial voltado a iniciantes, manteremos a IA bem leve – pense nisso como o uso de um modelo de IA para nos ajudar a entender o texto, sem necessariamente tomar decisões complexas. A parte “agente” é o ciclo: observar, refletir (um pouco), agir, repetir.
Meu objetivo com esse agente era simples: eu queria saber o *momento exato* em que a página do produto desse dispositivo de casa inteligente mudava de “Esgotado” para “Em estoque.” Eu não queria receber notificações para cada pequena atualização, apenas essa informação crucial. No entanto, isso não é apenas para lançamentos de produtos. Imagine seguir ofertas de emprego, artigos de notícias sobre um assunto específico, alterações de preços dos concorrentes ou até mesmo atualizações do seu webcomic favorito. As possibilidades são bem legais uma vez que você entendeu o conceito.
As ferramentas de que precisaremos (não entre em pânico, é minimalista)
- Python: Se você ainda não o tem, vá buscá-lo. É gratuito e relativamente fácil de usar.
- Algumas bibliotecas Python: Vamos usar
requestspara recuperar páginas da web,BeautifulSouppara analisar HTML e potencialmente uma maneira de enviar notificações (comosmtplibpara email ou um simples webhook). - Um modelo de IA (opcional, mas útil): Para isso, vou assumir que você tem acesso a algo como a API da OpenAI ou a API Gemini do Google. Vamos usar isso para detectar mudanças de forma inteligente, em vez de apenas fazer uma correspondência de texto simples. É aqui que a “IA” realmente entra em ação além de um simples script.
- Um editor de texto: VS Code, Sublime Text, até mesmo Notepad se você estiver se sentindo old-school.
Viu? Nada de muito intimidador. Não estamos configurando servidores ou configurando serviços em nuvem complicados. Tudo isso é feito localmente, na sua máquina, assim como eu fiz.
Etapa 1: Recuperando o conteúdo da página web
Primeiro, nosso agente realmente precisa “ver” a página web. Vamos usar a biblioteca requests para isso. É como seu navegador, mas sem os gráficos elaborados – ele obtém apenas o HTML bruto.
import requests
def fetch_page_content(url):
try:
response = requests.get(url)
response.raise_for_status() # Isso disparará uma HTTPError para respostas ruins (4xx ou 5xx)
return response.text
except requests.exceptions.RequestException as e:
print(f"Erro ao recuperar a URL {url}: {e}")
return None
# Vamos tentar com uma URL fictícia (substitua pela sua real)
# Para este exemplo, eu usarei um espaço reservado. NUNCA faça scraping sem verificar o robots.txt de um site
# e os termos de uso. Seja respeitoso e não sobrecarregue os servidores!
target_url = "https://example.com/product-page" # SUBSTITUA ISTO PELO SEU ALVO REAL
current_content = fetch_page_content(target_url)
if current_content:
print("Conteúdo recuperado com sucesso. Primeiros 200 caracteres:")
print(current_content[:200])
else:
print("Falha ao recuperar o conteúdo.")
Quando escrevi isso pela primeira vez, eu realmente tentei recuperar uma página que bloqueava requisições automatizadas. Recebi um erro 403. Oops! Tive que encontrar outro site alvo ou descobrir como adicionar cabeçalhos para imitar um navegador. Para este tutorial, vamos supor que o site que você está mirando está de acordo com requisições básicas. Sempre verifique o arquivo robots.txt do site (por exemplo, https://example.com/robots.txt) para ver o que eles permitem e não permitem para robôs. O scraping ético é importante!
Etapa 2: Analisando o HTML para encontrar o que é importante
Uma vez que temos o HTML bruto, é um emaranhado de tags e texto. Precisamos extrair a parte específica que diz “Em estoque” ou “Esgotado.” É aqui que BeautifulSoup entra em cena. Ele nos ajuda a navegar pela estrutura HTML como um mapa.
Essa foi a parte mais complicada para mim. Cada site é diferente. Você precisa abrir a página alvo no seu navegador, clicar com o botão direito no elemento que lhe interessa (como o texto “Em estoque”) e selecionar “Inspecionar” ou “Inspecionar elemento.” Isso mostrará o código HTML para essa parte específica. Procure identificadores únicos como IDs ou nomes de classe.
from bs4 import BeautifulSoup
def extract_relevant_info(html_content):
if not html_content:
return "Sem conteúdo para analisar."
soup = BeautifulSoup(html_content, 'html.parser')
# Isso é muito específico para a página web que você está monitorando.
# VOCÊ PRECISA MUDAR ISTO.
# Exemplo: Procurar um div com uma classe específica ou um span com texto específico.
# Para minha página de produto, o status do estoque geralmente estava em uma tag com uma classe como "product-status"
# Tente encontrar um span ou um div contendo o status de estoque
stock_element = soup.find('span', class_='product-status') # Ajuste o nome da classe conforme a sua inspeção
if not stock_element:
stock_element = soup.find('div', id='stock-indicator') # Ajuste o ID conforme a sua inspeção
if stock_element:
return stock_element.get_text(strip=True)
else:
# Se não conseguimos encontrar o elemento específico, vamos retornar um extrato maior ou até o corpo todo
# e deixar o modelo de IA cuidar disso. É um bom plano B.
body_content = soup.find('body')
if body_content:
return body_content.get_text(separator=' ', strip=True)
return "Elemento específico não encontrado, fornecendo o texto completo da página (isso pode ser barulhento)."
# Supondo que `current_content` venha da etapa anterior
relevant_text = extract_relevant_info(current_content)
print(f"Texto relevante extraído: {relevant_text[:200]}...") # Exibe os primeiros 200 caracteres
Minhas tentativas iniciais aqui foram falhas hilariantes. Tentei pegar apenas a página inteira e dar para a IA, o que funcionava às vezes, mas era realmente lento e caro (as chamadas da API não são gratuitas!). Depois, tentei ser muito específico e perdi o elemento porque o nome da classe havia mudado ligeiramente. A chave é encontrar um equilíbrio: específico o suficiente para reduzir o ruído, geral o suficiente para lidar com pequenas mudanças de layout.
Etapa 3: A magia da IA – Detectar uma mudança significativa
Aqui está a parte divertida! Em vez de simplesmente fazer uma comparação de texto simples (que seria acionada a cada pequena mudança no anúncio), vamos usar um modelo de IA para nos dizer se o *sentido* do texto relevante mudou de maneira significativa em relação ao nosso interesse (o status do estoque).
Para isso, você precisará de uma chave API para o seu modelo de IA escolhido (OpenAI, Gemini, etc.). Armazene-a em segurança, não diretamente em seu código!
import os
from openai import OpenAI # Ou `google.generativeai` se você usar Gemini
# Configure sua chave API OpenAI
# NUNCA codifique chaves API diretamente! Use variáveis de ambiente ou um arquivo de configuração.
# os.environ["OPENAI_API_KEY"] = "SUA_CHAVE_API_AQUI" # NÃO FAÇA ISSO NO CÓDIGO DE PRODUÇÃO
# Em vez disso, defina-a em seu terminal: export OPENAI_API_KEY="sk-..."
client = OpenAI() # Supondo que OPENAI_API_KEY esteja definida nas variáveis de ambiente
def ask_ai_about_change(old_text, new_text, target_keyword="em estoque"):
prompt = f"""
Você é um assistente inteligente monitorando uma página da web em busca de mudanças relacionadas à disponibilidade de produtos.
Vou fornecer duas versões de texto extraídas de uma página de produto.
Sua tarefa é determinar se o status de disponibilidade do produto mudou de maneira significativa,
especificamente se ele se tornou '{target_keyword}' quando não era antes,
ou se mudou de '{target_keyword}'.
Texto antigo:
"{old_text}"
Novo texto:
"{new_text}"
A disponibilidade do produto mudou para ou de '{target_keyword}'?
Se sim, explique brevemente a mudança. Caso contrário, diga apenas 'Sem mudança significativa.'
Concentre-se apenas na disponibilidade, ignore mudanças menores de redação ou formatação.
"""
try:
completion = client.chat.completions.create(
model="gpt-3.5-turbo", # Ou "gpt-4", "gemini-pro", etc.
messages=[
{"role": "system", "content": "Você é um assistente útil."},
{"role": "user", "content": prompt}
],
max_tokens=150
)
return completion.choices[0].message.content
except Exception as e:
print(f"Erro ao chamar o modelo de IA: {e}")
return "A análise de IA falhou."
# Exemplo de uso (normalmente você faria isso em um loop)
# Por enquanto, vamos simular uma mudança
# Suponha que 'previous_relevant_text' venha de um fetch anterior
previous_relevant_text = "Fora de estoque. Reabastecimento previsto em 2 semanas."
new_relevant_text = "Em estoque! Quantidade limitada disponível."
ai_response = ask_ai_about_change(previous_relevant_text, new_relevant_text, "Em estoque")
print(f"Avaliação da IA: {ai_response}")
# Simular nenhuma mudança
new_relevant_text_no_change = "Fora de estoque. Reabastecimento previsto em 3 semanas."
ai_response_no_change = ask_ai_about_change(previous_relevant_text, new_relevant_text_no_change, "Em estoque")
print(f"Avaliação da IA (simulação sem mudança): {ai_response_no_change}")
É aqui que o agente se torna realmente “IA.” Em vez de escrever expressões regulares complexas ou comparações de strings frágeis, eu simplesmente digo à IA que tipo de mudança estou procurando. É como ter um estagiário que entende o contexto! Quando experimentei isso pela primeira vez, temia que a IA se perdesse em leves variações de redação. Mas com um bom prompt, foi surpreendentemente sólido. Ela identificou corretamente quando “Disponível em breve” se tornou “Pré-encomende agora” como uma mudança significativa, mesmo que as palavras exatas “Em estoque” não estivessem presentes.
Passo 4: Unir tudo – O loop do agente e a notificação
Um agente deve funcionar continuamente. Então, vamos encapsular nossa lógica de recuperação e verificação em um loop. E quando encontrar algo, ele deve nos avisar!
import time
# ... (import requests, BeautifulSoup, os, OpenAI das etapas anteriores) ...
# Variável global para armazenar o último estado conhecido
last_known_status_text = ""
def send_notification(message):
print(f"\n!!! Alerta AGENTE !!!\n{message}\n")
# Aqui, você integraria com um verdadeiro serviço de notificação:
# - Email (usando smtplib)
# - Serviço de notificação push (Pushover, webhook IFTTT, bot Telegram)
# - Gateway SMS
# Para simplificar, vamos apenas imprimir no console.
# Exemplo para o email (requer configuração):
# import smtplib
# from email.mime.text import MIMEText
# msg = MIMEText(message)
# msg['Subject'] = 'Mudança na página web detectada!'
# msg['From'] = '[email protected]'
# msg['To'] = '[email protected]'
# try:
# with smtplib.SMTP_SSL('smtp.example.com', 465) as smtp:
# smtp.login('[email protected]', 'seu_senha')
# smtp.send_message(msg)
# print("Notificação por email enviada.")
# except Exception as e:
# print(f"Falha ao enviar o email: {e}")
def run_agent(url, interval_seconds=300, target_keyword="Em estoque"):
global last_known_status_text
print(f"O agente começa a monitorar {url} a cada {interval_seconds} segundos.")
print("Recuperação inicial...")
# Recuperação inicial para definir a linha de base
html_content = fetch_page_content(url)
if html_content:
last_known_status_text = extract_relevant_info(html_content)
print(f"Status inicial definido: {last_known_status_text[:100]}...")
else:
print("Não foi possível recuperar o conteúdo inicial. O agente começa com uma linha de base vazia.")
# Se a recuperação inicial falhar, o agente tentará novamente na primeira iteração do loop
while True:
print(f"\n[{time.strftime('%Y-%m-%d %H:%M:%S')}] Verificando {url}...")
current_html_content = fetch_page_content(url)
if current_html_content:
new_relevant_text = extract_relevant_info(current_html_content)
if not last_known_status_text: # Lidar com o caso em que a recuperação inicial falhou
last_known_status_text = new_relevant_text
print(f"Linha de base definida após falha inicial: {last_known_status_text[:100]}...")
if new_relevant_text != last_known_status_text:
print("Mudança potencial detectada. Consultando a IA...")
ai_analysis = ask_ai_about_change(last_known_status_text, new_relevant_text, target_keyword)
if "Sem mudança significativa." not in ai_analysis:
send_notification(f"Atualização da página web para {url}:\n{ai_analysis}\nNovo texto: {new_relevant_text[:200]}...")
last_known_status_text = new_relevant_text # Atualizar a linha de base apenas em caso de mudança significativa
else:
print(f"A IA determinou: {ai_analysis} (menor, ignorado)")
# Mesmo que a IA diga que não houve mudança significativa, poderíamos querer atualizar a linha de base
# para evitar alertas repetidos de "mudança potencial" para a mesma diferença menor.
# Ou, deixe assim se você quiser que a IA reavalie a cada vez.
# Para este exemplo, vamos atualizar para evitar spams à IA por mudanças menores estáticas.
last_known_status_text = new_relevant_text
else:
print("Nenhuma mudança textual detectada na seção relevante.")
else:
print(f"Falha ao recuperar o conteúdo de {url} nesta iteração.")
time.sleep(interval_seconds) # Esperar antes de verificar novamente
# --- Execução principal ---
if __name__ == "__main__":
# Configure sua URL alvo e o intervalo desejado
# Tenha cuidado com as políticas do site e não faça requisições muito frequentes!
my_target_url = "https://www.some-store.com/new-widget-X" # <<< SUBSTITUA ISSO!
monitoring_interval = 600 # Verifique a cada 10 minutos (600 segundos)
desired_status = "Em estoque" # Que palavra-chave estamos procurando?
# IMPORTANTE: Certifique-se de que sua chave API OpenAI está definida como uma variável de ambiente!
# export OPENAI_API_KEY="sk-..." no seu terminal antes de executar.
run_agent(my_target_url, monitoring_interval, desired_status)
Defini meu intervalo em 5 minutos para esse dispositivo de casa inteligente insaissecível. Sempre que eu via a mensagem "Verificando...", sentia uma pequena onda de emoção. Quando a notificação finalmente chegou – "Em estoque! Quantidade limitada disponível." – juro que ouvi anjos cantando. Cliquei no link, adicionei ao meu carrinho e paguei em segundos. Sucesso! Meu pequeno agente IA me salvou de um refresh sem fim e me ajudou a conseguir esse gadget.
Lições concretas para o seu primeiro agente IA
- Comece pequeno: Não tente construir um agente conversacional complexo desde o início. Uma tarefa simples de monitoramento é perfeita para aprender o básico.
- Inspecione seu alvo: Compreender a estrutura HTML da página da web que você está monitorando é crucial. Utilize as ferramentas de desenvolvimento do seu navegador.
- A engenharia de prompt é fundamental: Quanto mais precisamente você descrever o tipo de mudança que está buscando para o modelo de IA, mais precisas e úteis serão suas respostas. Experimente seus prompts!
- Seja respeitoso: Não bombardeie os sites com requisições. Use intervalos razoáveis, verifique
robots.txt, e compreenda os termos de uso de um site em relação ao acesso automatizado. - Proteja suas chaves: Nunca codifique as chaves API diretamente no seu script. Use variáveis de ambiente.
- Itere: Sua primeira tentativa pode não ser perfeita. A minha certamente não foi! Ajuste seus seletores `BeautifulSoup`, refine seu prompt de IA e modifique seu método de notificação até que funcione para você.
Construir este agente foi um enorme impulso de confiança para mim. Isso me mostrou que a IA não é apenas para grandes empresas ou pesquisa acadêmica. É uma ferramenta que nós, como usuários individuais e desenvolvedores ocasionais, podemos usar para resolver nossos próprios problemas e tornar nossas vidas digitais um pouco mais fáceis. Então vá em frente, escolha uma página da web que você está cansado de verificar manualmente e construa seu próprio cão de caça digital. Você ficará surpreso com o que pode realizar!
Artigos relacionados
- Quando seu agente se rebela: dominando os interruptores de emergência
- Agentes IA no imobiliário: transformando a indústria
- API OpenAI em 2026: 7 coisas após 3 meses de uso
🕒 Published: