I Built a Local AI Agent That Reads My WhatsApp Groups Overnight So I Don’t Have To

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

What I Built

WhatsApp Digest — a fully local AI agent that reads your WhatsApp group chat exports overnight and hands you a clean 2-5 line summary every morning in a single markdown file.

Problem statement: Too many groups, too much noise, manually checking all of them is time-consuming & hectic and still important things gets missed.

WhatsApp Digest solves this completely. Set it up once. A CRON job runs it automatically every morning. One markdown file, every important announcement from every group, nothing missed.

No cloud. No subscription. No data leaving the machine. Ever.

Demo

The demo shows the complete flow: launching the interactive CLI, selecting the model, pointing it at a folder of exported chat files, watching it process each group, and opening the final digest markdown file with summaries of every group.

Code

aadityasingh9601 / Chat-summarizer

Local agent to summarize WhatsApp group chats & return a short summary.

WhatsApp Chat Summarizer

Introduction:
A simple tool to summarize your WhatsApp chats using local AI.

What it does (step by step):

1. Export - Get your chats as .txt or .zip (manually from WhatsApp, or optionally with get-whatsapp-chat.py).
2. Parse - Reads .txt or .zip WhatsApp exports.
3. Summarize - Uses a local Ollama model to create short summaries.
4. Digest - main.py builds a clean digest_YYYY-MM-DD.md file for you.

How it's different:

• Runs without internet - All AI runs on your machine.
• Private - Your messages & files stay on your host machine.
• Setup once - Do it once, use forever.
• Never pay for it - Free, uses your own computer.

⚠️ Optional: Automatic Export (Use at your own risk)
This feature uses browser automation on WhatsApp Web to export chats automatically.
This violates WhatsApp's Terms of Service and carries a small risk of account suspension.
Use a secondary number if you…

View on GitHub

How I Built It

The entire stack runs locally with zero internet dependency after setup.

Local inference: Ollama

Ollama handles model serving. It installs in one click, runs as a background service, and exposes a local REST API at localhost:11434. No configuration needed. My Python script talks to it through the ollama Python library — one function call to get a summary back.

Models: Gemma 4 E4B and Qwen3 1.7B

The default model is Gemma 4 E4B running through Ollama. It produces detailed, accurate summaries and handles the messy reality of WhatsApp group chats well — mixed languages, slang, forwarded messages, emoji-heavy text. For users on lower-spec machines, Qwen3 1.7B is available as an alternative — smaller footprint, still solid quality for summarization.

Pipeline architecture

Interactive CLI: questionary

The user interface is a simple interactive terminal prompt built with questionary. On first run it asks for model, input folder, date range, and output path — then saves that config. The daily cron job uses the saved config automatically, so after the first setup the user never interacts with it again.

Scheduling:

Mac/Linux users add one crontab line to run it daily at their preferred time. Windows users set it up through Task Scheduler in four steps:

1. Open Task Scheduler → Create Basic Task
2. Name it WhatsApp Summarizer → Trigger: Daily → Set your preferred time
3. Action: Start a program
   • Program/script: C:\full\path\to\chat\venv\Scripts\python.exe
   • Add arguments: main.py
   • Start in: C:\full\path\to\chat\
4. Save.

For fully unattended runs, use saved defaults in .chat_digest_config.json — the script auto-runs in non-TTY mode when defaults are present, so no prompts block the scheduled execution.

Why Does Open Innovation Matter?

Three things that a closed API simply cannot offer for this use case:

1. Privacy is non-negotiable here.

WhatsApp group messages contain genuinely private information — family conversations, college announcements, workplace discussions. Sending that data to an external API means it travels over the internet, hits someone else’s server, and potentially gets logged. With a local open model, the data never leaves the machine. Full stop. This isn’t a preference — for many users, especially in academic or professional contexts, it’s a hard requirement.

2. Zero ongoing cost.

Cloud APIs charge per token. Run this every day for a year across 20 groups and the costs add up. A local model costs nothing after the one-time download. For a college student this matters — they’re not paying a subscription to stay on top of their coursework announcements.

3. Works without internet.

Works without internet. Hostels have unreliable Wi-Fi. Travelling happens. The morning you most need your digest might be the morning your connection is down. Because everything runs locally, the tool works regardless of connectivity. The CRON job fires, Ollama serves the model, the digest appears. Internet is irrelevant.

The honest tradeoff: Cloud models are faster and produce marginally higher quality output — comparing GPT-4o to Gemma 4 E4B, the cloud model summarizes faster and handles edge cases more gracefully. But for a daily summarization task on casual group chat text, the quality difference is negligible and the privacy difference is absolute. Open wins here.

The Lazy Payoff

My friend is a second-year college student managing 20-25 WhatsApp groups. His previous routine was 20-25 minutes every morning manually scrolling through all of them, still regularly missing things because of sheer message volume. He’s been running WhatsApp Digest for two days and it’s working exactly as intended — one markdown file every morning covering every group, nothing to scroll through manually.

Two days is too early for dramatic stories. But the core problem is real: when you have hundreds of messages across 20+ groups daily, manual checking isn’t sustainable. Most of it is noise, and the important stuff gets buried. A 2-minute digest every morning is the right solution and so far it’s delivering exactly that.

The people who benefit most from this aren’t lazy — they’re overwhelmed. College students managing coursework across multiple groups, professionals in too many team chats, anyone where the signal-to-noise ratio has tipped past the point of manual management. For them, 20 minutes of daily scrolling isn’t a choice, it’s an obligation. This tool eliminates it entirely.

Prize Categories

Best Use of Gemma — WhatsApp Digest uses Gemma 4 E4B as the primary model, running locally via Ollama. The model handles real-world messy chat text well and produces clean structured summaries within tight line limits.

Built by Aaditya Singh