Olá, agente em treinamento! Aqui é a Emma, de volta de mais um mergulho noturno no mundo fascinante, às vezes frustrante, dos agentes de IA. Se você é como eu, provavelmente passou os últimos meses ouvindo rumores (ou gritos) sobre agentes de IA e pensou: “Certo, isso parece legal, mas também… o que realmente é, e como posso ter um que 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 *na teoria*. Vamos arregaçar as mangas e abordar uma questão que preocupa muitos de vocês (e a mim, até recentemente): Como construir um agente de IA simples que possa realmente navegar na Internet para mim e responder a perguntas específicas?
Vamos esquecer o entusiasmo por um momento. Vamos nos concentrar no prático. Nosso objetivo será o “Eu realmente consigo fazer isso funcionar no meu laptop.” Porque, honestamente, ver é acreditar, não é?
Meus próprios erros (e sucessos) com o navegador
Quando comecei a experimentar com a ideia de um agente capaz de usar a Internet, tinha grandes visões. Eu queria que ele pesquisasse tópicos complexos, comparasse preços em uma dúzia de sites e fosse, essencialmente, meu assistente digital pessoal. O que consegui, no início, foi um monte de erros, alguns scrapers web quebrados e um profundo sentimento de inadequação. Minhas primeiras tentativas foram como tentar ensinar uma criança pequena a operar uma máquina complexa – muito entusiasmo, nenhuma compreensão dos mecanismos subjacentes.
O maior obstáculo? Fazer um modelo de IA interagir com a Internet de maneira significativa e controlada. É uma coisa fazer uma pergunta ao ChatGPT para a qual ele já conhece a resposta. É outra coisa pedir que ele vá buscar novas informações, as interprete e então aja de acordo. É aí que a parte “agente” realmente entra em jogo.
Depois de muitas tentativas e erros, percebi que a chave não era construir uma entidade supercomplexa e onisciente desde o início. Era preciso começar pequeno, com uma tarefa muito específica, e desenvolver a partir daí. E é exatamente isso que vamos fazer hoje. Vamos criar um agente de navegador básico que pode acessar um site específico, extrair informações e fazer um relatório.
O que é um agente de IA de navegador?
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 maneira autônoma. Ele observa seu ambiente (no nosso caso, a Internet), toma decisões baseadas em seus objetivos e, em seguida, age. Um agente de IA *navegador* usa especificamente capacidades de navegação web como ferramenta.
Pense nisso assim: você diz ao seu agente, “Encontre-me a previsão do tempo atual em Londres.” Em vez de simplesmente acessar seu conhecimento interno, um agente navegador abriria (idealmente) um navegador web, acessaria um site de tempo, encontraria a informação e, então, a comunicaria a você. É a diferença entre fazer uma pergunta a um bibliotecário que já conhece a resposta e pedir que ele vá buscar um livro, leia um capítulo específico e o resuma para você.
Para nosso agente simples, vamos usar algumas bibliotecas Python comuns que tornam todo esse processo muito menos intimidador.
As ferramentas que precisaremos
Você não precisa de um supercomputador para isso. Apenas sua configuração de desenvolvimento habitual. Aqui está o que vamos usar:
- Python: Nossa linguagem de programação preferida. (Estou usando a versão 3.9, mas a 3.8+ deve ser suficiente.)
requests: Uma biblioteca fantástica para realizar requisições HTTP (isto é, recuperar páginas web).BeautifulSoup(bs4): Este é nosso mágico do parsing web. Ele nos ajuda a navegar e extrair dados de HTML.- Uma API de Grande Modelo Linguístico (LLM): Precisaremos de acesso a um LLM como os modelos GPT da OpenAI ou Claude da Anthropic. Para este tutorial, vou supor que você possui uma chave API da OpenAI.
Primeiro, 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 API da OpenAI à mão. Você deve configurá-la como variável de ambiente ou passá-la diretamente em seu script. Para simplificar, vou mostrá-la diretamente, mas em produção, as variáveis de ambiente são sempre melhores.
Nossa missão: Encontrar um artigo específico em um blog
Vamos estabelecer um objetivo concreto e alcançável. A missão do nosso agente será:
- Acessar um blog específico (vamos usar uma URL de blog fictício por enquanto, ou até agent101.net se você se sentir aventureiro!).
- Encontrar um título de post do blog que contenha uma palavra-chave específica (por exemplo, “iniciantes”).
- Extrair a URL desse post do blog.
- Resumir o conteúdo desse post do blog utilizando um LLM.
Esse é um ótimo ponto de partida, pois combina a interação web com a compreensão do LLM. É como pedir ao seu assistente digital para “me encontrar o último artigo sobre agentes de IA para iniciantes em agent101.net e me dizer do que se trata.”
Etapa 1: Recuperar a página web
A primeira etapa para qualquer agente de navegador é “ver” a página 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 uma HTTPError para respostas inválidas (4xx ou 5xx)
return response.text
except requests.exceptions.RequestException as e:
print(f"Erro ao recuperar a URL {url}: {e}")
return None
# Vamos usar uma URL de exemplo por enquanto.
# Substitua por uma URL verdadeira de blog que tenha artigos se você quiser testar!
blog_url = "https://www.example-blog.com/articles" # Use uma URL verdadeira aqui!
html_content = fetch_webpage(blog_url)
if html_content:
print("Conteúdo da página web recuperado com sucesso.")
# Vamos processar esse conteúdo na próxima etapa
else:
print("Falha ao recuperar a página web.")
Uma observação rápida sobre as URLs: Para que isso funcione, você precisará de uma URL verdadeira de blog. Se não tiver uma à mão, pode usar um site como `http://quotes.toscrape.com/` para testar o scraping simples, mas para posts de blog, encontre um blog verdadeiro. Até mesmo este site, agent101.net, poderia funcionar se você adaptar os seletores CSS depois!
Etapa 2: Analisar o HTML e encontrar links de artigos
Agora que temos o HTML bruto, é como ter um enorme livro sem índice. O BeautifulSoup é nosso indexador. Precisamos dizer a ele como encontrar os títulos dos artigos e seus links correspondentes.
Essa é a parte mais delicada, pois a estrutura HTML de cada site é diferente. Você precisará “inspecionar” o elemento no site alvo. Clique com o botão direito em um título de artigo do blog escolhido e selecione “Inspecionar” (ou “Inspecionar elemento”). Procure por padrões comuns, como as tags <h2> para os títulos, ou as tags <a> para os links, frequentemente aninhados dentro de um <div> com um nome de classe específico.
Para a demonstração, vamos presumir uma estrutura de blog comum onde os títulos dos artigos estão nas tags <h2>, e seus links estão em uma tag <a> diretamente dentro ou precedendo isso.
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ê deverá ajustar os seletores de acordo com o site alvo.
# Modelos comuns: div com a classe 'article-item', h2 com a classe 'article-title', etc.
# Suponha que os artigos estejam em elementos 'div' com a classe 'post'
# e que 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
# Em seguida, verifique se elas estão linkadas.
# Uma abordagem mais sólida pode consistir em encontrar primeiro os contêineres:
article_containers = soup.find_all('div', class_='article-card') # Ajuste esta classe!
if not article_containers:
# Retorne a outra seleção se a primeira 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 no 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 seja 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 anterior para fetch_webpage) ...
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 simplesmente 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* ajustá-las com base na estrutura HTML real do blog que você está focando. É aí 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 depois filtrar com classes ou IDs.
Etapa 3: Extrair o Conteúdo do Artigo Alvo
Uma vez que temos a URL do nosso artigo alvo, precisamos recuperar seu conteúdo e, em seguida, extrair o texto principal. Isso é muitas vezes mais fácil do que analisar uma página de índice, pois a maior parte do conteúdo dos artigos está em uma tag de conteúdo principal <div> ou <article>.
# ... (código anterior) ...
import openai
import os
# Defina sua chave API 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.
# Modelos comuns: encontrar um div com a classe 'entry-content', 'article-body', 'main-content'
# Ou apenas as tags dentro da tag principal do artigo.
# Vamos tentar encontrar as áreas de conteúdo comuns.
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, 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 uma div/artigo específico de conteúdo, extraímos todo o texto dos parágrafos
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"\nRecuperando o conteúdo para: {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Mostra os primeiros 500 caracteres para verificar
print("\nTexto do artigo extraído com sucesso. Vamos para a resumir.")
else:
print("Falha ao extrair o texto do artigo.")
article_text_content = "" # Certifique-se de que não seja None para a próxima etapa
else:
article_text_content = ""
Mais uma vez, a linha soup.find('div', class_='entry-content') é seu alvo principal para personalização. Use o inspetor do seu navegador!
Etapa 4: Resumir com um LLM
Finalmente, o momento em que fazemos a inteligência artificial intervir! Vamos alimentar o texto extraído para um LLM e pedir para resumir. É aí 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 o resumo."
# Truncar o texto se for muito longo para a janela de contexto do modelo
# GPT-3.5-turbo tem uma janela de contexto de 16k, mas é bom ficar razoável.
# Para um iniciante, mirar 4000-8000 tokens é seguro.
# Aproximadamente 1 token = 4 caracteres para texto em inglês.
max_tokens_for_input = 12000 # Ajuste de acordo com a 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"Aviso: texto truncado para ~{max_tokens_for_input} tokens para o processamento 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 artigos de blog de maneira concisa."},
{"role": "user", "content": f"Por favor, resuma a seguinte postagem de blog para mim:\n\n{text}"}
],
temperature=0.7, # Controle do aleatório. Mais baixo para resumos mais focados.
max_tokens=500 # Tokens máximos para o próprio resumo
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Erro API OpenAI: {e}")
return "Falha devido a um erro de API."
except Exception as e:
print(f"Um erro imprevisto ocorreu durante o resumo: {e}")
return "Falha devido a um erro imprevisto."
if article_text_content:
print("\nSolicitando resumo LLM...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Resumo do Artigo ---")
print(summary)
else:
print("\nImpossí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 apenas uma teoria; é um pedaço de código tangível que você pode executar.
Reunindo Tudo (Script Completo)
Aqui está o script completo para um fácil copiar e colar e testes. Não se esqueça de substituir as URLs de exemplo e sua chave API OpenAI!
import requests
from bs4 import BeautifulSoup
import openai
import os
# --- Configuração ---
# Substitua pela URL do seu blog. Certifique-se de que ele contém artigos!
TARGET_BLOG_URL = "https://www.example-blog.com/articles"
SEARCH_KEYWORD = "beginner" # A palavra-chave a ser pesquisada nos títulos dos artigos
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # SUBSTITUA ISTO! Ou use os.environ.get("OPENAI_API_KEY")
# Definir a chave API OpenAI
openai.api_key = OPENAI_API_KEY
# --- Funções de Auxílio ---
def fetch_webpage(url):
"""Recupera o conteúdo HTML de uma URL dada."""
try:
response = requests.get(url, timeout=10) # Adicionando um tempo limite
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
print(f"Erro ao recuperar a URL {url} : {e}")
return None
def find_article_links(html_content, base_url, keyword):
"""Analisa o HTML para encontrar os títulos e URLs de artigos correspondentes 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 os contêineres de artigos, títulos e links.
article_containers = soup.find_all('div', class_='article-card') # Comum para cartões/visões de artigos
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 as tags de contêiner de artigo comuns. Tentando uma busca mais ampla.")
# Retorno: apenas veja 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 # Retorne cedo se apenas links amplos foram encontrados
for container in article_containers:
# Procure o título e o link em cada contêiner
title_tag = container.find(['h2', 'h3', 'a']) # Os títulos estão frequentemente 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']
# Construindo 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 a 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 modelo 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:
# Retorno: obtenha 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 o texto fornecido."""
if not text or len(text.strip()) < 50: # Comprimento mínimo do texto para tentar um resumo
return "Conteúdo insuficiente para o resumo."
# Truncamento simples para manter-se dentro dos limites típicos da janela de contexto
# Considere usar um verdadeiro contador de tokens 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 desejar melhor qualidade
messages=[
{"role": "system", "content": "Você é um assistente útil que resume artigos de blog de maneira concisa e clara."},
{"role": "user", "content": f"Por favor, forneça um resumo conciso do seguinte artigo de blog, destacando os pontos principais:\n\n{text}"}
],
temperature=0.6, # Um pouco menos aleatório para os resumos
max_tokens=600 # Max tokens para o resumo gerado
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Erro da API OpenAI : {e}")
return f"Falha devido a um erro da 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 o agente de navegação para {TARGET_BLOG_URL} para encontrar artigos sobre '{SEARCH_KEYWORD}'...")
# Etapa 1 : Recuperar a página principal do blog
blog_html = fetch_webpage(TARGET_BLOG_URL)
if not blog_html:
print("O agente não conseguiu recuperar 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}. O agente terminou.")
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 tratar 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 o conteúdo do artigo alvo
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"O agente não conseguiu extrair o conteúdo de {target_article['url']}. Impossí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 ao LLM 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 Completa ---")
if __name__ == "__main__":
run_browser_agent()
Pontos Chaves Acionáveis para Seu Próprio Percurso de Agente
Este pequeno projeto é apenas a ponta do iceberg, mas ele mostra os mecanismos básicos. Aqui está o que aprendi e o que você deve ter em mente:
- Comece Pequeno, Pense Específico: Não tente construir o Skynet no primeiro dia. Escolha uma tarefa muito estreita e realizável para seu agente. “Encontrar uma receita de lasanha vegetariana” é melhor do que “cozinhe o jantar para mim”.
- A Extração de Dados é o Velho Oeste: Cada site web é diferente. Você PASSARÁ tempo inspecionando os elementos em seu navegador para obter os seletores CSS ou XPath corretos. Este é o trabalho básico, mas é essencial. Os sites mudam, então seu agente pode precisar de ajustes ocasionais.
- O Tratamento de Erros é seu Amigo: Coisas irão dar errado. Os sites estarão fora do ar, sua internet irá cair, as chamadas da API falharão. Adicione
try-exceptpara lidar graciosamente com esses problemas. - Os LLMs são Inteligentes, mas Precisam de Direção: A qualidade da saída do seu LLM depende fortemente de seu prompt. Seja claro, conciso, e dite exatamente o que você espera. Além disso, esteja ciente das limitações da janela de contexto e dos custos.
- Esta é uma Fundação: Nós construímos um agente em uma única fase. Os verdadeiros agentes muitas vezes envolvem várias etapas, lógica condicional (por exemplo, “se eu encontrar isso, então faça aquilo”) e memória. Mas você agora tem os blocos de construção.
Espero que ao ver este agente simples ganhar vida, o conceito inteiro de “agente IA” se torne um pouco menos misterioso. Não é magia; é apenas uma automação inteligente construída com ferramentas existentes. Vá em frente, experimente e construa seus próprios pequenos assistentes digitais!
Bom código,
Emma Walsh, agent101.net
Artigos Relacionados
- Como os Agentes IA dominam várias Línguas suavemente
- Eu fiz meu Agente IA útil (aqui está como)
- Eu construí um Agente IA em 2026: Minha opinião honesta
🕒 Published: