# yupi-hot-monitor: an AI pipeline that watches eight sources for you

> This project is a teaching codebase for an AI hot-topic monitor: it crawls eight or more sources, uses an OpenRouter model to expand the query and judge relevance, pushes results over Socket.io and email, and packages the whole capability as an Agent Skills bundle. The interesting engineering is the analysis layer, not the crawler.

**liyupi/yupi-hot-monitor** — 2026 年编程导航 AI 编程实战新项目，基于 Node.js + Express + React + OpenRouter 的 AI 热点监控工具，支持多信息源聚合抓取（Twitter / Bing / HackerNews / B 站等 7+ 平台）、AI 查询扩展、AI 真假识别与相关性分析、WebSocket 实时推送、邮件通知、多维度筛选排序，并将热点监控能力封装为 Agent Skills 技能包。覆盖 Prisma + SQLite 数据库、Socket.io 实时通信、Axios + Cheerio 网页爬虫、OpenRouter 大模型接入、Aceternity UI 炫酷前端、node-cron 定时任务、VSCode Copilot Vibe Coding + MCP

- Repository: https://github.com/liyupi/yupi-hot-monitor
- Website: https://www.codefather.cn/course/2026625439052627970
- Stars: 724 · Forks: 136
- Language: TypeScript
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/liyupi-yupi-hot-monitor

## A course project with a real pipeline behind it

This repository is the AI hot-topic monitor from a 2026 programming-navigation course on AI programming practice, and the README is written as course notes rather than as product documentation. The author explains the motivation in the first person: as an AI blogger, they wanted a tool that discovers the latest hot topics, such as large model releases, automatically and notifies them quickly, and rather than keeping that for themselves they built a more general tool.

The stack is stated in the repository description and it is specific. Node.js and Express on the back end, React on the front end, OpenRouter for the model calls, Prisma with SQLite for storage, Socket.io for the real time channel, Axios with Cheerio for the crawling, node-cron for scheduling, and Aceternity UI for the interface. The README itself names Express 5 and React 19.

There is a local setup guide in the docs directory that the README calls a detailed step by step guide, and the top level of the tree is a server directory, a client directory, a docs directory and a skills directory. The skills directory is the part that makes it more than an application, and it is covered below.

What you are reading is a codebase built to be studied, with the surrounding course offering a video walkthrough, written lessons, resume guidance, interview question explanations and support. The primary language is TypeScript, the default branch is master, and the last push was on 2026-04-16 with no GitHub releases. The licence is not identified in the project files, which matters if you plan to reuse the code rather than learn from it.

## What the six capabilities actually are

The feature list is organised as six capabilities, and the second one is the heart of the project.

First, you configure monitoring keywords and can activate or pause them. Second, AI automatically crawls and analyses hot topics from eight or more data sources, using AI for query expansion, truth and falsity identification, relevance analysis and intelligent summarising. Third, multi-dimensional filtering and sorting, by source, by importance and by time range, and sorting by heat, relevance or time. Fourth, a whole-network search that aggregates across multiple sources. Fifth, real-time notification through WebSocket push and email. Sixth, the Agent Skills bundle, so the capability can be used directly inside Cursor, VSCode Copilot and Claude Code.

The sources named in the README are Twitter, Bing, HackerNews, Sogou and Bilibili, with the count given as eight or more across the description and the feature list.

The order of the pipeline follows from the capability list. You give it a keyword, it expands the query so it catches different phrasings of the same topic, it crawls, it decides which results are relevant and which claims are dubious, it summarises, it ranks, and then it pushes.

The relevance and truth analysis is the part that distinguishes this from a feed reader, and it is the part that needs a model, which is why the OpenRouter key is a hard requirement rather than an optional extra.

## Why the model sits in the middle of the crawler

The course write-up is unusually explicit about which techniques the project teaches, and the list is a good map of the design.

There is how to install and use MCP to extend AI capabilities, and how to install and use Agent Skills to improve the quality of AI programming. There is how to aggregate and crawl content from multiple information sources, Twitter, Bing, HackerNews and Bilibili among them. There is how to connect to AI models through OpenRouter and implement intelligent content moderation. And there is how to implement query expansion to improve the recall rate of information retrieval.

Query expansion is the one to understand first, because it sits before the crawl rather than after it. A keyword like a model release name will be phrased differently across a dozen sources, and a search that only matches the exact string misses most of them. Expanding the query before searching is what makes the recall rate acceptable, and it is why the model runs before the crawler rather than only after it.

The content moderation through OpenRouter is the other interesting one. The README describes the capability as truth and falsity identification, which in a tool that aggregates social posts and search results means classifying a claim as reliable or not. That is a judgement call made by a model reading a snippet of text, and it is worth being clear-eyed about what that is: a probability, not a verification.

The stack makes the rest of the shape predictable. Socket.io for real-time push, so a new hot topic appears in the browser as it is found rather than on the next poll. node-cron for the scheduled crawl. Prisma with SQLite so the configuration and the results survive a restart, which matters because a monitoring tool that forgets its keywords on every deploy is not a monitoring tool.

## Running it locally, in two terminals

The prerequisites are Node.js 18 or newer with 20 LTS recommended, and an OpenRouter API key, which the README marks as required for the AI analysis.

The clone and install sequence splits into a back end and a front end:

