DEV Community: Aashutosh kumar bhardwaj

MeetMind: Sloth-Mode Meeting Memory & Interview Coach Powered by Open-Weight AI 🦥

Aashutosh kumar bhardwaj — Sun, 25 Oct 2026 18:46:41 +0000

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

What I Built

Let’s be completely honest: nobody genuinely enjoys taking meeting notes or writing post-interview scorecards.

Scribbling down who said what, trying to track whether Priya promised the onboarding copy by Wednesday, and deciphering messy notes after a 60-minute technical interview is tedious, mentally draining, and stressful.

In honor of International Sloth Day and this week's "Slow and Steady" theme, I built MeetMind: a privacy-first, zero-effort meeting memory and interview coaching copilot powered by open-weight AI.

MeetMind is designed to let you channel your inner sloth:

Zero manual note-taking: Sit back, sip your tea, and stay fully engaged in the conversation.
Pure tab capture: Captures the meeting tab’s audio or Google Meet captions directly from Chrome—excluding your own background microphone noise.
Evidence-grounded synthesis: Automatically structures meeting briefs and candidate reviews with strict separation between verbatim facts and AI interpretation.
Cross-session memory: Ask questions across weeks of past meetings ("What did we decide about analytics launch?") without ever opening a doc.

Demo

Here is how MeetMind operates right from your browser:

One-Click Capture: Click Start Recording on any Google Meet or web call tab. MeetMind captures tab audio cleanly using Chrome’s MV3 Offscreen API.
Audio Preservation & Recovery: If your network stumbles, audio is automatically preserved in memory with 1-click retry and .webm download backup—no lost meetings.
Structured Briefings: In seconds, MeetMind generates clean, executive-ready markdown:
- Executive Summary: Core highlights.
- Decisions Made: Explicit agreements tagged with [Direct Evidence].
- Action Items: Checklist with assignees and deadlines (- [ ]).
- Interview Coach Mode: Objective technical evaluation separating verbatim candidate quotes from AI coaching recommendations.
Interactive Local Q&A: A built-in "Ask" panel that performs deterministic keyword retrieval across saved sessions with citation excerpts ([S1]).

Code

💻 GitHub Repository: https://github.com/aashutoshkumarbhardwaj/meetmind

The project consists of two clean, decoupled components:

Chrome MV3 Extension:
- tabCapture + Offscreen Document audio capture pipeline
- Visible Google Meet caption scraper with progressive speech de-duplication
- Built-in, zero-dependency client-side Markdown rendering engine with custom visual evidence badges
- Local session storage (up to 30 meetings preserved in-browser)
FastAPI Python Backend:
- Open-weight transcription via local faster-whisper (or Groq Whisper)
- Open-weight analysis via Ollama (qwen2.5:7b, llama3.2, etc.) or hosted open-weights (openai/gpt-oss-120b)
- Sliding-window rate limiting, secret redaction, and dual auth (X-API-Token / Bearer)
- Deterministic lexical retrieval engine for cross-meeting Q&A

How I Built It

Building an assistant that works reliably on open-source AI required solving four practical engineering challenges:

1. The Progressive Speech De-duplication Problem

Google Meet captions and live speech engines emit continuous progressive updates (e.g. YouTo., YouTo choose., YouTo choose our distributed database...). If fed directly to an LLM, these fragments clutter the context window and trigger hallucinated stuttering critiques.
I implemented a space-aware recursive node walker in the extension content script and a backend clean_progressive_transcript() filter that collapses intermediate prefixes into single coherent sentences.

2. Strict Evidence Grounding Protocol

Most AI meeting summaries hallucinate commitments or invent quotes. MeetMind uses a strict 3-tier evidence classification prompt:

[Direct Evidence]: Verbatim quotes directly attested in the transcript.
[AI Inference / Analysis]: Deductions, trade-off evaluations, and coaching suggestions.
[Insufficient Evidence in Transcript]: Explicitly signals when information was not discussed, preventing the model from assuming proficiency or making up deadlines.

In the extension popup, a custom client-side renderer transforms these tags into sleek emerald, indigo, and amber visual pills.

3. Decoupled Local Open-Weight Pipeline

The backend is completely provider-agnostic. By setting two environment variables:

TRANSCRIPTION_PROVIDER=local
AI_PROVIDER=ollama
OLLAMA_CHAT_MODEL=qwen2.5:7b

The entire transcription and reasoning pipeline executes on the user's laptop using faster-whisper and Ollama, keeping 100% of the conversation offline.

Why Does Open Innovation Matter?

Open-weight models and local inference aren't just technical novelties for MeetMind—they are what make the product viable:

Uncompromising Privacy & Compliance: Business meetings, 1-on-1s, and job interviews contain highly confidential information—salaries, IP, strategy, and personal stories. Strict NDA and GDPR compliance prevent many professionals from piping conversations through third-party proprietary APIs. Running open-weight models (Qwen 2.5, Whisper) locally ensures confidential data never leaves the host machine.
Zero Metered Costs: Proprietary speech and LLM APIs charge by the minute and token. With open-weight models running on existing hardware, MeetMind costs $0.00 to run indefinitely.
Offline Autonomy: Whether you're on a spotty train Wi-Fi or behind a secure corporate air-gap, local open models continue transcribing and generating notes without an active internet connection.
Freedom from Vendor Lock-In: You are never locked into a single provider's deprecation cycle, pricing hike, or content policy shifts.

My Agent Session

This project was built and debugged pair-programming with Antigravity / Gemini CLI. The interactive session transcript has been preserved on DEV:

Building MeetMind: Privacy-First Meeting Memory with Open-Weight AI

You

We need to build MeetMind: a privacy-first meeting memory and interview coaching extension + FastAPI backend that runs with open-weight models (Whisper + Ollama/Qwen) so users never have to take manual meeting notes again.

Agent

I will design the architecture: Chrome MV3 extension with tabCapture and offscreen audio recording, paired with a FastAPI backend supporting both local faster-whisper and Ollama open-weight LLMs with strict evidence grounding.

▸ view_file view_file backend/main.py

Input

view_file backend/main.py

Output

Read backend API and pipeline handlers

You

How do we prevent hallucinations and ensure meeting action items and interview feedback are strictly evidence-grounded?

Agent

We implement strict evidence separation rules: [Direct Evidence] for verbatim quotes, [AI Inference / Analysis] for synthesis, and [Insufficient Evidence in Transcript] for gaps. We also added progressive caption de-duplication and a zero-dependency client-side Markdown engine with custom visual status pills.

🔗 Session Link: https://dev.to/agent_sessions/building-meetmind-privacy-first-meeting-memory-with-open-weight-ai-ldtxlj

The Lazy Payoff

Here is the sloth math on what MeetMind saves:

30 to 45 minutes saved per meeting: No more organizing raw bullet points, tracking down action item owners, or drafting follow-up emails manually.
1 hour saved per interview round: Rather than staring at a blank scorecard wondering how the candidate explained concurrency, the interview coach extracts exact quotes and structured feedback instantly.
Total mental energy conserved: You can lean back, listen with full attention, and let open-source AI do all the heavy lifting.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady (Primary Challenge Entry)

devchallenge #hf26challenge #ai #opensource

OpenlySearch: Privacy-First Local AI Desktop Intelligence & Project Memory 🔍

Aashutosh kumar bhardwaj — Sun, 18 Oct 2026 18:29:09 +0000

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

What I Built

Modern professionals—freelancers, developers, legal consultants, researchers, and small agency founders—face two critical problems when using AI in their daily workflow:

The Privacy & Compliance Wall: They handle sensitive client codebases, confidential contracts, financial spreadsheets, and proprietary notes that legally cannot be uploaded to third-party cloud AI APIs (like OpenAI or Anthropic) due to strict non-disclosure agreements (NDAs) and data residency laws.
Context Fragmentation: High-value tasks, architectural decisions, and copied terminal commands or credentials scatter across folders, messy markdown notes, and clipboard history.

OpenSearch solves this by delivering a commercial-grade, privacy-first desktop intelligence assistant that runs 100% locally on your machine with zero cloud telemetry.

OpenSearch turns passive local project folders into an active, actionable workspace:

Hybrid Semantic + Lexical Search: Instant sub-second search combining local MiniLM embeddings (all-MiniLM-L6-v2) with keyword ranking over documents, PDFs, Markdown, and code.
Universal Project Intelligence: Scans project repositories to synthesize architectural overviews, spot unaddressed risks, and extract verified next steps with citations.
Decision & Task Memory: Automatically identifies architectural choices, rationales, and pending action items with confidence scores and source excerpts.
Target Scope Selection: Focuses semantic analysis specifically on selected files or folders (e.g. client rubrics, audit directories) with on-the-fly parsing.
Assessment Action Plan & Interactive Notepad: Parses specs and assessment rubrics into structured phases, extracts deliverable deadlines, provides interactive [x] tick marks, and persists notes.
Interactive Calendar & Milestone Timeline: A full monthly calendar with day schedule inspection, one-click task completion tick marks, and velocity roadmap lanes (Overdue, Due Today, This Week, Upcoming 30 Days).
Searchable Clipboard Memory: Automatically captures and categorizes copied code, commands, and notes while proactively filtering out sensitive API keys and secrets.
Daily Memory Briefing: Generates morning project briefings with velocity scoring, intent setting, and local text-to-speech audio readout.

The Side Hustle / Commercial Opportunity: Who Would Pay For This?

OpenSearch is designed as a product that freelancers, boutique agencies, and enterprise consultants would gladly pay for:

Target Audience: Freelance developers, security auditors, legal/medical research consultants, and privacy-conscious professionals managing multi-client projects.
The Value Proposition: "Private AI intelligence that never leaks your clients' data." A single client data breach or NDA violation can cost thousands of dollars; OpenSearch guarantees complete local isolation.
Business Model:
- Free open-source core application.
- $29/seat/month Pro tier (or $99 perpetual license) for power user features: custom offline model packs, automated client audit reporting, and encrypted multi-device sync.
- Freelancers can bill it as a legitimate business expense for client data compliance.

Demo

Video : https://echowave.io/app/watch/fCE84IEVvzrgqIfgOQeI/

💻 Project Demo & Releases: Available directly in the GitHub repository.

The desktop app runs locally on macOS, Linux, and Windows, offering instant keyboard navigation (Alt + Shift + Space), multi-view task and calendar scheduling, and local LLM switching.

Code

💻 GitHub Repository: https://github.com/aashutoshkumarbhardwaj/openSearch

The project is built with:

Desktop Runtime: Electron 34 + TypeScript + electron-vite
Frontend: React 19 + Lucide Icons + Vanilla CSS design system
Open-Weight AI Embeddings: @huggingface/transformers running Xenova/all-MiniLM-L6-v2 locally via ONNX Runtime Web
Local LLM Engine: Seamless integration with local Ollama runtimes (supporting open models like SmolLM2-360M, Llama 3.2-1B, and Qwen 2.5)
Document & PDF Parsing: pdf-parse for on-the-fly extraction of rubric specifications and PDF briefs

How I Built It

The core technical challenge was building an end-to-end desktop intelligence assistant where every single feature runs on the user's hardware without sending a single byte to external servers.

1. Local Embeddings & Semantic Indexing Pipeline

Rather than relying on remote vector databases, OpenSearch chunks local documents, generates 384-dimensional dense vectors using @huggingface/transformers, and persists them in a lightweight local index (userData/index.json). Search queries execute cosine similarity combined with lexical scoring in under 5ms.

2. Grounded Decision & Task Extraction

The memory engine analyzes indexed passages using dual-mode reasoning:

A deterministic fallback parser that extracts explicit TODOs, FIXMEs, deadline patterns, and decision records using regex and pattern analysis.
An optional local LLM pipeline (via Ollama) that structures complex natural language notes into actionable tasks with confidence scoring and exact source excerpt verification.

3. Action Planner with Milestone Calendar & Tick Marks

To bridge the gap between reading a project spec and executing it, OpenSearch features a specialized planner:

Reads PDFs, Markdown, and text files.
Structures deliverables into chronological phases (Requirements, Implementation, Verification).
Binds tasks to an interactive monthly calendar and milestone timeline with one-click [x] completion tick marks that synchronize with local storage.
Provides a persistent scratchpad notepad for live meeting and rubric notes.

4. Searchable Clipboard Memory with Privacy Filtering

