DEV Community: Mritunjai Gupta

User-Friendly Forces — Your Privacy Matters

Mritunjai Gupta — Sat, 24 Oct 2026 13:07:43 +0000

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

What I Built

User-Friendly Forces is a Chrome extension that reads, analyzes, and summarizes website privacy policies — so you never have to sit through walls of legalese again.

You know the drill: you click "I agree" without reading anything because nobody has time for 8,000 words of legal boilerplate at 2 AM. That agreement you just clicked through might allow the company to sell your browsing habits, share your data with 200+ "partners," retain your information indefinitely, or quietly opt you into targeted advertising.

User-Friendly Forces fixes that by doing the lazy thing smartly. Click the extension on any privacy policy page, and within minutes you get:

📊 A Privacy Score (0–100) — higher means more privacy-friendly
📝 A plain-English 3-sentence summary of what the policy actually says
🚩 Color-coded red flags (🔴 High / 🟡 Medium / 🟢 Low) with specific details like "Your data is sold to third parties" or "Retention period is indefinite"

The entire analysis runs on your machine using Ollama — no data sent to any server you don't control. If Ollama isn't available, it gracefully falls back to the Gemini API (with a key you provide).

Who gets to be lazier? Anyone who ever clicked "Accept" without reading — which is everyone. Now you can actually know what you agreed to, in 30 seconds instead of 30 minutes.

Demo

Video Demo:

Code

Code Base:

Mritunjaii / User-Friendly-Forces-Extension

User-Friendly Forces v2.0

A Chrome extension that analyzes website privacy policies and highlights suspicious patterns — using local AI (Ollama) with Gemini as a cloud fallback.

Architecture

[Chrome Extension popup]
        │ POST /  (prompt + optional Gemini key)
        ▼
[Node.js server — index.mjs]
        │
        ├─► Ollama  (localhost:11434)   ← primary (free, private)
        │
        └─► Gemini API                 ← fallback (if Ollama is offline)

Setup

1. Install dependencies

npm install

The only runtime dependency is Node.js ≥18 (uses native fetch).
express and cors are installed via package.json.

2. (Recommended) Install Ollama

Download from https://ollama.com
Pull a model: ollama pull llama3
Ollama runs automatically at http://localhost:11434

You can change the model by setting the environment variable:

OLLAMA_MODEL=mistral node index.mjs

3. (Fallback) Get a free Gemini API key

Visit https://aistudio.google.com/app/apikey
Copy your key
Either set it as an env variable
```
GEMINI_API_KEY=AIza… node index.mjs
```
…or enter it directly in the extension's ⚙️ Settings panel…

View on GitHub

How I Built It

Stack:

Chrome Extension (Manifest v3) — the user-facing popup, written in vanilla JS/HTML/CSS with a glassmorphism aesthetic
Node.js backend (index.mjs) — a tiny Express server running locally on localhost:5000
Ollama — primary AI inference, running completely locally on your machine
Gemini API — cloud fallback, only used if Ollama is unavailable

The open-source AI layer:

The extension sends the privacy policy URL to the local Node server. The server uses Ollama's chat API (/api/chat) to run the analysis with whatever open-weight model you have installed — tested with llama3.2, llama2, and mistral. It also handles older Ollama versions by falling back to /api/generate.

The model is given a strict structured prompt that forces JSON output with a privacy score, plain-English summary, and a list of flags with severity levels. A robust JSON extractor strips any markdown fences or preamble text the model might add before parsing.

