DEV Community: Masham

StudyGuardian: Your Local-First AI Study Planner Powered by Gemma 3

Masham — Sun, 25 Oct 2026 21:27:51 +0000

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

What I Built

StudyGuardian is a local-first study planner that keeps your Google Classroom coursework, uploaded notes, and AI-generated study plans entirely on your computer.

It answers four questions every student asks every week:

What coursework is due this week?
What should I work on first?
Where's the related material — in Classroom or in my notes?
How do I revise from the notes I already have?

Gemma 3 4B, running locally through Ollama, handles the planning, note matching, and exam revision pack generation. No coursework ever leaves your machine for AI processing.

The UI uses a brutalist design — thick borders, zero border-radius, monospace typography, offset box-shadows with micro-animations — and includes a dark/light mode toggle that persists across sessions via localStorage.

Who gets to be lazier? Any student who's tired of manually scanning Classroom, cross-referencing notes, and figuring out what to study first. StudyGuardian does the triage so you can focus on actually studying.

🎮 Demo

🔗 Deployed demo (Render): StudyGuardian on Render

Note: The public demo runs in demo mode only — no Google login, Ollama, or uploads on the public host. Gemma runs locally on your computer.

Free Render instances sleep after inactivity, so the first load can take approximately 60 seconds.

💻 Code

Masham-0 / studyGuardian

StudyGuardian

Your week, organized. Your exams, less stressful.

Hosted demo: the Render service runs demo mode only. It shows the labeled sample week and does not accept Google login, uploads, web search, audio, or a connection to Ollama.
Source: https://github.com/Dev-Nidhan/studyguardian
Demo (about 75 seconds): https://github.com/Dev-Nidhan/studyguardian/blob/main/docs/demo.webm
License: MIT

StudyGuardian is a local study planner for the Hacktoberfest 2026 Week 3 "Slow and Steady" challenge. It keeps Google Classroom coursework, uploaded notes, and study plans on your computer. Gemma, through Ollama, prioritizes work, finds relevant pages in your notes, and builds a revision pack. It does not turn assignments in, and it does not send coursework to a cloud model.

What it answers

What coursework is due this week?
What should I work on first?
Where is the related material, in Classroom or in my notes?
How do I revise from the notes I already have?

Due dates, titles, links, and submission…

View on GitHub

🛠️ How I Built It

Open-Source AI Stack

Layer	Tool	Role
Model	Gemma 3 4B (open-weight)	Weekly planning, note-to-assignment matching, exam pack generation
Local inference	Ollama	Runs Gemma on-device without cloud calls
UI framework	Streamlit	Dashboard, week view, courses, exam prep, settings
Data	SQLite	Assignments, plans, preferences — all local
PDF extraction	PyMuPDF	Local text extraction from uploaded notes
Optional: Search	SerpApi	Live web search for study resources, only on button click
Optional: Audio	ElevenLabs	Spoken revision passages, only after explicit consent

Key Design Decisions

1. Gemma runs only on explicit user action

Gemma runs only when the user presses Generate Plan, Find Relevant Sections, or Build Revision Pack. Streamlit reruns never trigger the model.

2. Citations are validated

If Gemma cites a page that doesn't exist in an uploaded file, that citation is stripped and flagged. No hallucinated sources make it to the UI.

3. Offline-first architecture

After the first Classroom sync, the core application works without internet. Saved plans, notes, and search results are stored in SQLite.

4. No telemetry

Streamlit usage statistics are disabled. No analytics, no remote database, and no cloud AI inference.

5. Brutalist UI

The interface is deliberately bold and raw:

Sharp corners and thick 3px borders
Space Mono for data labels
Inter 900 uppercase headings
A #ff3d00 deep-orange accent
Offset box-shadows that animate on hover and click

A fixed dark/light toggle in the top-right corner switches CSS variables instantly through JavaScript. The preference persists in localStorage, while a MutationObserver keeps the styling consistent across Streamlit rerenders.

📚 Pages and Features

1. Dashboard

One recommended next action based on due dates
Metric cards for past-due assignments
Assignments due this week
Assignments without deadlines
Submitted assignments

2. This Week

Assignments grouped by course
An editable AI-generated study plan

3. Courses & Materials

Google Classroom links
Uploaded PDF and text notes
Grounded note-to-assignment matching
Optional web search for additional study resources

4. Exam Prep

Generate revision materials directly from your uploaded notes:

Revision notes
Key definitions
Flashcards
Practice questions

Generated material includes citations to the uploaded file and page number, making it easier to verify answers against the original source.

5. Settings

Model configuration
Timezone settings
Google Classroom connection
Demo data controls

🌱 Why Does Open Innovation Matter?

StudyGuardian processes real student coursework — assignment titles, descriptions, uploaded notes, and study plans. This is sensitive educational data that has no business leaving a student's computer just to generate a revision sheet.

Open-weight Gemma 3 + Ollama makes it possible to run the entire AI pipeline locally.

With a conventional hosted AI API, depending on the provider and configuration:

Every assignment description may be sent to a third-party server.
Uploaded notes may need to be transmitted over the internet.
Students on restrictive school networks might be blocked entirely.
Per-request costs can make frequent use difficult for students on tight budgets.

With Gemma running locally through Ollama:

🔒 Privacy: Zero coursework leaves your machine for AI processing.
💸 Cost: No per-request cloud AI charges after the initial model download.
📴 Offline access: Study on a plane, in a library basement, or wherever you need to.
♾️ No AI API rate limits: Generate plans and revision packs subject to your hardware and available resources.
🔍 Transparency: Every prompt template is available in the source code instead of being hidden behind an API.

Open innovation means students can verify what the AI sees, modify prompts, swap in a different model, or extend the entire application.

That's not possible to the same extent when the entire AI workflow is locked behind a closed API.

Open innovation isn't just about making AI accessible. It's about giving people the freedom to understand, adapt, and improve the technology they rely on.

⏱️ The Lazy Payoff

Without StudyGuardian, a student's weekly workflow might look like this:

Task	Estimated time
Open Classroom, scan courses, and mentally rank what's due	~15 min
Open notes and find material relevant to each assignment	~20 min
Build a study plan manually	~10 min
Make flashcards and revision notes manually	~30+ min
Total	~75+ min

With StudyGuardian:

Sync Google Classroom.
Click Generate Plan.
Click Build Revision Pack.
Review the results and start studying.

Gemma handles the initial triage, note matching, and revision-material generation. The workflow can require under two minutes of active user interaction, plus model processing time.

On suitable hardware, Gemma may take around 30 seconds to process a task, depending on the workload and system configuration.

That's roughly an hour saved per week on organizational overhead, based on these illustrative estimates.

Of course, AI-generated plans and revision material still need to be reviewed. The goal is to spend less time organizing and more time actually learning.

🏆 Prize Categories

Best Use of Render

The public demo runs on Render's free tier with STUDYGUARDIAN_PUBLIC_DEMO=1.

It shows a clearly labeled sample week without exposing OAuth secrets, private notes, or a local model endpoint. Gemma stays on your computer.

Best Use of Gemma

Gemma 3 4B through Ollama powers the planner, note matcher, and exam-pack generator.

Priorities are estimates, while assignment deadlines remain attached to their source records. Citations referencing pages that do not exist in an uploaded file are removed.

Best Use of SerpApi

The Courses & Materials page can search a topic and retain only URLs returned by the search provider. Invented URLs are discarded, and saved results persist in SQLite for offline access.

Best Use of ElevenLabs

Exam Prep can speak a revision passage after the user acknowledges a disclosure checkbox.

Only the selected text is sent for audio generation. Passages longer than 2,500 characters are rejected before a request is made, and the rest of the application works without audio.

🚀 What's Next?

StudyGuardian explores a simple idea: AI-assisted studying should be private, accessible, and practical.

A study assistant shouldn't force students to choose between convenience and control over their data.

By combining local inference, open-weight models, a lightweight database, and grounded citations, StudyGuardian demonstrates how that balance can work in practice.

There's still plenty of room to improve the planning logic, support more file formats, strengthen citation validation, and make the study experience smoother.

💬 Try It Out

Check out the code, explore the demo, and share your thoughts!

I'd especially love feedback on how StudyGuardian could become more useful for students managing multiple subjects, assignments, and exams.

Less admin. More learning. And your notes stay yours.

Gemma #Ollama #OpenSourceAI #AI #StudentProjects #Render #Python #BuildInPublic

SponsorProof: Catch Sponsorship Mistakes Before You Hit Submit with Local AI

Masham — Sun, 18 Oct 2026 18:58:43 +0000

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

SponsorProof: Catch Sponsorship Mistakes Before You Hit Submit

What I Built

Ever finished a sponsored video script, felt confident about it, and then discovered that you missed the exact discount code, forgot a mandatory hashtag, or skipped a talking point buried in the brand brief?

That’s the problem SponsorProof is built to solve.

SponsorProof is an evidence-based compliance auditor for content creators, video editors, and marketing agencies. It compares a brand's campaign brief against a draft script, transcript, or caption and catches potential compliance issues before the content reaches the client.

Here’s what it checks:

Exact requirements: Verifies discount codes, required hashtags, sponsor URLs, and disclosure phrases using deterministic code rather than relying on an LLM.
Semantic requirements: Uses local Google Gemma 3 to evaluate talking points, prohibited claims, product benefits, and tone.
Verifiable evidence: Links findings to verbatim excerpts from the brief and draft, making it easier to understand why something was flagged.
Duration and pacing: Estimates spoken content duration using word count and an approximate speaking rate.
Actionable corrections: Suggests copy-paste-ready text to address missing or questionable requirements.
Shareable reports: Exports audit results as Markdown or structured JSON.

One important design decision: SponsorProof doesn't blindly trust the AI. If the model marks a requirement as compliant but the evidence verifier cannot find supporting text in the draft, that finding is downgraded to NEEDS_REVIEW.

The goal is simple: fewer avoidable revision rounds, fewer missed deliverables, and more confidence before submitting sponsored content.

For creators managing multiple brand deals and agencies reviewing content at scale, catching these mistakes early can save time and reduce unnecessary back-and-forth.

Code

GitHub Repository: https://github.com/Masham-0/payCheck

The project combines a deterministic verification engine with local AI inference, keeping exact-match checks separate from semantic interpretation.

How I Built It

SponsorProof is built with Next.js, React, TypeScript, and Tailwind CSS, with Google Gemma 3 running locally through Ollama.

The core idea was to use the right tool for each type of verification instead of making an LLM responsible for everything.

1. Deterministic verification

Some campaign requirements aren't open to interpretation.

If the brand requires STYLE15, then STYLE10 is wrong. If a campaign requires three hashtags, including only one isn't enough.

I implemented rule-based checks for exact promotional codes, individual hashtags, sponsor URLs, and recognized disclosure phrases. Each required hashtag is verified independently, using word-boundary-aware matching to avoid accidental matches.

2. Local semantic analysis with Gemma 3

Other requirements need contextual understanding.

A brief might require a creator to explain a product's privacy benefits or mention a specific feature naturally. Simple keyword matching can't reliably determine whether the draft actually communicates the intended message.

That's where Gemma 3 comes in. The model evaluates semantic talking points, claims, and tone through local Ollama inference.

The default model configuration is gemma3:1b.

3. Evidence verification

AI-generated findings are only useful when they can be checked.

SponsorProof extracts supporting quotations from the original brief and the creator's draft, along with character offsets where available. The evidence verification layer checks whether quoted text actually exists in the source material and prevents unsupported AI judgments from being treated as confirmed compliance.

4. Scoring and reporting

Findings are classified by severity: CRITICAL, IMPORTANT, or RECOMMENDED.

A weighted scoring system calculates the compliance score and determines the overall status:

READY_TO_POST
CHANGES_REQUIRED
HIGH_RISK_VIOLATIONS

The results include explanations, supporting evidence, and suggested fixes, which can then be exported for a client or team review.

I also added sample campaigns, including VPN, fintech, and mobile gaming integrations, with flawed and compliant scripts to make the audit process easier to demonstrate and test.

Finally, SponsorProof reports Ollama's connection status and model availability honestly. If the model isn't available, the application doesn't pretend that an AI audit was completed.

Why Does Open Innovation Matter?

For a tool that evaluates sponsored content, privacy, transparency, and control matter just as much as accuracy.

Brand briefs and unpublished scripts can contain campaign details that creators and agencies aren't ready to share publicly. Using an open-weight model through local inference offers a way to run semantic analysis without depending on a third-party hosted LLM API for every audit.

Open innovation also made it possible to experiment with a hybrid approach: use deterministic code for requirements that must match exactly, and use a locally run language model for requirements that need contextual interpretation.

Neither approach is sufficient on its own.

A rule-based engine can't reliably understand whether a product benefit has been explained correctly. An LLM, on the other hand, shouldn't be trusted to validate an exact coupon code or invent evidence for a compliance decision.

Combining both creates a more transparent workflow in which the model provides contextual assistance while deterministic checks and source verification keep the results grounded.

There's also a practical benefit: local inference gives developers more control over model selection, deployment, and experimentation without making every semantic check depend on a paid API.

Of course, local inference is not a complete privacy guarantee by itself. The surrounding application's data handling still matters, and AI-generated findings remain reviewable recommendations rather than legal certification.

That's the kind of open innovation I wanted to explore with SponsorProof: not just adding AI to an application, but designing the workflow around its strengths and limitations.

🌿 NaturesCall: Turn Your Walks Into Adventures!

Masham — Sun, 11 Oct 2026 21:44:13 +0000

What if your daily walk felt less like a routine and more like an adventure? 🗺️

Introducing NaturesCall — a neighbourhood discovery game that transforms the world around you into an interactive exploration experience.

🚶 Explore your surroundings — Walk to uncover your map and reveal new areas.

📍 Discover nearby places — Find interesting locations around you using OpenStreetMap data.

