Eu criei um agente de IA para resumir minhas notícias.

Olá, agente em treinamento! Emma aqui, de volta no agent101.net. Hoje, quero falar sobre algo que tem sido discutido em meus canais Slack e meus projetos pessoais há alguns meses: fazer com que um agente de IA realmente faça algo útil para você, de maneira consistente, sem precisar de um doutorado em engenharia de prompts ou de uma fazenda de servidores no seu armário. Mais especificamente, vamos explorar como criar um agente de IA super simples, com uma única tarefa, que busca e resume notícias específicas para você – um pequeno cão de caça às novidades, se preferir.

Eu sei, eu sei. “Agente de IA” ainda soa como algo saído de um filme de ficção científica, não é? Ou talvez você já tenha tentado o ChatGPT e se perguntado: “Certo, mas como fazer essa coisa funcionar sozinha sem eu ter que digitar cada comando?” É exatamente essa lacuna que vamos preencher hoje. Meu objetivo para este artigo é desmistificar o processo e mostrar que construir um pequeno agente de IA focado não é tão assustador quanto parece. Pense nisso como ensinar seu assistente digital um truque muito específico e repetível.

Minha própria jornada no mundo dos agentes começou, francamente, por pura frustração. Eu passava tempo demais filtrando notícias de tecnologia, tentando encontrar menções de atualizações de modelos de IA específicos ou novos frameworks de agentes. Eu tinha configurado alertas do Google, mas muitas vezes eram muito amplos ou lentos. Eu queria algo que entendesse o contexto, pudesse filtrar o ruído e me desse um resumo conciso. Então, como todo bom programador preguiçoso (do que tenho orgulho de ser!), pensei: “Deve haver um jeito de automatizar isso com IA.”

E havia! Após algumas falsas partidas, alguns momentos refletindo sobre as chaves de API, e uma boa quantidade de tentativas e erros com diferentes modelos de linguagem de grande porte (LLMs), encontrei um esquema que funciona. Não é um sistema multi-agentes coordenando tarefas complexas, nem vai escrever seu próximo romance. Mas é uma entrada perfeita para entender como esses elementos se juntam para criar algo realmente útil.

Por que um agente “Cão de Caça às Notícias”?

Quando você está começando, escolher um projeto muito ambicioso é uma maneira certa de se desmotivar. É por isso que eu recomendo começar com um agente de tarefa única. Nosso agente “Cão de Caça às Notícias” é perfeito por várias razões:

• Objetivo claro: Encontrar notícias específicas, resumi-las. Simples.
• Resultado tangível: Você obtém um resumo que pode realmente ler.
• Baseado em dados externos: Isso ensina como os agentes interagem com o mundo exterior (recuperação de informações).
• Utiliza LLMs para interpretação: O coração da maioria dos agentes é um LLM que entende e gera texto.
• Repetível: Uma vez construído, você pode executá-lo diariamente, semanalmente ou quando quiser.

Imagine-se acordando e seu agente já preparou um breve resumo de todos os últimos avanços em “ética de IA em grandes modelos de linguagem” ou “novos desenvolvimentos em sensores de condução autônoma.” Chega de rolar indefinidamente por blogs de tecnologia genéricos. Esse é o sonho, e é totalmente viável.

A anatomia do nosso agente Cão de Caça às Notícias

Cada agente de IA, não importa quão simples, geralmente tem alguns componentes principais. Para nosso Cão de Caça às Notícias, aqui está o que precisaremos:

1. O “Cérebro” (LLM): Este é o nosso modelo de linguagem de grande porte. Ele entenderá o que estamos buscando e resumirá as informações. Eu usarei os modelos da OpenAI para este exemplo, pois são amplamente acessíveis e têm uma boa documentação, mas você pode optar pelo Claude da Anthropic ou até mesmo um modelo open-source local se se sentir aventureiro.
2. Os “Olhos” (Recuperador de informações): Nosso agente precisa de um meio para obter informações na Internet. Para notícias, um leitor de feeds RSS ou uma simples biblioteca de web scraping serve. Vamos manter isso simples com uma API de notícias para consistência.
3. As “Instruções” (Prompt): É assim que dizemos ao LLM o que fazer. Isso é crucial para obter bons resultados.
4. O “Orquestrador” (Script Python): Um simples script para conectar tudo, indicando ao agente quando buscar, quando e onde exibir os resultados.

Não se preocupe se esses termos parecerem um pouco confusos por agora. Vamos detalhar cada elemento.

O que você precisará antes de começar

• Python: Certifique-se de ter o Python 3.8+ instalado.
• Uma chave API da OpenAI: Você pode obter uma na plataforma OpenAI. Há um nível gratuito para testes iniciais, mas provavelmente você terá que adicionar uma forma de pagamento para uso contínuo. Mantenha essa chave em segredo!
• Uma chave API de notícias (opcional, mas recomendado): Serviços como NewsAPI.org ou GNews API oferecem níveis gratuitos perfeitos para isso. Isso torna a recuperação de dados de notícias estruturadas muito mais fácil do que fazer um web scraping bruto. Para este tutorial, vou assumir que você possui uma chave NewsAPI.org.
• Um editor de texto básico: VS Code, Sublime Text ou até mesmo o Notepad funcionam.

Etapa 1: Configurando seu ambiente

Primeiro, vamos criar um novo diretório para nosso projeto e instalar as bibliotecas necessárias. Abra seu terminal ou prompt de comando:

mkdir news_hound_agent
cd news_hound_agent
python -m venv venv
source venv/bin/activate # No Windows: venv\Scripts\activate
pip install openai requests python-dotenv

Estamos instalando:

• openai: Para interagir com os modelos da OpenAI.
• requests: Para fazer requisições HTTP à API de notícias.
• python-dotenv: Para armazenar nossas chaves API com segurança.

Em seguida, crie um arquivo chamado .env no seu diretório news_hound_agent e adicione suas chaves API:

OPENAI_API_KEY="sua_chave_api_openai_aqui"
NEWS_API_KEY="sua_chave_api_newsapi_aqui"

Substitua os espaços reservados pelas suas chaves reais. Certifique-se de adicionar .env ao seu arquivo .gitignore se você alguma vez for colocar esse projeto em um repositório Git!

Etapa 2: Construindo o Recuperador de Informações (Os “Olhos”)

Vamos criar um arquivo Python chamado news_fetcher.py. Este módulo será responsável por recuperar os artigos de notícias.

# news_fetcher.py
import requests
import os
from dotenv import load_dotenv

load_dotenv() # Carregar as variáveis de ambiente do arquivo .env

NEWS_API_KEY = os.getenv("NEWS_API_KEY")
NEWS_API_URL = "https://newsapi.org/v2/everything"

def fetch_news(query, language='en', sort_by='relevancy', page_size=10):
 """
 Recupera artigos de notícias da NewsAPI.org com base em uma consulta.
 """
 if not NEWS_API_KEY:
 print("Erro: Chave NEWS_API_KEY não encontrada no arquivo .env.")
 return []

 params = {
 'q': query,
 'language': language,
 'sortBy': sort_by,
 'pageSize': page_size,
 'apiKey': NEWS_API_KEY
 }

 try:
 response = requests.get(NEWS_API_URL, params=params)
 response.raise_for_status() # Levanta uma exceção para erros HTTP (4xx ou 5xx)
 data = response.json()
 articles = data.get('articles', [])
 return articles
 except requests.exceptions.RequestException as e:
 print(f"Erro ao recuperar notícias: {e}")
 return []

if __name__ == "__main__":
 # Exemplo de uso ao executar este script diretamente
 search_term = "Agentes de IA para produtividade pessoal"
 articles = fetch_news(search_term, page_size=5)
 if articles:
 print(f"Encontrados {len(articles)} artigos para '{search_term}':")
 for i, article in enumerate(articles):
 print(f"{i+1}. {article.get('title', 'Sem título')} - {article.get('url', 'Sem URL')}")
 else:
 print(f"Nenhum artigo encontrado para '{search_term}'.")

Este script define uma função fetch_news que pega uma consulta (por exemplo, “ética da IA”) e retorna uma lista de dicionários de artigos. Cada dicionário contém informações como título, descrição e URL. O bloco if __name__ == "__main__": é apenas para testar este módulo de forma isolada.

Etapa 3: Elaborando o Prompt (As “Instruções”)

É aqui que a mágica do LLM entra em ação. Quanto melhor for seu prompt, melhor será seu resumo. Vamos criar um arquivo chamado summarizer.py.

# summarizer.py
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def summarize_articles(articles, specific_focus="general overview"):
 """
 Resume uma lista de artigos de notícias usando um LLM da OpenAI.
 O parâmetro specific_focus ajuda a guiar o resumo.
 """
 if not articles:
 return "Nenhum artigo fornecido."

 # Preparar os artigos para o LLM
 article_texts = []
 for i, article in enumerate(articles):
 title = article.get('title', 'Sem título')
 description = article.get('description', 'Sem descrição')
 url = article.get('url', 'Sem URL')
 article_texts.append(f"Artigo {i+1}:\nTítulo: {title}\nDescrição: {description}\nURL: {url}\n---")

 combined_text = "\n\n".join(article_texts)

 # O convite para nosso LLM
 prompt = f"""
 Você é um analista de notícias expert. Sua tarefa é revisar os seguintes artigos de notícias e fornecer um resumo conciso.
 O resumo deve se concentrar especificamente em "{specific_focus}".
 Extraia os desenvolvimentos chave, as tendências e os anúncios importantes relacionados a esse foco.
 Mantenha o resumo em até 300 palavras, usando uma linguagem clara e profissional.
 Se um artigo não for relevante para o foco específico, você pode mencionar brevemente o porquê ou omiti-lo.

 Artigos de notícias:
 {combined_text}

 Resumo focando em "{specific_focus}":
 """

 try:
 response = client.chat.completions.create(
 model="gpt-3.5-turbo", # Você pode usar "gpt-4" para uma qualidade melhor, mas é mais caro
 messages=[
 {"role": "system", "content": "Você é um resumidor de notícias útil e conciso."},
 {"role": "user", "content": prompt}
 ],
 max_tokens=500, # Ajuste se necessário
 temperature=0.7 # Um pouco criativo, mas ainda assim factual
 )
 summary = response.choices[0].message.content.strip()
 return summary
 except Exception as e:
 print(f"Erro ao resumir os artigos: {e}")
 return "Não foi possível gerar o resumo devido a um erro."

