DEV Community: Kunal Badgujar

SARAS AI: Stop Studying Twice — Learn Once, Recall Better

Kunal Badgujar — Sat, 24 Oct 2026 13:11:55 +0000

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

SARAS AI — Learn. Recall. Understand.

What if finishing a lecture didn't mean spending another hour preparing to revise it?

Students often watch an educational video, then switch between tools to write notes, create flashcards, draw diagrams, and prepare questions. The actual learning can get buried under the work required to organize it.

I built SARAS AI to tackle that problem.

What I Built

SARAS AI is an AI-powered learning workspace designed to transform passive video watching into structured, active learning. It brings learning resources and revision tools together so students can spend less time preparing to study and more time understanding what they learn.

Key features

Smart Video Ingestion: Organize educational YouTube lectures into structured learning chapters.
Checkpoint Quiz Gating: Test your understanding before progressing through a lesson.
Smart Notes: Turn lesson content into organized notes, definitions, examples, and summaries.
Flashcards and Active Recall: Practice remembering concepts instead of repeatedly rereading them.
Mind Maps and Flowcharts: Visualize relationships between ideas and break down complex processes.
Interactive Knowledge Graph: Explore connections between topics and their prerequisites.
Socratic AI Tutor: Get guidance that supports your learning process.
Exam Planner: Organize revision around upcoming exams and available study time.

The central idea is simple: automate repetitive preparation without automating away the learning itself.

Try the Demo

🚀 Live demo: https://sarasai.vercel.app

Explore the interface and see how SARAS AI brings lesson content, quizzes, notes, and revision tools into one learning workspace.

Explore the Code

💻 GitHub repository: https://github.com/badgujarkunal93-blip/sarasai

SARAS AI is an open-source project. The repository contains the source code, technical documentation, setup instructions, and AI integration architecture.

Tech stack: Next.js, TypeScript, Tailwind CSS, Mermaid.js, Prisma ORM, and a modular AI integration layer.

How I Built It

I approached SARAS AI as a learning workflow rather than another general-purpose chatbot.

The application is organized around a sequence: ingest educational content, structure it into chapters, support understanding with learning resources, and help students revise through active recall.

The AI integration layer is designed to support tasks such as:

Transcript segmentation and chapter organization
Chapter-based quiz generation
Smart notes and flashcards
Mind map and flowchart generation
Image-based learning assistance
Concept extraction and tutor conversations

For visual learning resources, Mermaid.js turns supported diagram definitions into rendered diagrams. The architecture also provides a path for local inference through a compatible model runtime, while a deterministic fallback helps the application demonstrate selected workflows when inference is unavailable.

That separation makes it easier to experiment with different model configurations without redesigning the entire learning experience.

One important distinction: local inference requires a compatible model, runtime, and configuration. The hosted demo should not be mistaken for a fully offline application, and AI-dependent features can vary depending on the active inference configuration.

Why Open Innovation Matters

I believe open innovation matters because developers should have room to understand, adapt, and improve the technology behind the products they build.

For SARAS AI, that flexibility has three important benefits.

1. The freedom to experiment

A modular AI architecture makes it easier to evaluate different open-weight models, experiment with prompts, and adapt structured outputs to educational tasks.

2. A path toward local-first learning

Supporting compatible local inference creates a foundation for exploring learning tools that can run on a student's own machine. With the appropriate model and hardware, this could reduce dependence on hosted inference and offer more control over where processing happens.

3. Building beyond a black box

Open models and adaptable tooling let developers investigate how their systems work, modify their workflows, and build specialized applications around real needs.

For me, the goal is not to add AI just because it is trending. It is to build something useful with an architecture that can evolve as models and tools improve.

The Lazy Payoff

The biggest time-waster isn't always studying. Sometimes, it's preparing to study.

After a programming lecture, a student might spend additional time writing summaries, creating revision questions, drawing process diagrams, and deciding what to review first.

SARAS AI aims to bring those activities into one workspace, giving students a structured starting point for revision instead of making them start from scratch every time.

That doesn't mean removing the effort required to learn. Students still need to solve problems, test their understanding, and apply concepts independently.

I call this productive laziness: letting technology handle repetitive preparation so people can focus on the work that actually builds understanding.

Less busywork. More active learning.

What I Want to Improve Next

SARAS AI is a work in progress, and there is room to make it more useful.

My next priorities are to improve the reliability of AI-generated learning resources, make model configuration clearer, strengthen the local-inference path, and continue refining the learning workflow based on real student feedback.

I also want to make it easier for contributors to understand the architecture and help extend the project.

Final Thoughts

Building SARAS AI has reinforced an idea I care about: useful AI should do more than generate text. It should help people complete meaningful workflows.

For students, that means spending less time organizing learning materials and more time understanding, remembering, and applying what they learn.

For developers, it means keeping the system adaptable enough to experiment, improve, and build on open technology.

SARAS AI — Learn. Recall. Understand.

OpenSourceAI #Hacktoberfest #AI #EdTech

TrailMate AI

Kunal Badgujar — Mon, 12 Oct 2026 12:55:38 +0000

TrailMate AI: Your Offline Nature Companion 🌿

An open-source AI companion that helps people explore nature, identify birds, and spend less time on screens.

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

🌱 What I Built

TrailMate AI is a concept for an AI-powered outdoor companion designed to make nature exploration easier and more engaging.

The idea is simple: instead of spending hours on a phone, people can use AI to discover birds, learn about plants, plan outdoor walks, and document their experiences in nature.

Key features include:

Bird Identification: Identify birds from photographs using an open-source vision model.
Nature Explorer: Learn about plants, trees, and wildlife around you.
Offline-First Experience: Run supported AI models locally so basic features can work without an internet connection.
Trail Journal: Record observations and keep a personal log of outdoor discoveries.
Screen-Time Friendly: Encourage users to explore outdoors rather than remain glued to their devices.

🎬 Demo

This submission describes the proposed concept and workflow. A working demonstration and live deployment are not yet available.

💻 Code

The project is intended to use open-source components, with a lightweight interface and locally runnable AI models.

The proposed implementation would include a responsive web interface, an open-source vision model for wildlife recognition, and local storage for nature observations.

🛠️ How I Would Build It

My proposed technology stack:

Frontend: React and Tailwind CSS
AI: An open-weight vision-language model for image understanding
Local Inference: Ollama or another compatible local inference runtime
Storage: Browser-based local storage
Deployment: Vercel for the web interface

The goal is to keep the architecture modular so users can replace models and adapt the application to their own devices.

🔓 Why Does Open Innovation Matter?

Nature exploration should not depend on a paid API, a constant internet connection, or sending personal photographs to a third-party server.

An open-source approach could let users run supported models locally, inspect how the system works, change the model, and contribute improvements. Local processing can also help protect privacy by keeping observations on the user's device.

Open innovation makes AI more accessible and gives developers the freedom to experiment without depending entirely on a single closed platform.

🤖 My Agent Session

No agent session is attached to this concept submission.

🏆 Prize Categories

Primary theme: Touch Grass

The concept focuses on open-source AI, local inference, privacy, and encouraging real-world outdoor exploration.

🌍 Final Thoughts

AI should not always demand more of our attention. Sometimes, it should help us put our phones away and appreciate the world around us.

TrailMate AI is a concept built around that idea: use open technology to make outdoor discovery more accessible, private, and fun.

Less scrolling. More exploring. More nature. 🌿

StudyMate — Your AI Study Partner for Exam Prep

Kunal Badgujar — Sun, 04 Oct 2026 13:29:49 +0000

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

What I Built

I built StudyMate, an AI study partner designed for a friend who was preparing for engineering finals and struggling with dense technical subjects.

The problem wasn't a lack of study material.

It was knowing what to study, what to practice, and what they actually didn't understand.

StudyMate turns their study material into a complete learning loop:

Notes → Study Guide → AI Quiz → Performance → Weak Topics → Targeted Revision

Instead of simply asking an AI chatbot questions, the student can give StudyMate their own notes and let the system build an exam-focused study session around them.

The experience

Add study material.
Generate an exam-oriented study guide with Gemma.
Take an AI-generated quiz based only on that material.
Get deterministic scoring.
See which topics need more work.
Generate targeted revision for those weak topics.

The goal was simple:

Don't just help my friend study more. Help them study the things they actually need to improve.

Demo

🚀 Live Demo: https://studymate-sable-zeta.vercel.app/

If the hosted AI backend is not available in the deployed demo environment, here's the recorded demo showing the complete working flow:

[Add your demo video link here]

The demo flow is:

Add Material → Generate Study Guide → Generate Quiz → Answer Questions → Identify Weak Topics → Targeted Revision

Code

💻 GitHub: https://github.com/badgujarkunal93-blip/StudyMate

The repository contains the complete frontend, backend, Gemma integration, local storage layer, planning documents, and setup instructions.

How I Built It

The application is built with:

React 19
TypeScript
Vite
Node.js
Express
IndexedDB
localStorage fallback
Google's @google/genai SDK
Gemma 4 — gemma-4-26b-a4b-it

The frontend provides the study experience while the Node/Express backend keeps the AI API credentials away from the browser.

