# Como criei um varredura diária de papers de IA com Ollama + Telegram

> Source: <https://dev.to/lincoln_romais/-como-criei-um-varredura-diaria-de-papers-de-ia-com-ollama-telegram-gnl>
> Published: 2026-05-27 20:02:57+00:00

Se você acompanha pesquisa em IA, sabe que o [HuggingFace Papers](https://huggingface.co/papers) solta novos papers todo dia. O problema? São dezenas de abstracts em inglês, e ler tudo manualmente é inviável no dia a dia.

Resolvi automatizar isso: um script Python que busca os papers do dia, joga cada abstract pro meu LLM local via **Ollama**, traduz pra português e manda tudo pro **Telegram**. Sem pagar por API, sem nada na nuvem.

Neste artigo vou te mostrar como funciona e como você pode replicar em menos de 10 minutos.

O resultado no Telegram fica assim:

```
🤖 HuggingFace Papers — 27/05/2026
Top 8 papers do dia, traduzidos com llama3
──────────────────────────────

1. *Scaling Laws for Reward Model Overoptimization*
👥 Leo Gao, John Schulman, Jacob Hilton
💬 142 upvotes

📝 Investigamos como o desempenho de modelos de linguagem muda quando otimizamos 
excessivamente contra um modelo de recompensa (reward model). Descobrimos que o 
desempenho no proxy aumenta mas o desempenho verdadeiro diminui — um fenômeno 
conhecido como overoptimization. Nossos experimentos mostram leis de escala 
previsíveis para esse comportamento...

🔗 HuggingFace | arXiv
```

`llama3`

(ou qualquer modelo que você tiver)

```
hf-digest/
├── hf_digest.py      # script principal
├── config.py         # suas configurações
└── get_chat_id.py    # helper para descobrir o chat_id
```

`config.py`

Começa pela configuração. Tudo em um lugar só, fácil de ajustar:

```
TELEGRAM_BOT_TOKEN = "SEU_TOKEN_AQUI"
TELEGRAM_CHAT_ID   = "SEU_CHAT_ID_AQUI"
OLLAMA_URL         = "http://localhost:11434"
OLLAMA_MODEL       = "llama3"
MAX_PAPERS         = 8
```

A API do HuggingFace retorna os papers do dia em JSON. Simples assim:

``` php
def fetch_papers() -> list[dict]:
    today = datetime.now().strftime("%Y-%m-%d")
    url = f"https://huggingface.co/api/daily_papers?date={today}"

    headers = {"User-Agent": "Mozilla/5.0 (compatible; HFDigestBot/1.0)"}
    response = requests.get(url, headers=headers, timeout=20)
    response.raise_for_status()

    papers = response.json()
    return papers[:MAX_PAPERS]
```

Aqui mora a mágica. O Ollama expõe uma API REST local no `localhost:11434`

. A gente manda um prompt e ele retorna a resposta do modelo:

``` php
def translate_with_ollama(text: str) -> str:
    prompt = f"""Você é um assistente especializado em IA e ML. 
Traduza e resuma o seguinte abstract para o português brasileiro.
Mantenha termos técnicos em inglês entre parênteses quando necessário.
Responda APENAS com o resumo, sem frases introdutórias.

Abstract:
{text}"""

    payload = {
        "model": OLLAMA_MODEL,
        "prompt": prompt,
        "stream": False,
    }

    response = requests.post(
        f"{OLLAMA_URL}/api/generate",
        json=payload,
        timeout=120,
    )
    return response.json()["response"].strip()
```

O `stream: False`

faz o Ollama esperar processar tudo antes de responder — mais fácil de lidar do que streaming para esse caso de uso.

O bot do Telegram aceita Markdown, então dá pra formatar bem as mensagens:

``` php
def send_telegram(text: str) -> bool:
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    payload = {
        "chat_id": TELEGRAM_CHAT_ID,
        "text": text,
        "parse_mode": "Markdown",
        "disable_web_page_preview": True,
    }
    response = requests.post(url, json=payload, timeout=15)
    return response.ok
```

`main()`

``` python
def main():
    papers = fetch_papers()

    # Cabeçalho
    send_telegram(f"🤖 *HuggingFace Papers — {datetime.now().strftime('%d/%m/%Y')}*")

    for i, paper in enumerate(papers, start=1):
        abstract = paper["paper"].get("summary", "")

        translated = translate_with_ollama(abstract)
        message = format_paper(paper, i, translated)
        send_telegram(message)

    send_telegram(f"✅ {len(papers)} papers enviados!")
```

**1. Instale a dependência**

```
pip install requests
```

**2. Crie o bot no Telegram**

`/newbot`

, siga as instruções`config.py`

**3. Descubra seu Chat ID**

Envie qualquer mensagem pro seu novo bot e rode:

``` python
# get_chat_id.py
import requests
from config import TELEGRAM_BOT_TOKEN

r = requests.get(f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates")
updates = r.json()["result"]
chat_id = updates[-1]["message"]["chat"]["id"]
print(f"Seu chat_id: {chat_id}")
```

**4. Suba o Ollama e rode**

```
ollama serve
python3 hf_digest.py
```

Poderia ter usado a API da OpenAI ou do Gemini para traduzir. Mas há algumas vantagens em rodar local:

O `llama3`

faz um trabalho muito bom em traduções técnicas. Se quiser mais velocidade, o `phi4`

ou `gemma3`

também funcionam bem e são mais leves.

Para receber o digest todo dia de manhã sem precisar rodar manualmente, adicione ao crontab:

```
crontab -e
0 9 * * * cd /caminho/para/hf-digest && python3 hf_digest.py >> digest.log 2>&1
```

Algumas ideias para evoluir o projeto:

O projeto completo está disponível no GitHub: **[ https://github.com/lromais/ai_newsletters]**

Se você testar e fizer alguma melhoria, compartilha nos comentários! E se tiver dúvida em algum passo do setup, é só perguntar.

*Tags: python, ai, ollama, telegram, machinelearning*