```bash
git clone https://github.com/liyupi/yupi-hot-monitor.git
cd yupi-hot-monitor
cd server
npm install
npx prisma generate
npx prisma db push
cd ../client
npm install
```

The two Prisma commands are the ones worth understanding. generate produces the client from the schema, and db push applies that schema to the database, which in this project is SQLite, so the two commands together create an empty database with the right tables on a fresh checkout.

The environment file is copied from the example and then edited:

```bash
cp server/.env.example server/.env
```

The required value is the OpenRouter key, and the Twitter API key is optional. The README notes that the key is used for the AI analysis, which is the step that turns a list of posts into a ranked, scored feed.

Then the two services run in separate terminals, with the back end on port 3001 and the front end on port 5173:

```bash
cd server && npm run dev
cd client && npm run dev
```

You then open the front end address, enter a keyword, and monitoring starts. The service table also lists a database management entry, which is the Prisma studio command run from the server directory, marked optional.

## The Agent Skills bundle, and what it is for

The sixth capability is the one that reaches outside the application, and it is the most distinctive thing in the repository.

The hot-topic monitoring capability is packaged as an Agent Skills bundle, and once installed it can be used directly inside Cursor, VSCode Copilot and Claude Code. The README makes the claim twice, in the project description and again in the capability list, and the skills/ directory at the top of the tree is where the bundle lives.

The idea is a specific one. Instead of the monitoring running only inside the web application, the same capability becomes something an editor-side assistant can call, so an agent working in your editor can ask for the current hot topics on a subject, or start a monitoring session, without the user leaving the editor.

That is a different shape of reuse from a library. A library is something your code imports, and an Agent Skills bundle is a description of a capability that a model in an editor can decide to use, packaged so it works across several tools with the same content. The skills directory being a top level entry alongside server and client, rather than inside the server, reflects that separation.

The course description is explicit that developing a standardised Agent Skills package and validating it across multiple AI tools is one of the things the project teaches, alongside the MCP setup, so the skill packaging is treated as a first-class engineering task here rather than an afterthought.

## Where this project is the wrong choice

The first wrong case is a production monitoring system. This is a course project, and while the stack is a real one, the operational surface is thin. There is no authentication described, no rate limiting, no multi-tenant model, and the crawlers depend on the structure of third party sites staying the same, which is the fragility that kills home-built scrapers.

The second is a team that needs the data rather than the tutorial. The repository is one implementation with a course wrapped around it, and the value of the course is the walkthrough, the written lessons and the interview question explanations. If you want a working tool, a general feed reader plus an LLM summarisation step over your own feeds is less work and more maintainable.

The third is legal exposure. The project crawls Twitter, Bing, HackerNews, Sogou and Bilibili. Scraping those sites runs into their terms of service, and the fact that a source is reachable does not make scraping it permitted. A monitoring tool for your own research is a different proposition from one you offer to other people.

The fourth is anyone who needs the licence to be clear. The project files do not identify one, and a repository that is a course project with a commercial course attached is not the place to take a dependency on for production code.

The alternative worth weighing is a hosted news and research tool with the same shape, which handles the crawling, the summarisation and the delivery without you operating any of it, and the trade is that you are reading a curated set of sources rather than searching eight of them yourself.

## Conclusion

Adopt this project as a reference implementation if you are building a source aggregator with an AI analysis layer, since the query expansion, the relevance and truth checks and the multi-dimensional filtering are the parts worth copying, and the Agent Skills bundle shows how to expose the same capability to an editor. Keep away if you want a finished monitoring product, because this is a course project with a Chinese-language course around it and a licence that is not identified. Before you run it, get an OpenRouter key, because the analysis step depends on it, and note the last push was on 2026-04-16 with no GitHub releases to pin.

## FAQ

### What does the yupi-hot-monitor project do?

It aggregates content from eight or more sources including Twitter, Bing, HackerNews, Sogou and Bilibili for a set of monitored keywords, then uses AI for query expansion, truth and falsity identification, relevance analysis and summarising. Results can be filtered by source, importance and time range, sorted by heat, relevance or time, and pushed over WebSocket or sent by email.

### How do I run the yupi-hot-monitor project locally?

You need Node.js 18 or newer, with 20 LTS recommended, and an OpenRouter API key for the AI analysis. Clone the repository, install dependencies and run npx prisma generate and npx prisma db push in the server directory, then install the client dependencies, copy server/.env.example to server/.env and fill in the key, and start the server on port 3001 and the client on port 5173 in two terminals.

### Why does the yupi-hot-monitor project need an OpenRouter API key?

Because the analysis step depends on a model. The OpenRouter connection is used for the content moderation, the relevance analysis, the intelligent summarising and the query expansion that widens the search before the crawlers run. Without a key the pipeline can crawl but cannot rank or judge the results.

### What does the Agent Skills bundle in yupi-hot-monitor do?

It packages the hot-topic monitoring capability so it can be used directly inside Cursor, VSCode Copilot and Claude Code, rather than only through the web application. The skills directory sits at the top level beside the server and client, and developing and validating that package across tools is one of the techniques the course teaches.

## Sources

- [Issues](https://github.com/liyupi/yupi-hot-monitor/issues)
- [liyupi/yupi-hot-monitor on GitHub](https://github.com/liyupi/yupi-hot-monitor)
- [Project website](https://www.codefather.cn/course/2026625439052627970)
- [README](https://github.com/liyupi/yupi-hot-monitor/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/liyupi-yupi-hot-monitor