To capture ephemeral workflow knowledge (code snippets, terminal commands, URLs), OpenSearch continuously monitors the clipboard. Crucially, a built-in entropy and pattern scanner automatically detects and skips sensitive tokens (Stripe keys, AWS access IDs, RSA private keys, connection strings) before saving.

Why Does Open Innovation Matter?

Open innovation is the cornerstone of OpenSearch:

Data Sovereignty & Zero Trust: When you work with open-weight models (like SmolLM, Llama 3.2, Qwen), you own the weights, the inference, and the data. No corporation can change terms of service, train on your proprietary code, or revoke API access.
Economic Viability for Freelancers: Cloud AI APIs incur metered per-token costs that scale with document size. For a freelancer indexing hundreds of PDF pages and code repos, cloud API costs quickly become prohibitive. Open-source local models run for free on existing laptop CPUs and GPUs.
Resilience & Offline Autonomy: Whether working on an airplane, in a remote location, or behind an air-gapped corporate firewall, OpenSearch provides uninterrupted intelligence and search.

Prize Categories

Best Use of a .tech Domain (or Overall Challenge Entry): OpenSearch represents an open, privacy-first alternative to closed-source cloud intelligence tools, built for real-world independent professionals and freelancers.

devchallenge #hf26challenge #ai #opensource

TouchQuest: An AI That Helps You Put Your Phone Down 🌿

Aashutosh kumar bhardwaj — Mon, 12 Oct 2026 14:39:11 +0000

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

What I Built

We have apps that help us track our habits, optimize our schedules, and spend more time online. But what if an app's goal was to help us spend less time using it?

That's the idea behind TouchQuest.

TouchQuest is an offline-first Android application that turns the simple idea of taking a break into a personalized, real-world mission. Instead of endlessly scrolling through recommendations, users get one small activity they can actually do.

Maybe you feel overwhelmed and need five minutes of quiet. Maybe you feel restless and want to move a little. Or maybe you simply want to notice something interesting outside your usual routine.

TouchQuest helps you find a starting point.

Users can choose their mood, energy level, available time, preferred environment, and accessibility needs. The app then attempts to generate a personalized mission using an open-weight language model running locally on the device. If the model is unavailable or returns an invalid response, TouchQuest can provide a built-in alternative instead.

Each mission includes actionable steps, a suggested duration, a phone-down reminder, and safety guidance. Users can start a timer, complete their activity, reflect on the experience, and track their progress through XP, streaks, a growing virtual garden, and mission history.

The goal isn't to keep users engaged with TouchQuest for hours.

The goal is to help them find one meaningful thing to do, put their phones away, and experience it.

Demo

