Oi, agente em treinamento! Emma aqui, de volta ao agent101.net, e hoje vamos explorar algo que vem borbulhando em segundo plano por um tempo, mas que finalmente está ganhando forma: fazer agentes de IA realmente fazerem coisas por você, mesmo se você estiver apenas começando. Especificamente, vamos falar sobre como fazer um agente de IA simples monitorar uma parte específica da internet para você e te avisar quando algo mudar. Pense nisso como seu cão de caça digital pessoal, mas muito menos bagunçado.
Há meses, venho experimentando várias ferramentas de IA, tentando empurrá-las para além de apenas escrever poemas engraçados ou resumir artigos. Queria que elas fossem proativas. Queria que elas fossem… agentes! Mas toda vez que eu olhava para um tutorial, parecia que eu precisava de um diploma em ciência da computação e de um fim de semana livre apenas para configurar o ambiente. Frustrante, né?
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 simplesmente tinha que colocar as mãos. Era uma daquelas coisas que apareciam sem muito aviso e o estoque sumia em minutos. Atualizar a página a cada cinco minutos estava me deixando maluca. Meus dedos doíam, meus olhos estavam embaçados, e minha ingestão de café estava perigosamente alta. Foi aí que a ficha caiu: essa é exatamente o tipo de tarefa repetitiva e que requer vigilância para a qual um agente de IA é perfeito. E eu descobri uma forma de fazer isso que até eu, uma blogueira de tecnologia autodenominada “que às vezes se confunde com YAML”, conseguiria gerenciar. Nada de frameworks sofisticados, nenhuma biblioteca obscura, apenas um pouco de Python e uma boa compreensão do que um assistente de IA pode fazer por você.
Então, hoje, vamos construir um agente de IA simples que monitore uma página da web para uma mudança específica e te notifique. Isso não é sobre construir a próxima Skynet; trata-se de resolver um problema real do dia a dia com uma pitada de mágica da IA. E acredite em mim, se eu conseguir, você também consegue.
O que É um Agente de IA de Monitoramento Simples?
Em sua essência, 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 observar uma página da web. Por que “agente de IA” e não apenas “script”? Bem, a parte de “IA” entra quando começamos a pensar em como ele interpreta as mudanças e como decide o que é importante. Para este tutorial para iniciantes, estamos mantendo a IA bem leve – pense nisso como usar um modelo de IA para nos ajudar a entender o texto, não necessariamente para tomar decisões complexas. A parte de “agente” é o loop: observar, pensar (um pouco), agir, repetir.
Meu objetivo com este agente era simples: eu queria saber o *instante* em que a página do produto para aquele dispositivo de casa inteligente mudasse de “Indisponível” para “Disponível.” Eu não queria ser incomodada com cada pequena atualização, apenas aquela informação crucial. Isso não serve apenas para lançamentos de produtos, embora. Imagine monitorar postagens de emprego, artigos de notícias sobre um tópico específico, mudanças nos preços da concorrência ou até mesmo atualizações do seu webcomic favorito. As possibilidades são bem legais assim que você pega o jeito.
As Ferramentas que Precisamos (Não entre em Pânico, é Mínimo)
- Python: Se você não tiver, vá pegar. É gratuito e relativamente fácil de usar.
- Algumas bibliotecas Python: Usaremos
requestspara buscar páginas da web,BeautifulSouppara analisar HTML e, possivelmente, uma maneira de enviar notificações (comosmtplibpara email ou um webhook simples). - 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 do Gemini do Google. Nós a usaremos para detectar mudanças de forma inteligente, em vez de apenas corresponder texto simples. É aqui que a “IA” realmente entra em cena além de apenas um script.
- Um editor de texto: VS Code, Sublime Text, até mesmo o Notepad se você estiver se sentindo à moda antiga.
Viu? Nada muito intimidador. Não estamos levantando servidores ou configurando serviços em nuvem complexos. Tudo isso é local, na sua máquina, assim como eu fiz.
Passo 1: Buscando o Conteúdo da Página Web
Primeiro, nosso agente precisa realmente “ver” a página da web. Vamos usar a biblioteca requests para isso. É como seu navegador, mas sem os gráficos sofisticados – ele apenas obtém o HTML bruto.
import requests
def fetch_page_content(url):
try:
response = requests.get(url)
response.raise_for_status() # Isso levantará 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 experimentar com uma URL de teste (substitua pela sua real)
# Para este exemplo, usarei um marcador. NUNCA faça scraping sem verificar o robots.txt de um site
# e os termos de serviço. Seja respeitoso e não sobrecarregue os servidores!
target_url = "https://example.com/product-page" # SUBSTITUA ISSO PELA SUA ALVO REAL
current_content = fetch_page_content(target_url)
if current_content:
print("Conteúdo buscado com sucesso. Primeiros 200 caracteres:")
print(current_content[:200])
else:
print("Falha ao buscar conteúdo.")
Quando escrevi isso pela primeira vez, na verdade tentei buscar uma página que bloqueou solicitações automatizadas. Recebi um erro 403. Oops! Tive que encontrar um site de destino diferente ou descobrir como adicionar cabeçalhos para imitar um navegador. Para este tutorial, vamos assumir que o site que você está monitorando está ok 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 crawlers. O scraping ético é importante!
Passo 2: Analisando o HTML para Encontrar o que Importa
Uma vez que temos o HTML bruto, ele é uma bagunça de tags e texto. Precisamos extrair a parte específica que indica “Disponível” ou “Indisponível.” É aqui que entra o BeautifulSoup. Ele nos ajuda a navegar pela estrutura HTML como um mapa.
Essa foi a parte mais difícil para mim. Cada site é diferente. Você tem que abrir a página alvo no seu navegador, clicar com o botão direito no elemento que você está interessado (como o texto “Disponível”), e selecionar “Inspecionar” ou “Inspecionar Elemento.” Isso mostrará o código HTML daquela parte específica. Procure por 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 é altamente específico para a página que você está monitorando.
# VOCÊ PRECISARÁ MUDAR ISSO.
# Exemplo: Procurando uma div com uma classe específica, ou um span com texto específico.
# Para minha página de produto, o status do estoque frequentemente estava em uma tag com uma classe como "product-status"
# Tente encontrar um span ou div que contenha o status do estoque
stock_element = soup.find('span', class_='product-status') # Ajuste o nome da classe com base na sua inspeção
if not stock_element:
stock_element = soup.find('div', id='stock-indicator') # Ajuste o ID com base na sua inspeção
if stock_element:
return stock_element.get_text(strip=True)
else:
# Se não conseguirmos encontrar o elemento específico, retorne um pedaço maior ou até mesmo o corpo inteiro
# e deixe o modelo de IA descobrir. Esta é uma boa alternativa.
body_content = soup.find('body')
if body_content:
return body_content.get_text(separator=' ', strip=True)
return "Elemento específico não encontrado, fornecendo texto completo da página (pode ser barulhento)."
# Assumindo que `current_content` é do passo anterior
relevant_text = extract_relevant_info(current_content)
print(f"Texto relevante extraído: {relevant_text[:200]}...") # Imprimir os primeiros 200 caracteres
Minhas tentativas iniciais aqui foram hilárias falhas. Eu tentei pegar a página inteira e alimentá-la para a IA, o que às vezes funcionava, mas era realmente lento e caro (as chamadas à API não são gratuitas!). Depois, tentei ser muito específica e perdi o elemento porque o nome da classe mudou 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.
Passo 3: A Mágica da IA – Detectando Mudanças Significativas
Agora vem a parte divertida! Em vez de apenas fazer uma comparação simples de texto (que acionaria em cada pequena mudança de anúncio), usaremos um modelo de IA para nos dizer se o *significado* do texto relevante mudou de forma significativa em relação ao nosso interesse (o status do estoque).
Para isso, você precisará de uma chave de API para o modelo de IA escolhido (OpenAI, Gemini, etc.). Armazene-a de forma segura, não diretamente no seu código!
import os
from openai import OpenAI # Ou `google.generativeai` se você estiver usando o Gemini
# Configure sua chave de API da OpenAI
# NUNCA insira chaves de API diretamente! Use variáveis de ambiente ou um arquivo de configuração.
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY_HERE" # NÃO FAÇA ISSO NO CÓDIGO DE PRODUÇÃO
# Em vez disso, defina-a no seu shell: export OPENAI_API_KEY="sk-..."
client = OpenAI() # Presume que a OPENAI_API_KEY está definida nas variáveis de ambiente
def ask_ai_about_change(old_text, new_text, target_keyword="in stock"):
prompt = f"""
Você é um assistente inteligente monitorando uma página da web em busca de alterações 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 significativamente,
especificamente se se tornou '{target_keyword}' quando anteriormente não estava,
ou se mudou para longe 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. Se não, apenas diga 'Nenhuma mudança significativa.'
Foque 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 "Análise da IA falhou."
# Exemplo de uso (normalmente você faria isso em um loop)
# Por enquanto, vamos simular uma mudança
# Presuma que 'previous_relevant_text' foi de uma coleta anterior
previous_relevant_text = "Fora de Estoque. Esperado reabastecimento 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. Esperado reabastecimento 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 de nenhuma mudança): {ai_response_no_change}")
É aqui que o agente realmente se torna “IA.” Em vez de eu escrever padrões regex complexos ou comparações de strings frágeis, eu apenas digo à IA que tipo de mudança estou procurando. É como ter um pequeno estagiário que entende o contexto! Quando tentei isso pela primeira vez, estava preocupado que a IA se confundisse com pequenas variações de redação. Mas com um bom prompt, foi surpreendentemente sólido. Ela identificou corretamente quando “Em Breve” se tornou “Pré-venda Agora” como uma mudança significativa, mesmo que as palavras exatas “Em Estoque” não estivessem presentes.
Passo 4: Juntando Tudo – O Loop do Agente e Notificação
Um agente precisa executar continuamente. Então, vamos encapsular nossa lógica de busca e verificação em um loop. E quando encontrar algo, precisa nos avisar!
import time
# ... (importar requests, BeautifulSoup, os, OpenAI dos passos anteriores) ...
# Variável global para armazenar o último estado conhecido
last_known_status_text = ""
def send_notification(message):
print(f"\n!!! ALERTA DO AGENTE !!!\n{message}\n")
# Aqui você integraria com um serviço de notificação real:
# - Email (usando smtplib)
# - Serviço de notificação push (Pushover, webhook IFTTT, bot do Telegram)
# - Gateway de SMS
# Para simplicidade, apenas imprimiremos no console.
# Exemplo para email (requer configuração):
# import smtplib
# from email.mime.text import MIMEText
# msg = MIMEText(message)
# msg['Subject'] = 'Mudança na Página Detectada!'
# msg['From'] = '[email protected]'
# msg['To'] = '[email protected]'
# try:
# with smtplib.SMTP_SSL('smtp.exemplo.com', 465) as smtp:
# smtp.login('[email protected]', 'sua_senha')
# smtp.send_message(msg)
# print("Notificação de email enviada.")
# except Exception as e:
# print(f"Falha ao enviar email: {e}")
def run_agent(url, interval_seconds=300, target_keyword="Em Estoque"):
global last_known_status_text
print(f"Agente começando a monitorar {url} a cada {interval_seconds} segundos.")
print("Coleta inicial...")
# Coleta 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 coletar o conteúdo inicial. O agente começando com linha de base vazia.")
# Se a coleta 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: # Tratar caso onde a coleta inicial falhou
last_known_status_text = new_relevant_text
print(f"Base definida após a falha inicial: {last_known_status_text[:100]}...")
if new_relevant_text != last_known_status_text:
print("Mudança potencial detectada. Perguntando à IA...")
ai_analysis = ask_ai_about_change(last_known_status_text, new_relevant_text, target_keyword)
if "Nenhuma mudança significativa." not in ai_analysis:
send_notification(f"Atualização da página da web para {url}:\n{ai_analysis}\nNovo Texto: {new_relevant_text[:200]}...")
last_known_status_text = new_relevant_text # Atualiza a linha de base apenas em mudança significativa
else:
print(f"IA determinou: {ai_analysis} (menor, ignorado)")
# Mesmo que a IA diga que não houve mudança significativa, podemos querer atualizar a linha de base
# para evitar alertas repetidos de "mudança potencial" pela mesma diferença menor.
# Ou, mantenha como está se quiser que a IA reavalie toda vez.
# Para este exemplo, atualizaremos para evitar spam para IA por mudanças estáticas menores.
last_known_status_text = new_relevant_text
else:
print("Nenhuma mudança textual detectada na seção relevante.")
else:
print(f"Falha ao coletar conteúdo de {url} nesta iteração.")
time.sleep(interval_seconds) # Aguarde antes de verificar novamente
# --- Execução principal ---
if __name__ == "__main__":
# Configure sua URL alvo e intervalo desejado
# Tenha cuidado com as políticas do site e não faça solicitações com muita frequência!
my_target_url = "https://www.alguma-loja.com/novo-widget-X" # <<< SUBSTITUA ISTO!
monitoring_interval = 600 # Verifique a cada 10 minutos (600 segundos)
desired_status = "Em Estoque" # Qual palavra-chave estamos procurando?
# IMPORTANTE: Certifique-se de que sua chave de API da 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 para 5 minutos para aquele elusivo dispositivo de casa inteligente. Cada vez que vi a mensagem "Verificando..." piscar, senti um pequeno palpitar de emoção. Quando a notificação finalmente chegou – "Em Estoque! Quantidade limitada disponível." – juro que ouvi anjos cantarem. Cliquei no link, adicionei ao meu carrinho e finalizei a compra em segundos. Sucesso! Meu pequeno agente de IA me salvou de atualizações incessantes e me ajudou a garantir aquele gadget.
Conselhos Práticos para seu Primeiro Agente de IA
- Comece Pequeno: Não tente construir um agente conversacional complexo logo de cara. Uma tarefa de monitoramento simples é perfeita para aprender.
- Inspecione Seu Alvo: Entender a estrutura HTML da página que você está monitorando é crucial. Use as ferramentas de desenvolvedor do seu navegador.
- Engenharia de Prompt é Fundamental: Quanto melhor você descrever que tipo de mudança está procurando para o modelo de IA, mais precisas e úteis serão suas respostas. Experimente seus prompts!
- Seja Respeitoso: Não sobrecarregue sites com solicitações. Use intervalos razoáveis, verifique
robots.txte entenda os termos de serviço de um site em relação ao acesso automatizado. - Proteja Suas Chaves: Nunca insira chaves de 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 pequeno agente foi um grande impulsionador de confiança para mim. Mostrou-me que a IA não é apenas para grandes empresas ou pesquisas acadêmicas. É uma ferramenta que nós, como usuários individuais e pequenos desenvolvedores, podemos usar para resolver nossos próprios problemas e tornar nossas vidas digitais um pouco mais fáceis. Então, siga em frente, escolha uma página que você está cansado de verificar manualmente e construa seu próprio bloodhound digital. Você ficará surpreso com o que pode alcançar!
Artigos Relacionados
- Quando Seu Agente Se Rebela: Dominando Kill Switches
- Agentes de IA na Imobiliária: Transformando a Indústria
- API da OpenAI em 2026: 7 Coisas Após 3 Meses de Uso
🕒 Published: