DEV Community: Shourya Shinde

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

Shourya Shinde — Sun, 25 Oct 2026 07:11:45 +0000

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:

Collect incoming chat notifications.
Store messages locally with timestamps.
Send relevant messages to Qwen3 through Ollama.
Generate a concise digest highlighting important updates and follow-ups.
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. ☕

Samjho AI

Shourya Shinde — Sat, 17 Oct 2026 14:36:46 +0000

Samjho AI — Turn Complex Documents into Clear, Actionable Steps

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

Samjho AI — Understand the information. Know what to do next.

Have you ever received a college circular, scholarship announcement, application form, or government notice and struggled to understand what it actually requires you to do?

Important information is often buried in lengthy documents, complicated language, eligibility criteria, and confusing instructions. Missing a deadline or misunderstanding a requirement can mean missing an opportunity entirely.

That's the problem we're solving with Samjho AI.

Samjho AI is an AI-powered document understanding platform that transforms complex documents into simple explanations and actionable next steps. Instead of making users read through pages of formal language, it helps them understand the information that matters.

What can Samjho AI do?

Simplify complex documents: Convert formal and complicated language into easy-to-understand explanations.
Extract important information: Highlight eligibility criteria, deadlines, required documents, and key instructions.
Generate actionable next steps: Help users understand what they need to do after reading a document.
Support document-based questions: Build toward grounded question answering so users can ask questions about the information in their documents.

Who is it for?

Our initial target users are students, particularly those who regularly deal with college notices, scholarship announcements, internship opportunities, and application requirements. The platform could also help job seekers and individuals navigating public notices and administrative paperwork.

From a side-hustle perspective, Samjho AI could evolve into a freemium product, with basic document explanations available for free and paid plans offering higher usage limits, advanced document analysis, and additional productivity features. These are potential monetization paths, not an existing paid offering.

Our goal is simple: make important information easier to understand and easier to act on.

Demo

GitHub Repository: https://github.com/ShouryaShinde/Hacktoberfest2026_AetherElevateX
Backend Connection Guide: https://github.com/ShouryaShinde/Hacktoberfest2026_AetherElevateX/blob/main/docs/BACKEND_CONNECTION_GUIDE.md

Code

Explore the complete project repository:

👉 Samjho AI on GitHub

The project follows a modular frontend-backend architecture:

Frontend: React + Vite
Backend: Node.js + Express.js
Database: MongoDB with Mongoose
Architecture: MVC with a separate service layer
Validation: Zod schemas for structured AI output
Document processing: PDF and text extraction through the backend API

The repository also includes implementation documentation, an environment configuration template, and a backend integration guide to make collaboration easier.

How I Built It

We built Samjho AI using a React frontend and a Node.js/Express backend, keeping the application modular so that the AI capabilities can evolve independently of the user interface.

The backend includes request validation, centralized error handling, request IDs, rate limiting, and document upload and extraction support.

For the AI layer, we implemented a Gemma inference adapter with versioned prompt templates, Zod-based response validation, safe JSON repair, and a mock provider for development and testing.

The intended workflow is:

The user uploads a document or provides text.
The backend extracts the document content.
The AI inference adapter processes the extracted text using a structured prompt.
The response is validated against the expected JSON schema.
The frontend presents the result in a format suitable for understanding key information and taking action.

Structured output is particularly important for this project. We don't just want a block of generated text; we want information that the interface can display consistently, such as summaries, deadlines, eligibility requirements, and next steps.

The project uses a provider-adapter approach so that the inference implementation can be maintained or replaced without redesigning the entire application.

Current development status: The API foundation and Gemma provider adapter are implemented, while end-to-end frontend integration is in progress. Grounded Q&A and session functionality are planned next.

Why Does Open Innovation Matter?

Open innovation made it possible for us to build Samjho AI around an adaptable AI architecture rather than locking the application into a single proprietary provider.

Open-weight models such as Gemma offer developers more flexibility in how they experiment with inference, structure their applications, and choose deployment options. The ability to build a provider abstraction also makes it easier to evaluate alternatives as performance, cost, and infrastructure requirements change.

For a student-built project, this flexibility matters. We can focus on solving the actual user problem, test different approaches, and keep the backend maintainable without tying every application feature to one model provider.

Open innovation also encourages collaboration. By maintaining clear API contracts, modular services, and implementation documentation, we can make it easier for other developers to understand the project and contribute improvements.

For Samjho AI, the broader vision is to make AI-powered document understanding more accessible, adaptable, and useful in everyday situations.

Prize Categories

Best Use of Gemma — Using Gemma 4 for AI-powered document understanding and summarization.
Best Use of GitHub Copilot — Using GitHub Copilot to assist with development of the Samjho AI application.

Other Technologies Used

Ollama — Used for local model inference and experimentation.

Built with the belief that understanding information should never be a barrier to accessing an opportunity.

Samjho AI — Understand the information. Know what to do next.

FieldNotes - DEV Challenge Week 1 Hacktoberfest

Shourya Shinde — Tue, 06 Oct 2026 15:01:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

🌿 Field Notes — Trade Scrolling for Noticing

Field Notes is a local-first, AI-powered outdoor mission generator designed to help people spend less time scrolling and more time experiencing the world around them.

Instead of opening another app and consuming more content, users tell Field Notes:

⚡ How much energy they have — Slow & Soft, Curious, or Let's Roam
🌳 What's nearby — Anywhere, Park, Streets, or Garden
📍 Optionally, something they can see from their door

Field Notes then uses a locally running open-weight AI model to generate a small, personalized outdoor mission.

For example:

The Overlooked Corner

Take the most familiar route near you, but turn once where you normally wouldn't. Find a corner, doorway, tree, or view you've never properly looked at.

Each mission includes:

A short title
A practical activity
An estimated time
Something to look for
Something to take away from the experience

The idea is simple:

The AI shouldn't keep you on the screen. It should give you a reason to leave it.

Field Notes is designed for anyone who feels stuck in a scrolling loop, wants a low-pressure break from technology, or simply needs a small reason to step outside.

Demo

GitHub Repository: ShouryaShinde/FieldNotes

Project Screenshots:

Code

The complete project is open source on GitHub:

Field Notes — GitHub Repository

The project currently uses:

HTML
CSS
Vanilla JavaScript
Node.js
Express
Ollama
Llama 3.2 3B

How I Built It

The original prototype used a hardcoded collection of outdoor missions.

I changed that architecture so missions are generated dynamically by an open-weight AI model running locally.

Tech Stack

Frontend: HTML, CSS, Vanilla JavaScript
Backend: Node.js + Express
AI Runtime: Ollama
AI Model: Llama 3.2 3B
Communication: REST API
Output: Structured JSON
Inference: Local

The architecture is:

User
  ↓
Field Notes Web UI
  ↓
Vanilla JavaScript
  ↓
POST /api/mission
  ↓
Node.js + Express
  ↓
Ollama
  ↓
Llama 3.2 3B
  ↓
Structured JSON Mission
  ↓
Field Notes UI

When a user submits their preferences, the browser sends information such as:

{
  "energy": "medium",
  "place": "park",
  "location": "a quiet lane with two neem trees"
}

The Express backend constructs a prompt around those preferences and sends it to the local Llama 3.2 3B model through Ollama.

The model returns structured JSON containing:

{
  "title": "Follow the moving shade",
  "description": "Walk slowly through the park...",
  "time": "25 min",
  "look": "Places where sunlight meets shadow",
  "leave": "One detail you would normally miss"
}

The frontend then renders the generated mission using the existing mission card.

This means the application no longer depends on a fixed list of missions. Every interaction can produce a new activity based on the user's context.

Why Does Open Innovation Matter?

Open innovation made it possible to build Field Notes around local AI rather than a closed AI API.

That matters because the project's entire philosophy is local-first.

With a locally running open-weight model:

🔐 User-provided context can stay on the device.
💸 There are no per-request AI API costs.
🔑 No proprietary AI API key is required.
🧪 The model can be replaced and experimented with.
🛠️ Developers have more control over the AI layer.
🌱 The application can continue working without depending on a cloud AI provider.

A closed API could certainly generate outdoor missions. But using an open-weight model changes what is possible.

The AI doesn't need to be a remote service that users continuously send their information to. It can simply be another component running locally alongside the application.

That makes the technology fit the purpose of the project:

Use technology to help people disconnect from technology.

Prize Categories

Best Use of GitHub Copilot

GitHub Copilot was used during the initial development of Field Notes to help scaffold the project, implement the initial frontend structure, and iterate on the application's functionality.

Copilot helped accelerate the transition from the initial concept and UI prototype into a working web application, while the AI mission-generation layer was later implemented using Ollama and Llama 3.2 3B.

The project is open source and available here:

https://github.com/ShouryaShinde/FieldNotes

DEV Challenge 1 Complete - StudyMate

Shourya Shinde — Sun, 04 Oct 2026 22:01:09 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

StudyMate — AI-Powered Study Assistant

StudyMate is an AI-powered study companion built for students who spend too much time converting long study material into something they can actually revise.

I built it with fellow students in mind — especially when exams are approaching and there is a lot of material to go through.

StudyMate allows a student to paste their study material and automatically generates:

📝 Concise study notes
🔑 Important key points
🧠 AI-generated multiple-choice questions
✅ Interactive quizzes with instant scoring

Instead of manually reading through lengthy material and creating revision notes and questions, StudyMate turns the material into a structured revision experience in seconds.

Demo

Code

💻 GitHub Repository: https://github.com/ShouryaShinde/StudyMate

The project is organized as a monorepo containing:

client/ — React + Vite frontend
packages/ui/ — Shared shadcn/ui components
server/ — Node.js + Express backend
Ollama integration for local AI inference

How I Built It

StudyMate is built around open-source AI and local inference.

Tech Stack

Frontend

React
TypeScript
Vite
Tailwind CSS
shadcn/ui
React Router

Backend

Node.js
Express.js
Ollama

AI Model

llama3.2:3b

The core AI functionality runs through Ollama locally rather than relying on a proprietary hosted AI API.

When a student submits study material, the frontend sends it to the Express backend:

Student
   ↓
Study Material
   ↓
React Frontend
   ↓
Express API
   ↓
Ollama
   ↓
Llama 3.2 3B
   ↓
Structured JSON
   ↓
Notes + Key Points + Quiz