🎯 Complete quests — Follow challenges and solve riddles as you explore.

🏆 Collect badges — Track your discoveries and celebrate your progress.

🔒 Privacy-first by design — Your walking history and discovery progress stay on your device.

📴 Offline-friendly exploration — Previously loaded regions are cached locally, so you can continue exploring even without an internet connection.

🛠️ Tech Stack

NaturesCall brings together modern web technologies and on-device AI, including:

Frontend: Vite, Leaflet

AI / ML: Gemma, Transformers.js, wllama

Maps & Places: OpenStreetMap, Overpass API

Development & Testing: Node.js, automated tests and browser checks

🚀 Run It Locally

Want to explore the project or contribute?

git clone https://github.com/Masham-0/NaturesCall.git
cd NaturesCall
npm install
npm run dev

Start the places service separately with npm run server, and run the test suite with npm test.

You can also use ?debug to simulate walking without leaving your desk. Pretty useful when you're debugging a walking game at 3 AM. 👀

🌍 Make It Your Neighbourhood

You can configure a home area, adjust its discovery radius, and regenerate place data to create a personalized exploration experience.

The project uses OpenStreetMap data, with attribution to its contributors under the Open Database License (ODbL).

💡 Why NaturesCall?

The idea is simple: make people more curious about the places they walk past every day.

Instead of staring at a screen while walking, NaturesCall encourages you to explore your surroundings, uncover hidden corners of your neighbourhood, and turn ordinary walks into small adventures.

🔗 Explore the Project

GitHub Repository: httpss://github.com/Masham-0/NaturesCall

I'd love to hear your thoughts!

What features would make you want to explore your neighbourhood more often? Drop your ideas in the comments. 🌱

DevChallenge #HF26Challenge #WebDev #OpenSource #AI #Gemma #OpenStreetMap #Nature #IndieDev

Deadline Guardian : Built for my All-Nighter friend

Masham — Mon, 05 Oct 2026 07:33:53 +0000

Every semester, my college friend and I face the exact same chaos before our exams: piles of slides and notes, scanned PDFs, previous-year papers, syllabi, and only a few hours left.

When you're pulling a deadline all-nighter, reading through hundreds of slides line-by-line is impossible. Asking a standard LLM often leads to generic fluff or hallucinated answers with zero references.

That's why I built Deadline Guardian, a RAG-based project for the DEV Hacktoberfest Weekend Challenge — "Build for a Friend"!

We can all work together on this project to improve this small Deadline Guardian for all of us!

🚀 Key Features

❓ Ask Anything (Grounded RAG with Citations): Answers questions strictly using your uploaded notes, complete with exact inline file and page citations such as [ch4.pptx p.11].
📝 High-Yield Cheat Sheets: Condenses dense chapters into quick, digestible revision cheat sheets.
⏱️ Deadline Panic Plan: Tell it how many hours you have left before the exam. It automatically prioritizes topics into tiers — 🔴 High-Yield, 🟡 Medium, and 🟢 Low — and generates an hour-by-hour actionable timetable.
📂 Multi-Format Support: Parses digital PDFs, PPT/PPTX slide decks, plain text notes, Markdown files, and photos of handwritten pages or diagrams.
🧮 LaTeX Math & Compilable Code: Renders mathematical equations using KaTeX and formats programming algorithms such as Peterson's Solution and CPU scheduling as compilable C/C++ code blocks.

🔗 Links

GitHub Repository:

https://github.com/Masham-0/deadline-guardian

Live Demo:

https://deadline-guardian-3195.onrender.com/

🧠 Tech Stack

LLM: Gemma 2B
Embeddings: BGE-small
Architecture: Retrieval-Augmented Generation (RAG)

⚙️ Steps to Run Locally

1. Clone the Repository

git clone https://github.com/Masham-0/deadline-guardian.git
cd deadline-guardian
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

2. Configure Environment

Create a .env file:

LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
LLM_API_KEY=your_api_key_here
LLM_MODEL=gemma-2-9b-it

3. Start the Server

For the Google API setup:

uvicorn main:app --reload --host 127.0.0.1 --port 8000

For a local Ollama setup:

ollama pull gemma:2b

Then start the server with:

LLM_BASE_URL=http://localhost:11434/v1 \
LLM_API_KEY=ollama \
LLM_MODEL=gemma:2b \
uvicorn main:app --reload

👨‍💻 Author & Credits

Developer: Mohammad Masham

Email: mohd.masham@gmail.com

Institution: Netaji Subhas University of Technology (NSUT)

Hackathon: DEV Hacktoberfest Weekend Challenge 2026 — Build for a Friend

If you find Deadline Guardian helpful for your exam prep, feel free to drop a ⭐ on the GitHub repository!

Happy studying! 📚