Morning Digest AI: Let Your Group Chats Catch You Up 🌅🤖

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Ever wake up to hundreds of unread group chat messages and wonder if you missed anything important?

I’m building Morning Digest AI, a local-first AI agent that turns noisy group chat notifications into a concise, two-line morning summary.

Instead of scrolling through endless conversations, you can start your day knowing the most important announcements, deadlines, decisions, and pending tasks.

The goal is simple: spend less time catching up and more time getting things done.

The project is designed to process messages locally, keeping personal conversations off third-party AI inference APIs.

Demo

The project currently runs locally on my Windows PC.

The prototype uses a Python summarization pipeline connected to Ollama, with Qwen3 generating concise summaries. I’m working toward integrating automatic WhatsApp notification collection and Windows desktop notifications.

Code

GitHub Repository: Morning Digest AI

The project uses a simple, modular structure:

• app.py — FastAPI receiver for incoming chat notifications.
• digest.py — Processes stored messages, calls the local AI model, and generates a summary.
• SQLite — Stores incoming messages and tracks which messages have been summarized.
• Ollama — Runs the language model locally.

Replace the repository link above with your actual project repository before publishing.

How I Built It

I wanted to explore how far I could get with a small, locally running AI model instead of relying on a paid cloud API.

My current stack:

• Python — Core application logic and summarization pipeline.
• Qwen3:1.7B — Lightweight language model for generating concise summaries.
• Ollama — Local model inference through its HTTP API.
• FastAPI — Receives incoming messages from a future Android notification bridge.
• SQLite — Lightweight local storage for messages and processing status.
• Winotify — Windows desktop notifications.

The workflow is straightforward:

1. Collect incoming chat notifications.
2. Store messages locally with timestamps.
3. Send relevant messages to Qwen3 through Ollama.
4. Generate a concise digest highlighting important updates and follow-ups.
5. Display the summary as a desktop notification.

I'm starting small and building incrementally: first getting local inference working, then message storage, and finally automatic collection and scheduled delivery.

Why Does Open Innovation Matter?

Open innovation makes projects like this possible for individual developers without requiring expensive infrastructure or proprietary AI subscriptions.

Using an open-weight model through Ollama gives me control over the model runtime, inference workflow, and application architecture. I can experiment with prompts, adjust the model, and build around my own privacy requirements.

Local inference also means the summarization step does not need to send message contents to a third-party AI API.

For a personal productivity tool that handles private conversations, that control matters.

Open-source frameworks and accessible model runtimes make it possible to build useful AI applications on everyday hardware—not just expensive GPUs or cloud servers.

My Agent Session

I'm developing and testing the agent incrementally, validating local inference and the message-processing pipeline before completing the automatic notification bridge.

I'll add a DevRelay agent session here if I record one during development.

The Lazy Payoff

The idea is to eliminate the daily ritual of scrolling through every group chat just to find one important deadline or announcement.

Instead of manually catching up on dozens of messages, I want a quick morning digest that answers two questions:

• What happened?
• What do I need to do next?

The project is still a work in progress, but the goal is to make staying informed effortless while keeping the workflow lightweight and local.

Prize Categories

I'll select the applicable partner categories according to the challenge rules and the integrations included in the final submission.

---

Built with Python, Qwen3, Ollama, and a simple idea: let AI handle the scrolling so you don't have to. ☕