The Gemini fallback tries 5 model names in sequence, skipping any that return 404 (some models aren't available in all regions):

const GEMINI_MODELS = [
  'gemini-2.0-flash',
  'gemini-1.5-flash',
  'gemini-1.5-flash-latest',
  'gemini-pro',
  'gemini-1.0-pro',
];

The health endpoint (GET /health) lets the popup check provider availability at startup and show a live status badge — green for Ollama ready, yellow for Gemini fallback, red if nothing is available.

Why Does Open Innovation Matter?

Privacy tools need to be private themselves. That's the core tension with a closed-API approach.

If I had built this with a hosted OpenAI or Anthropic API, every privacy policy you analyze would pass through their servers. You'd be trusting a third party with the URLs of every privacy page you visit, potentially leaking which services you use, when you use them, and what concerns you enough to check. A tool meant to protect your privacy shouldn't compromise it in the process of doing so.

With Ollama:

✅ Runs entirely offline — once the model is downloaded, no internet connection required
✅ Zero data leaves your machine — the policy URL, the AI prompt, and the analysis result never touch an external server
✅ Costs exactly $0 to run — indefinitely, for any number of policies
✅ Model-agnostic — swap llama3.2 for mistral, phi3, gemma2, or any future open-weight model that fits your hardware, with no code changes
✅ No API key, no rate limits, no usage quotas — analyze 500 privacy policies in a day if you want

A closed API would have introduced a monthly bill, rate limits, and the irony of sending your privacy-checking queries to a company whose own privacy policy you haven't read. Open inference removes all three problems at once.

The open approach also lets the community improve it: you could fine-tune a small model specifically on privacy policy datasets (there are several on Hugging Face) to get better, more consistent analysis than a general-purpose model provides. That's simply not possible with a closed API.

The Lazy Payoff

The average privacy policy is 2,500 words and takes ~10 minutes to read properly.

Most people spend 0 minutes reading it and just click "Accept."

User-Friendly Forces gets you from "0 minutes of knowledge" to "actually informed" in under 2 minutes, without reading a word.

In one week of testing across a dozen popular websites:

🔴 3 out of 4 had at least one high-severity flag
The most common flag: "Data shared with unspecified third parties"
Worst score seen: 18/100 (a popular fitness tracking app)
Best score seen: 71/100 (a small open-source developer tool)

The sloth doesn't read the privacy policy. The sloth makes the AI read it, hangs upside down, and waits for the summary. That's the energy.

Prize Categories

Best Use of Gemma — The extension works with Google's open-weight gemma2 model running locally through Ollama, giving users a Google-quality model without any API calls
Best Use of GitHub Copilot — Development workflow used Copilot for iterating on the structured prompt engineering and the JSON extraction logic

Turning WhatsApp Bursts into Briefs: A Local AI Tool for Freelancers & Small Businesses

Mritunjai Gupta — Thu, 15 Oct 2026 20:51:40 +0000

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

What I Built

Client communication on WhatsApp is notoriously chaotic. Freelancers and small business owners rarely receive structured project briefs; instead, clients send rapid-fire bursts of fragmented messages that bury essential scope shifts, budgets, and deadlines.

I built Client Buddy, a privacy-first client intelligence dashboard designed specifically for freelancers and small businesses.

It solves the "fragmented burst" problem by automatically grouping a client's rapid-fire messages and converting them into structured executive briefs containing explicit deliverables, hard deadlines, and tone-matched suggested reply drafts.

To respect professional boundaries, Client Buddy enforces a strict "Zero Auto-Reply" policy—the application never messages clients automatically, ensuring all outbound communication requires human discretion via 1-click copy-paste drafts. Finally, for severe incidents (like a server crash or payment failure), the system flags the issue as CRITICAL and triggers an immediate outbound phone call alert to your mobile device using a synthesized AI voice so you never miss an emergency.

Demo

Video Demo[https://youtu.be/T6_h7ZFzigc]

Code

Code Base[https://github.com/Mritunjaii/Client-Buddy.git]

How I Built It

Client Buddy is structured as a modern monorepo separating the dashboard from the heavy-lifting background workers.

The Ingestion Engine: I used whatsapp-web.js with Puppeteer to run a headless browser session that securely captures live incoming messages.
The Sliding-Window Batcher: To prevent disjointed summaries, incoming messages from the same chat reset a 120-second inactivity countdown (flushAt). I used MongoDB to store these pending batches, implementing atomic lease locks (findOneAndUpdate) to guarantee thread safety and exactly-once processing across background workers.
Local-First AI: The background worker feeds the aggregated batch into Ollama, running open-weight models (llama3.2:latest or gemma:2b) locally. The prompt forces strict JSON outputs to populate the Next.js dashboard with requirements, open questions, and drafted replies.
Critical Alerts: If the local LLM classifies a burst as a CRITICAL emergency, the backend calls the ElevenLabs API (eleven_multilingual_v2) to synthesize a realistic voice briefing, and uses Twilio to literally ring my mobile phone with the alert.
Zero-Footprint Privacy: Raw source messages are protected by a native MongoDB 7-day TTL index (expireAfterSeconds: 0), automatically purging raw chat records to maintain GDPR compliance.

Why Does Open Innovation Matter?

When you are managing client relationships, privacy is non-negotiable. Processing client NDAs, proprietary code snippets, and financial budgets through a closed-source cloud API is often a massive compliance violation.

Open innovation made Client Buddy possible. By leveraging local inference through Ollama and open-weight models, sensitive conversation histories never leave the user's machine for analysis. It provides enterprise-grade intelligence with zero cloud LLM exposure and zero per-token costs. Open models give freelancers the power of advanced AI without forcing them to compromise their clients' trust.

Prize Categories

I am submitting Client Buddy for the following prize categories:

- Best Use of Gemma: Utilized locally via Ollama as the core reasoning engine to extract structured deadlines, requirements, and reply drafts from messy chat data.

- Best Use of MongoDB Atlas: Used for complex state management, atomic worker lease locks (findOneAndUpdate) for the batching engine, and TTL indexes for privacy-first raw data purging.

- Best Use of ElevenLabs: Integrated the eleven_multilingual_v2 model to synthesize crystal-clear, natural speech for outbound emergency PSTN phone calls.

AFTERWORLD: Every Place Has a Past. Every Place Has a Possible Future.

Mritunjai Gupta — Sat, 10 Oct 2026 20:20:16 +0000

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

What I Built

AFTERWORLD is an editorial, open-weight AI web companion that transforms physical landmarks, urban structures, and historical sites into living portals across time.
Most modern web experiences are designed to maximize screen time, trap users in algorithmic feeds, and pull attention inward. AFTERWORLD does the exact opposite: it exists to pull you off your screen and out into the real physical world.

How it gets people out to "Touch Grass":

Geolocated Discovery ("Find Portals Near Me"): With a single tap, AFTERWORLD uses your device's geolocation to discover historical landmarks around your immediate physical coordinates. Whether you're standing in front of a centuries-old monument or walking down a historic city street, it turns your physical walk into a field expedition.
Three Portals of Time:
1. Past (Strictly Grounded): Deep historical narratives constructed exclusively from verified public records (Wikidata, Wikipedia, UNESCO, and curated archives). Every claim includes clickable, transparent source citations.
2. Present (Architectural & Physical Reality): Real-world coordinates, satellite/cartographic mapping, physical conservation challenges, and verified imagery.
3. Future (Speculative Projection): Imaginative horizons labeled Imagined future — not a prediction exploring ecological shifts, architectural preservation, and future human stewardship over decades and centuries.
Hands-Free Audio Walk Narration: Built-in voice synthesis (Web Speech API) turns every portal into an ambient audio walking tour. Pocket your phone, put on your headphones, and listen to the past and future of the ground you are walking on while looking up at the world around you.
Zero Distraction, Zero Surveillance: No accounts, no likes, no gamified leaderboards, and zero GPS tracking. You explore physical reality on your own terms.

Demo

Live Demo: [https://afterworld-hacktoberfest-open-source-ai.onrender.com/]
Video Demo: [https://youtu.be/hjsaewygV5U]

Code

GitHub Repository: https://github.com/Mritunjaii/AfterWorld-Hacktoberfest-Open-Source-AI-Challenge-Week-1.git

How I Built It

AFTERWORLD is built around Google Gemma 2 (gemma2:2b) running via a swappable Ollama local inference provider:

1. Zero-Hallucination Historical Grounding

Generative AI often hallucinates historical facts, inventing dates, names, and battles. In AFTERWORLD, the Past mode enforces an uncompromising architectural contract:

The backend queries Wikipedia/Wikidata APIs for the target location to build an evidence bundle of verifiable facts and source URLs.
The prompt instructs Gemma 2 to act strictly as a curator, synthesizing prose only from the supplied facts and returning exact fact IDs used.
If the AI model is offline or facts are insufficient, the system falls back to a deterministic, strictly cited prose synthesizer rather than fabricating history. ### 2. Fully Local, Private Edge Inference Through the AIModelProvider interface, AFTERWORLD connects directly to an Ollama instance serving gemma2:2b:
Fast 2B Parameter Footprint: Runs seamlessly on consumer laptops and edge devices without needing a dedicated server GPU.
Swappable Model Adapter: The application is model-agnostic and can effortlessly run Llama 3, Mistral, or custom fine-tunes with an environment variable tweak (OLLAMA_MODEL=gemma2:2b).

Why Does Open Innovation Matter?

I wanted AFTERWORLD to be more than another application that sends a prompt to a closed AI API.

Open-weight models make it possible to experiment with the storytelling process, change models, control prompts, and potentially run inference on infrastructure we control.

Using Gemma through Ollama provides a path toward local development and self-hosted inference. This can reduce dependence on a proprietary model provider and offer more control over where data is processed.

Open geographic data and a modular source-retrieval pipeline also make the project easier to extend and adapt.

Most importantly, the model is part of the actual product: it transforms retrieved historical evidence into an engaging narrative and creates a separate imaginative future for each location.

The vision is an exploration tool that encourages people to experience the world directly, with AI serving as a guide rather than the destination.

Prize Categories

Best Use of Gemma: If the implemented Gemma integration is used for narrative generation.
Best Use of SerpApi: If SerpApi is genuinely integrated into the source-discovery pipeline.
Best Use of MongoDB Atlas: If Atlas is used for application data and story caching.
Best Use of Render: If the application or backend is deployed on Render.
Best Use of Sentry: If Sentry is integrated for application monitoring.

Healtify: Turn your everyday bad habits into good one

Mritunjai Gupta — Sun, 04 Oct 2026 19:25:13 +0000

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

What I Built

I built Healtify, a personal lifestyle tracking and wellness companion for a friend who has been struggling with smoking and other unhealthy habits.
The initial idea was simple: create an application where he could track things like smoking, alcohol consumption, outside food, screen time, sleep, and physical activity.
But while building it, I realized there was a problem with only tracking bad habits.
If someone is already frustrated with their habits, opening an app every day and seeing charts showing smoking, junk food, or other negative behaviors going up can become discouraging. Instead of motivating them, the application could make them feel like they are constantly failing.
So I changed the idea.
Healtify tracks both the habits that are helping you and the habits that are working against you.
It tracks eight lifestyle dimensions:

Food & Nutrition
Smoking
Alcohol
Physical Activity
Sleep & Recovery
Hydration
Screen Time
Mental Wellness

The application calculates a transparent Healtify Score from 0–100 using a deterministic scoring system. The score is calculated by the backend rather than being guessed by AI.
One of my favorite features is Habit Balance. Instead of simply showing "bad habits," it visualizes the relationship between positive lifestyle behaviors and risk factors.
For example, if someone is struggling with smoking but has simultaneously started walking more, exercising, sleeping better, and drinking more water, Healtify makes that progress visible.
The goal is:
Don't focus only on what you're doing wrong. See what you're doing right, understand what needs attention, and gradually move your lifestyle in a better direction.

Healtify also provides AI-generated lifestyle reflections that interpret the user's trends and suggest small, practical actions. The AI is an interpretation layer, not a medical diagnostic system.

Demo

Live Demo:
[https://healtify-fcik.onrender.com/]
Video Demo:
[https://youtu.be/MJy8uAH1tzk]
The demo walks through:

Recording daily lifestyle habits
Real-time Healtify Score calculation
Lifestyle category trends
Habit Balance visualization
Positive habits vs. risk factors
AI-generated wellness reflections
Lifestyle goals and areas needing attention

Code

GitHub Repository:
[https://github.com/Mritunjaii/Healtify.git]
Tech Stack
Frontend

React Backend
Node.js
Express.js Database
MongoDB AI
Llama 3.2 via Ollama — primary/local AI
Gemini API — cloud fallback Architecture: React ↓ Node.js + Express ↓ MongoDB ↓ AI Service Layer ↓ Llama 3.2 via Ollama ↓ Gemini Cloud Fallback

The AI service is separated from the rest of the application so that Healtify can use local AI whenever available and fall back to Gemini when the local model is unavailable.

How I Built It

One of the main design decisions in Healtify was to make AI an interpretation layer, rather than allowing AI to control the application's core logic.
The Healtify Score is calculated deterministically by the Node.js/Express backend.
Each lifestyle category is normalized to a 0–100 score, and the overall score is calculated from those category scores.
The AI receives a structured summary of the user's lifestyle data and trends.
For example:
{
"steps": 10400,
"workoutMinutes": 45,
"sleepHours": 8.1,
"waterLiters": 2.3,
"smokingCount": 2,
"outsideFoodCount": 1
}

This information is passed to the AI service.
Local AI First
Healtify primarily uses Llama 3.2 through Ollama.
This allows the application to run the AI interpretation locally without sending the user's lifestyle information to a cloud AI provider.
The local model generates things such as:

Daily reflections
Weekly summaries
Score explanations
Practical micro-actions
Achievable lifestyle goals For example: "Your activity and sleep have been strong this week. Your biggest opportunity is reducing smoking while maintaining your current exercise routine."

Cloud Fallback
If the local Ollama service or model is unavailable, Healtify can use the Gemini API as a fallback.
The flow is:
User requests AI Insight
↓
Node.js AI Service
↓
Is Ollama available?
/ \
YES NO
↓ ↓
Llama 3.2 Gemini API
\ /
↓ ↓
AI Insight
↓
React

This gives the application the benefits of local AI when possible, while still providing a reliable cloud fallback.

Why Does Open Innovation Matter?

Open innovation is especially important for Healtify because the application deals with personal lifestyle data.
Using a local open-weight model through Ollama means Healtify can process AI insights locally without requiring every piece of lifestyle information to be sent to a cloud AI provider.
This gives the project:

Greater control over data processing
Local AI inference
Reduced dependency on a single cloud provider
The ability to experiment with different models
A path toward more privacy-focused deployments
The ability to run the AI layer without a constant internet connection The project also demonstrates that an AI-powered application does not necessarily need to send every request to a proprietary cloud model. Llama 3.2 via Ollama handles the primary AI workload locally, while Gemini provides a fallback when local inference isn't available. More importantly, Healtify doesn't use AI for everything. The application itself controls:
Habit tracking
Data storage
Score calculation
Category scoring
Habit Balance
Goals
Historical trends The AI simply helps the user understand the patterns in their own data.

Prize Categories

Render: Deployed and hosted as a live full-stack Web Service on Render with automated builds and environment variable management.
Gemma:Open-weight AI storytelling powered by Llama 3.2 via Ollama (with gemini cloud fallback).
MongoDB:as a database