if __name__ == "__main__":
 # Artigos fictícios de exemplo para os testes
 dummy_articles = [
 {"title": "A IA na saúde recebe novo financiamento", "description": "Os investimentos aumentam em startups que utilizam IA para diagnóstico.", "url": "http://example.com/ai-health"},
 {"title": "Novo modelo de carro elétrico lançado", "description": "A marca de luxo EV revela seu último veículo com autonomia aprimorada.", "url": "http://example.com/ev-car"},
 {"title": "Diretrizes éticas sobre IA propostas pela UE", "description": "A União Europeia está redigindo regras rígidas para o desenvolvimento responsável de IA.", "url": "http://example.com/eu-ai"},
 ]
 focus = "ética e regulação da IA"
 summary_result = summarize_articles(dummy_articles, focus)
 print(f"\n--- Resumo para '{focus}' ---\n{summary_result}")

Neste script:

• Nós carregamos a chave API da OpenAI.
• summarize_articles recebe uma lista de artigos e uma string specific_focus. Esse specific_focus é fundamental! Ele indica ao LLM qual ângulo usar ao resumir, evitando assim saídas genéricas.
• O convite é cuidadosamente construído para dar ao LLM um papel (“analista de notícias expert”), instruções claras (resumo conciso, foco específico, limite de palavras) e o conteúdo a ser processado.
• Nós usamos gpt-3.5-turbo porque é um bom equilíbrio entre custo e desempenho para essa tarefa. Sinta-se à vontade para experimentar com gpt-4 se você quiser resumos mais nuançados.

Etapa 4: O Organizador (Conectando Tudo)

Finalmente, vamos criar nosso script de agente principal, main_agent.py, que chamará nosso fetcher e nosso resumidor.

# main_agent.py
from news_fetcher import fetch_news
from summarizer import summarize_articles
import datetime

def run_news_hound_agent(search_query, summary_focus):
 """
 Orquestra o processo de busca e resumo de notícias.
 """
 print(f"[{datetime.datetime.now()}] Iniciando o agente News Hound...")
 print(f"Buscando: '{search_query}' com foco em '{summary_focus}'")

 # Etapa 1: Recuperar os artigos de notícias
 print("Recuperando os artigos de notícias...")
 articles = fetch_news(search_query, page_size=10) # Recuperar 10 artigos

 if not articles:
 print("Nenhum artigo encontrado ou ocorreu um erro ao recuperar. Saindo.")
 return

 print(f"Encontrados {len(articles)} artigos relevantes.")

 # Etapa 2: Resumir os artigos
 print("Resumindo os artigos com o LLM...")
 summary = summarize_articles(articles, summary_focus)

 # Etapa 3: Exibir os resultados
 print("\n--- Digest Diário de Notícias ---")
 print(f"Data: {datetime.date.today()}")
 print(f"Busca: {search_query}")
 print(f"Foco: {summary_focus}")
 print("\nResumo:")
 print(summary)
 print("\n--- Fim do Digest ---")

 # Opcional: Salvar em um arquivo
 output_filename = f"digest_noticias_{datetime.date.today().isoformat()}.txt"
 with open(output_filename, "w", encoding="utf-8") as f:
 f.write(f"Digest Diário de Notícias para {datetime.date.today()}\n")
 f.write(f"Busca: {search_query}\n")
 f.write(f"Foco: {summary_focus}\n\n")
 f.write("Resumo:\n")
 f.write(summary)
 f.write("\n\nTítulos dos artigos originais (para referência):\n")
 for article in articles:
 f.write(f"- {article.get('title', 'Sem título')}\n")
 print(f"\nDigest salvo como {output_filename}")


if __name__ == "__main__":
 # Definir o que seu agente deve buscar e em que se concentrar
 my_search_query = "frameworks de agentes IA OU orquestração LLM"
 my_summary_focus = "novas ferramentas e métodos para construir agentes IA"

 run_news_hound_agent(my_search_query, my_summary_focus)

