A Free RSS Triage Bot: Let a Free Model Decide What Deserves Your Attention

Your RSS reader probably has a queue that never reaches zero. Mine crossed 2,300 items last week, and the only honest response was to pretend the folder did not exist. The usual fix is a paid summarization API, but for a solo developer there is another path: run a triage bot on MonkeyCode's free model access and its free server option. That combination is enough to turn an overwhelming feed into a five-line daily digest without entering a credit card.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

The numbers and product terms I mention reflect what the MonkeyCode team told me in August 2026. The project is open source and moving quickly, so check the current README before you rely on the free tier for anything permanent.

Why triage beats summarization

Asking a free model to write a long summary for every article burns tokens fast and produces reading material you still have to skim. Scoring is a cheaper task because the output is a tiny integer per article, not paragraphs. Your own judgment still matters, and a score between zero and five is enough to separate signal from noise.

The real insight is that relevance filtering does not need a frontier model. A small instruction prompt with twenty titles and short excerpts is usually sufficient. Free models can handle that workload comfortably, and the latency is irrelevant when the job runs at 6 a.m. while you sleep.

The triage pipeline

I built a four-step pipeline that runs entirely on the free server. Each step has a single output, so failures stay visible and easy to debug.

1. Fetch the feed and take the latest twenty entries.
2. Normalize each entry into a title and a 300-character excerpt.
3. Send the batch to the free model and ask for JSON scores only.
4. Sort by score and print the top three items into a digest file.

The clever part is the strict output contract. If the model returns anything except valid JSON, the script fails loudly instead of silently generating a useless paragraph.

A minimal working script

The following code assumes an OpenAI-compatible chat endpoint, which is what the current MonkeyCode docs describe for local and free-server deployments. If the exact URL changes in your build, adjust one environment variable and leave the triage logic alone.

#!/usr/bin/env python3
import os
import json
import feedparser
import requests


def fetch_feed(feed_url, limit=20):
    parsed = feedparser.parse(feed_url)
    return [
        {"title": e.get("title", ""),
         "summary": e.get("summary", "")[:300]}
        for e in parsed.entries[:limit]
    ]


def score_items(items, endpoint):
    prompt = (
        "You are a news triage assistant for an indie developer. "
        "Score each item from 0 to 5, where 5 is essential. "
        "Return only JSON: {\"scores\": [0, 3, 5, ...]}\n"
        "Items:\n" + json.dumps(items)
    )
    payload = {
        "messages": [{"role": "user", "content": prompt}]
    }
    response = requests.post(endpoint, json=payload, timeout=180)
    response.raise_for_status()
    content = response.json()["choices"][0]["message"]["content"]
    return json.loads(content)["scores"]


def main(feed_url, endpoint):
    items = fetch_feed(feed_url)
    scores = score_items(items, endpoint)
    ranked = sorted(zip(items, scores), key=lambda pair: pair[1], reverse=True)
    for item, score in ranked[:3]:
        print(f"[{score}/5] {item['title']}")


if __name__ == "__main__":
    main(os.environ["FEED_URL"], os.environ["MONKEY_BASE_URL"])

Create a virtual environment and install the two dependencies first:

python -m venv .venv
. .venv/bin/activate
pip install feedparser requests

Then provide the feed URL and the endpoint from your server setup:

export FEED_URL="https://hnrss.org/frontpage"
export MONKEY_BASE_URL="http://localhost:8000/v1/chat/completions"
python triage.py

If the free server is remote, replace localhost with the address you get when provisioning the free server option. The same script runs locally for testing, which is a good way to verify your prompt before scheduling anything.

Scheduling on the free server

Once the script produces the digest you want, add a cron entry on the free server instance. The job should run once a day and write into a file you actually open.

30 6 * * * cd ~/rss-bot && . .venv/bin/activate && python triage.py >> digest.txt

You can even pipe the output to a free notification service, but a file is enough for a personal experiment. The goal is to make reading decisions before you start your morning coffee, not to build a notification platform.

When the free tier is the right fit

The decision table below comes from running this pattern for a few weeks. It is not a benchmark, just a tool for choosing when free models and the free server make sense.

Job pattern	Token load per run	Server strain	Verdict on free tier
Daily RSS triage (20 items)	Low	Very low	Fits easily
Weekly report generation	Medium	Low	Fits with a token check
Real-time user-facing API	Unpredictable	High	Not a fit
Long multi-turn agent loop	Very high	Medium	Avoid

The pattern that works is a batch job with a fixed input size and a clear output shape. Once the job crosses into real-time territory or unbounded loops, the free tier starts to bend under the load.

Limitations and who should skip this

The free model access is not an SLA-backed production service. Do not use it for regulated data, anything patient-related, or a workflow where a silent failure costs real money. The free server also has no autoscaling, so a public endpoint hammered by traffic is a bad idea.

This approach also assumes you can read the source and audit what runs on your machine. MonkeyCode is open source, which is a feature if you want transparency and a risk if you do not have time to review upstream changes. If you need a guaranteed response time and humans to call, buy a commercial plan instead.

A gentle starting point

The fastest way to test this workflow is to point the script at one low-volume feed and run it manually for a day. When you trust the scores, add the cron job and let the free server earn its keep.

Give MonkeyCode a try with a throwaway account and a single feed. The README will tell you whether the free model and free server terms match what I described, and your unread count will thank you.