The architecture is:

                    STUDYMATE
                        │
              ┌─────────┴─────────┐
              │                   │
         Study Library        AI Actions
              │                   │
        IndexedDB             Node/Express
              │                   │
              │              @google/genai
              │                   │
              │                Gemma 4
              │                   │
              └─────────┬─────────┘
                        ↓
                Study Guide / Quiz
                        ↓
                 User Performance
                        ↓
                  Weak Topics
                        ↓
                Targeted Revision

Why Gemma?

Gemma is the core AI model behind StudyMate.

I use it for:

Exam-oriented study guide generation
Key concept extraction
Important terminology
AI-generated practice questions
Topic classification
Targeted revision

The quiz itself does not ask an AI model to decide whether the student was correct. Gemma generates the questions and their answer indices, while StudyMate performs the actual scoring deterministically in the browser.

That separation makes the learning loop more predictable.

Why Does Open Innovation Matter?

This was one of the most important decisions in the project.

I didn't want to build another application where the AI layer was just an invisible call to a proprietary chatbot.

The challenge gave me a reason to explore what an open-weight model could make possible.

StudyMate uses Gemma, an open-weight model, as the intelligence behind the core learning workflow.

That matters because the AI isn't just an optional chatbot feature.

It defines how the application works:

Material → Gemma → Learning resources → Quiz → Weakness analysis → Revision

Using an open-weight model also gives the project a much more flexible foundation. The model can be experimented with, swapped, adapted, and integrated into different environments instead of treating the intelligence layer as an untouchable black box.

I also had a practical constraint: my laptop isn't powerful enough to comfortably run a large model locally.

So instead of pretending that local inference was practical, I used hosted Gemma while keeping the student's study library in the browser.

The privacy model is intentionally explicit:

Your study library stays on your device. Material is sent to Gemma only when you request AI assistance.

That was a better fit for the real person I was building for.

What Makes StudyMate Different?

A lot of AI study tools stop here:

Upload notes → Get summary

StudyMate goes further:

YOUR NOTES
    ↓
UNDERSTAND
    ↓
PRACTICE
    ↓
MEASURE
    ↓
FIND WEAKNESS
    ↓
FIX IT

The application doesn't just generate content.

It creates a feedback loop.

If a student repeatedly performs poorly on a topic, that topic becomes part of their weak-topic radar. They can then ask StudyMate to generate focused revision material specifically for that area.

That's the part I wanted my friend to actually use before an exam.

Design

I also wanted StudyMate to feel different from the typical "AI SaaS dashboard."

So I built a retro student app × brutalist UI × modern AI product aesthetic:

Dark charcoal background
Chunky typography
Red accents
Thick borders
Hard offset shadows
Tactile buttons
Responsive mobile navigation

The interface is intentionally bold because studying doesn't need to look like another corporate dashboard.

Building It

I built StudyMate as a completely new project for this challenge.

I used an AI coding workflow with Antigravity and GSD Core to plan and implement the application in phases:

Phase 1: Design system and application shell

Phase 2: Study material management

Phase 3: Real Gemma integration

Phase 4: AI quiz + weak-topic engine

The GSD workflow helped me keep the project focused instead of turning a weekend challenge into an unnecessarily huge application.

The final application has:

Persistent local study materials
Real Gemma API integration
Structured AI responses
Server-side API key protection
Deterministic quiz scoring
Persistent quiz performance
Weak-topic detection
Targeted AI revision
Responsive mobile/desktop UI

A Small Detail I Care About

The application doesn't pretend that everything is AI.

Gemma handles the parts where generative intelligence is useful.

The application handles deterministic logic itself.

For example:

Gemma:

"What questions should this student practice?"

StudyMate:

"Did they actually answer question 4 correctly?"

That separation makes the system more reliable and easier to reason about.

Prize Categories

I'm entering:

🏆 Best Use of Gemma

StudyMate uses Google's Gemma 4 (gemma-4-26b-a4b-it) as the core AI model for study-guide generation, quiz generation, topic classification, and targeted revision.

I am only claiming this category because Gemma is genuinely central to the application's functionality.

Final Thoughts

I started with a very simple problem:

My friend has plenty of notes. They don't have a good way to turn those notes into effective exam preparation.

That became StudyMate.

It isn't trying to replace a teacher.

It isn't trying to be another general-purpose chatbot.

It's a small AI study partner designed around one person's actual workflow:

Understand → Practice → Measure → Improve.

And that's what made this challenge fun for me.

Thanks for checking out StudyMate! 🚀

Live Demo: https://studymate-sable-zeta.vercel.app/

Source: https://github.com/badgujarkunal93-blip/StudyMate

Hacktoberfest #AI #Gemma #React #TypeScript #DEVChallenge