Esse script orquestra todo o processo:

• Ele define uma função run_news_hound_agent que recebe uma search_query (o que deve ser buscado nos títulos e descrições das notícias) e um summary_focus (o que o LLM deve destacar especificamente).
• Ele chama fetch_news para obter os artigos brutos.
• Ele passa esses artigos e o foco para summarize_articles.
• Por fim, ele imprime o resumo no console e o salva em um arquivo texto para facilitar a leitura posterior.

Executando seu agente News Hound!

Agora, abra seu terminal, certifique-se de que seu ambiente virtual está ativo e execute:

python main_agent.py

Você deverá ver uma saída indicando que o agente está recuperando as notícias, depois resumindo, e, finalmente, seu digest de notícias personalizado impresso no console e salvo em um arquivo! A primeira execução pode levar alguns segundos, pois o LLM processa o pedido.

O que eu gosto nisso é a rapidez da devolução da informação. Você insere uma consulta, especifica um foco, e bum – você obtém um resumo personalizado. Chega de títulos genéricos. Para mim, esse foi um enorme momento “eureka”. Não era apenas conversar com uma IA; era fazer com que uma IA realizasse uma tarefa específica e valiosa em meu nome.

Personalizar e Ampliar Seu Agente

Isso é apenas o começo! Aqui estão algumas ideias para melhorar ainda mais seu News Hound:

• Múltiplas Consultas/Focos: Modifique main_agent.py para executar várias consultas ou diferentes focos e gerar vários digests.
• Agendamento: Use ferramentas como cron (Linux/macOS) ou o Agendador de Tarefas do Windows para executar main_agent.py automaticamente toda manhã.
• Diferentes LLMs: Experimente com outros LLMs. Talvez Claude 3 Opus da Anthropic para contextos mais longos ou Llama 3 para processamento local.
• Formatos de Saída: Em vez de um arquivo texto, salve a saída em formato HTML, arquivo Markdown, ou até envie por e-mail ou em um canal Slack (nesse caso, você precisaria se integrar a essas APIs).
• Filtragem Contextual: Antes de resumir, você poderia adicionar uma etapa intermediária onde o LLM (ou um classificador de texto mais simples) determina se cada artigo recuperado é realmente relevante para seu foco específico, filtrando ainda mais o ruído.
• Fontes de Notícias Avançadas: Explore outras APIs de notícias ou até mesmo o web scraping de sites específicos (embora você deva ter cuidado com os termos de uso!).

Meu próprio News Hound evoluiu a partir dessa configuração básica. Eu o programei para funcionar toda noite, escaneando atualizações sobre frameworks de agentes específicos que estou monitorando, e ele me envia um resumo todas as manhãs. Isso me fez ganhar horas classificando feeds RSS e Twitter. Ele realmente se tornou meu assistente de pesquisa digital.

Pontos a Lembrar

Então, o que você precisa levar em conta de tudo isso?

1. Comece pequeno, pense grande: Não tente construir a próxima AGI na sua primeira tentativa. Um agente com um único objetivo é uma excelente ferramenta de aprendizado.
2. As mensagens são poderosas: A qualidade da sua saída está diretamente ligada à clareza e especificidade das suas mensagens. Reserve um tempo para aperfeiçoá-las.
3. APIs são suas amigas: Os LLMs são poderosos, mas precisam de dados. Aprender a interagir com APIs externas (como a NewsAPI) é fundamental.
4. O código é o elo: Python (ou qualquer linguagem de script) é o que transforma uma coleção de componentes poderosos em um agente funcional.
5. Iterar e experimentar: Não tenha medo de trocar de modelos, modificar mensagens ou tentar diferentes fontes de dados. É assim que você aprende o que funciona melhor para suas necessidades específicas.

Construir este agente News Hound é uma maneira prática e concreta de entender os conceitos fundamentais por trás dos agentes de IA. Isso mostra como conectar um LLM a ferramentas externas e automatizar uma tarefa útil. Este conhecimento fundamental é sobre o que você vai construir ao explorar sistemas multiagentes mais complexos ou ao integrar agentes em aplicações maiores.

Vá em frente, experimente! Você pode se surpreender com a rapidez com que consegue montar seu próprio assistente digital. E como sempre, se você encontrar um problema ou descobrir uma nova maneira interessante de expandir isso, deixe um comentário abaixo ou me encontre nas redes sociais. Bom desenvolvimento de agentes!

Artigos Relacionados

• Aprenda IA: Seu caminho completo para iniciantes em IA 2026
• Agentes de IA para iniciantes: Seu guia amigável
• Tutoriais sobre agentes de IA com exemplos práticos

🕒 Published: April 1, 2026