🎬 Watch TouchQuest in action: [https://youtube.com/shorts/lpF4a4xKiHU?si=rJkPdCTR-wBXR8ZE]

The demo shows the Android app, its personalized mission flow, and how users can turn a small suggestion into an offline, real-world activity.

📱 Try the Android APK: [ https://github.com/aashutoshkumarbhardwaj/TouchQuest/releases/download/V1.0/app-debug.apk ]

The app is designed to work offline after the required model assets are available locally. Actual offline behavior depends on successful model setup and device compatibility.

Code

💻 GitHub repository: [https://github.com/aashutoshkumarbhardwaj/TouchQuest]

The project is built with JavaScript, Vite, Capacitor, Transformers.js, and ONNX Runtime Web.

The repository includes the app interface, recommendation logic, local progress storage, model integration, and built-in mission alternatives.

I focused on making the experience usable even when AI inference fails. A recommendation app shouldn't become useless just because a model cannot load or produce valid output.

How I Built It

The most interesting engineering decision was making local AI part of the experience without making the entire application dependent on it.

1. Open-weight AI running on-device

TouchQuest integrates SmolLM2-135M-Instruct, an open-weight language model, through Transformers.js and ONNX Runtime Web.

The intended inference flow is:

The user selects their preferences.
TouchQuest creates a compact prompt from those preferences.
The model attempts to generate a structured mission locally.
The app validates the response before displaying it.
If the output is malformed or inference fails, the app uses a built-in recommendation.

This validation step matters. During development, I encountered model responses that contained conversational introductions or malformed JSON instead of a usable mission. Rather than displaying that raw output, I added validation and fallback handling.

2. A recommendation system beyond the model

Not every useful recommendation needs a language model.

TouchQuest also contains curated activities and deterministic recommendation logic. These provide a predictable alternative for different moods, available settings, time limits, and accessibility preferences.

This hybrid approach helps keep the core experience useful even when on-device inference is unavailable.

3. Designed for real-world use

The application includes a distraction-free mission experience, a timer with pause and resume controls, reflection options, local progress tracking, and a growing virtual garden.

I also focused on mobile usability, readable instructions, accessible controls, and a calm visual identity inspired by nature.

4. Built with privacy and reliability in mind

The architecture is designed to keep preferences and progress on the device and avoid sending prompts to a cloud AI service.

The app has been built as an Android APK, and I added automated checks for recommendation logic, AI response validation, and progress tracking.

Local inference still depends on the model loading successfully and the device having sufficient memory. That's an important limitation to test honestly across different Android phones.

Why Does Open Innovation Matter?

For me, open innovation means being able to build something useful without treating intelligence as a service that must always live on someone else's server.

Using an open-weight model made it possible to explore an AI experience where user preferences can be processed locally rather than routinely sent to a remote model API.

It also gave me more control over the inference pipeline, model integration, output validation, and fallback behavior.

That control came with trade-offs. Running a model on a phone introduces memory constraints, compatibility issues, and output-quality challenges. I had to think beyond simply sending a prompt to an API and displaying the response.

Those challenges made the project more interesting.

Open innovation also allowed me to combine model-generated suggestions with deterministic recommendations and ordinary application code. The result is an architecture where AI can enhance the experience without being the only thing keeping it alive.

I think that's an important lesson: open-source AI becomes more useful when we design around its strengths and limitations instead of treating it as magic.

My Agent Session

This section is optional. If you save your Antigravity coding session using DevRelay, add the session link or embed it here using the challenge's supported agent_session tag.

Prize Categories

No partner category claimed in this submission. The project uses an open-weight model and local inference; I have not added an unverified partner integration.

TouchQuest started with a simple question: what if technology helped us reconnect with the world instead of asking for more of our attention?

I built this project to explore that idea, one small mission at a time.

If TouchQuest helps even one person put their phone away, step outside, notice something new, or take a much-needed pause, then it's doing what I built it to do.

Build less screen time. Make more room for life. 🌱

devchallenge #hf26challenge

TouchQuest: An AI That Helps You Put Your Phone Down 🌿

Aashutosh kumar bhardwaj — Sun, 11 Oct 2026 18:15:48 +0000

This document is entered as a response to the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

There are applications available which assist us in keeping track of our habits, in arranging our schedules, and in spending more time on line. Yet what if the aim of an app were to help us reduce the amount of time we spent using it?

That is the concept that underlies TouchQuest.

TouchQuest is an Android app which prioritises offline use and turns the simple notion of taking a break into a personal, real-life mission. Rather than having to scroll through endless recommendations, users are given a single activity that they can actually carry out.

You could be feeling overwhelmed and need five minutes to yourself, or you might be restless and would like to move about a bit; alternatively, you may just want to notice something interesting as part of your usual routine.

TouchQuest assists you in finding a starting point.

Users may select their mood, energy level, the amount of time they have available, their preferred environment, and their accessibility requirements. The app will then try to create a personalised mission by using an open-weight language model that is running on the device itself. If the model is not available or if it gives an invalid response, TouchQuest can offer an alternative that is built into the app.

Actionable steps, a recommended length of time, a reminder when the phone is disconnected, and safety advice are all included in each mission. Users are able to start a timer, carry out their activity, reflect on it, and keep record of their progress using XP, streaks, a developing virtual garden, and their mission history.

The aim is not to keep users engaged with TouchQuest for several hours.

The aim is to get them to identify a single worthwhile activity, take their phones out of the way, and take part in it.

Demo

🎬 Here's TouchQuest in action: [https://youtube.com/shorts/lpF4a4xKiHU?si=rJkPdCTR-wBXR8ZE]

The demonstration features the Android application, its tailored mission sequence, and the way in which users can turn a minor suggestion into an offline, real-world activity.

📱 Try the Android APK: [ https://github.com/aashutoshkumarbhardwaj/TouchQuest/releases/download/V1.0/app-debug.apk ]

The application can function offline once the necessary model files have been made available on the device. The exact behaviour when working offline will depend on the model having been correctly set up and the device being compatible.

Code

💻 GitHub repository: [https://github.com/aashutoshkumarbhardwaj/TouchQuest]

The project uses JavaScript, Vite, Capacitor, Transformers.js, and the ONNX Runtime Web.

The app interface, the recommendation logic, the local progress storage, the model integration, and the built-in mission alternatives are all included in the repository.

I aimed at ensuring that the experience remains usable even if AI inference fails. The recommendation app should not cease to be useful merely because the model is unable to load or generate valid output.

How I Built It

The most interesting engineering choice was to include the local AI as part of the experience while at the same time not making the whole application rely on it.

1. Open-weight AI running on device

TouchQuest includes the SmolLM2-135M-Instruct open-weight language model via the use of Transformers.js and ONNX Runtime Web.

The intended inference flow is:

The user chooses their preferences.

TouchQuest compiles a concise prompt from those preferences.
The model tries to create a structured mission on its own.
The app checks the response before it displays it. If the output is incorrectly formatted or if the inference process fails, the application resorts to a built-in recommendation.

This validation step is important; in the course of development I came across model responses which included conversational openings or malformed JSON instead of a usable mission. Instead of showing that unprocessed output, I introduced validation and fallback handling.

2. A type of recommendation system that goes beyond the model

It is not necessary for every useful recommendation to use a language model.

TouchQuest includes selected activities and uses deterministic recommendation logic. This enables a predictable option depending on one's mood, the available settings, the time limits, and the accessibility preferences.

This method of combining things ensures that the main experience remains useful even if on-device inference is not available.

3. Suitable for use in the real world

The application features a distraction-free mission experience, together with a timer that has controls for pausing and resuming, options for reflection, local tracking of progress, and an ever-growing virtual garden.

I also paid attention to mobile usability, easy-to-read instructions, accessible controls, and a peaceful visual identity drawn from nature.

4. It has been designed with both privacy and reliability in mind

The design of the architecture is such that it retains the user's preferences and progress on the device and does not send the prompts to a cloud AI service.

The application has been developed in the form of an Android APK, and I have included automated checks for the recommendation logic, AI response validation, and progress tracking.

The use of local inference still requires the model to load successfully and there to be enough memory on the device. It is important therefore to honestly carry out testing of this limitation on different Android phones.

Why is open innovation important?

What I understand by open innovation is that it is possible to create something useful without viewing intelligence as a service that has to be hosted on someone else's server.

The use of an open-weight model enabled an AI experience in which user preferences could be processed locally rather than being sent routinely to a remote model API.

It also allowed me to have greater control over the inference pipeline, model integration, output validation, and fallback behaviour.

There were disadvantages attached to that level of control. Using a model on a phone brings about memory limitations, compatibility problems, and difficulties regarding the quality of the output. I therefore had to consider going beyond just sending a prompt to an API and then displaying the response.

The challenges meant that the project became more interesting.

I was able to use open innovation to combine the suggestions generated by the model with the deterministic recommendations and the standard application code. The outcome is an architecture in which AI can improve the experience without being the only component responsible for keeping it running.

That's a important point: open-source AI becomes more useful when we take into account its strengths and limitations rather than viewing it as something magical.

My Agent Session

The section mentioned here is optional; if you use DevRelay to save your Antigravity coding session then you should include the session link or embed it here by means of the challenge's available agent_session tag.

Prize Categories

This submission does not include any partner category. The project makes use of an open-weight model and carries out local inference; I have not included an unverified partner integration.

TouchQuest began with a simple question: what if technology could help us to reestablish contact with the world rather than demanding more of our attention?

I created this project in order to look into that idea, taking one small mission at a time.

If just one person uses TouchQuest to put their phone down, to step outside and notice something new, or to take a much-needed break, then the programme is achieving the purpose for which I created it.

Reduce the amount of time spent on screens and create more space for real life. 🌱

devchallenge #hf26challenge