DEV Community: Ch Umamaheshwar

NoteNest AI 📚: A Local AI Study Assistant | Hacktoberfest 2026

Ch Umamaheshwar — Mon, 26 Oct 2026 05:26:49 +0000

What I Built

As a student, I know how time-consuming it can be to go through long class notes, identify the important concepts, and prepare for revision.

That's why I built NoteNest AI — a simple, locally running AI study assistant that helps students turn their notes into more manageable study materials.

Instead of manually going through every paragraph, the idea is to let an AI model help with the preparation so students can spend more time actually learning.

What can NoteNest AI do?

📝 Summarize notes: Turn long notes into shorter, easier-to-review content.
💡 Extract key concepts: Identify important ideas from your study material.
🃏 Create flashcards: Prepare question-and-answer cards for revision.
🧠 Generate practice quizzes: Create quiz questions from your notes.
💾 Save study materials: Keep notes and generated content in your browser using local storage.
🔒 Run AI locally: Use Ollama with an open-weight Gemma model instead of relying on a hosted AI API.

The goal is to make studying a little easier without adding another complicated tool to a student's workflow.

Demo

🔗 Project Demo / Repository: NoteNest AI on GitHub

NoteNest AI is designed to run locally on your computer. You can find the source code and setup instructions in the repository's README.

To try the app, you need Python, the required Python packages, Ollama, and the configured Gemma model.

Note: This link opens the GitHub repository, not a hosted live demo.

Code

💻 GitHub Repository:

https://github.com/Maheshwar247/NestNote-AI

The repository contains the application code and instructions for setting up and running the project locally.

How I Built It

I wanted to keep the project manageable while learning how a web application can connect to a local AI model.

Here is the technology stack I used:

Python and Flask: The backend that handles requests from the web interface.
HTML and CSS: The structure and styling of the application.
Vanilla JavaScript: Handles user interactions and communicates with the backend.
Ollama: Runs the AI model locally.
Gemma 2: The open-weight language model configured for generating study content.
Browser local storage: Saves notes and study materials in the user's browser.

The basic workflow is straightforward:

A student enters or pastes their class notes.
The frontend sends a request to the Flask backend.
Flask communicates with the local Ollama API.
The model generates the requested study content.
The application displays the result, which can be saved for later revision.

I also used Antigravity to help build the initial application and worked through setup and debugging while testing it locally. This gave me an opportunity to learn more about connecting a frontend, a Python backend, and a local AI model.

Why Does Open Innovation Matter?

For me, the biggest advantage of open-source AI is control.

Using a local model means the application can send prompts to a model running on the user's own computer instead of depending on a third-party hosted AI service.

That offers a few important benefits:

More control over data: Study notes can be processed locally rather than automatically sent to an external AI provider.
Greater flexibility: Developers can experiment with different supported models and adjust their applications.
Less dependence on paid APIs: Local inference can avoid per-request API charges, although running a model still uses hardware and electricity.
A better learning experience for developers: Building with open models makes it easier to explore how AI applications work beyond simply calling a hosted service.

Local AI isn't without trade-offs. Model performance depends on the available hardware, and setup can take some effort. Still, I think having the option to run AI locally is valuable, especially for small, practical tools like this one.

My Agent Session (Optional)

I used Antigravity to help build the initial version of NoteNest AI and assist with development.

I haven't included a public agent-session link in this submission.

The Lazy Payoff (Optional)

The idea behind NoteNest AI is simple: spend less time preparing to study and more time studying.

Instead of manually shortening every section of your notes or writing every revision question yourself, you can use AI to help prepare study materials in one place.

It's a small step toward making everyday student tasks less repetitive.

Prize Categories (Optional)

Best Use of Gemma: This project is intended to use the Gemma 2 model through Ollama for local AI-powered study assistance.

Final Thoughts

NoteNest AI is one of my attempts to explore how open-source AI can solve a practical problem without making the application unnecessarily complicated.

I'm still learning, and building this project helped me understand more about Flask, frontend-backend communication, local AI inference, and the challenges of testing AI-powered features.

I'd love to keep improving it and make it more useful for students who want a simpler way to revise their notes.

Thanks for checking out NoteNest AI! 📚

devchallenge #hf26challenge

🌱 Meet MarketMint: A Local AI Marketing Assistant for Small Businesses | Hacktoberfest Week 2

Ch Umamaheshwar — Sun, 18 Oct 2026 15:50:48 +0000

🌱 MarketMint — Your Local AI Marketing Assistant for Small Businesses

What if small businesses could create marketing content with open-weight AI, without paying for a cloud AI API for every generation?

That question inspired MarketMint, a lightweight AI-powered web application designed to help small business owners, freelancers, and online sellers create marketing content more easily.

Built for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle, MarketMint explores how open-weight AI can solve a practical, everyday problem.

📸 Meet MarketMint

✨ What Can MarketMint Do?

Creating marketing content from scratch can be time-consuming, especially when you're running a business on your own. MarketMint brings a few common marketing tasks into one simple interface.

🛍️ Product descriptions: Generate clear, engaging descriptions for your products.
💬 WhatsApp promotions: Draft promotional messages to share with customers.
📱 Social media captions: Create caption ideas for platforms like Instagram and Facebook.
🎨 Tone and language controls: Adapt the generated content to your audience.
📋 Copy-ready results: Copy, review, and customize your content before publishing.

The goal is simple: spend less time staring at a blank page and more time focusing on your business.

🧠 Open-Weight AI at the Core

MarketMint isn't just a regular web app with an AI feature added as an afterthought. AI-powered content generation is the core of the application.

Here's what powers it:

Gemma 2B (gemma2:2b): The open-weight language model used to generate marketing content.
Ollama: Runs the model locally on the user's computer.
Python and Flask: Handle the backend and application logic.
HTML, CSS, and JavaScript: Power the user interface.

Instead of sending every generation request to a paid, cloud-hosted AI API, MarketMint uses Ollama to communicate with the locally running model.

Why does that matter?

More control: Users can run inference on their own computer.
Cost flexibility: Local generation avoids per-request charges from a paid cloud AI API, although hardware and electricity still have costs.
Room to experiment: Developers can explore compatible models and customize the application.
A practical use for open AI: Small businesses can experiment with AI-assisted marketing without necessarily paying for a cloud AI subscription.

Once the model is downloaded, local inference can work without an internet connection, provided the app and model are available locally. As with any AI tool, generated content can contain mistakes, so users should review it before publishing.

For me, open innovation means being able to experiment with the technology behind an application and build something useful with it.

💼 The Side-Hustle Opportunity

MarketMint is designed with people in mind who may not have a dedicated marketing team or a large budget.

Potential users include:

Local shop owners promoting their products
Freelancers marketing their services
Online sellers writing product listings
Small businesses that regularly need promotional content

A future version could include reusable brand profiles, niche-specific marketing templates, and more language options. It could also evolve into an affordable tool for a specific business category.

This is a potential business direction I would like to explore and validate with real users — not a claim that MarketMint already has paying customers.

🛠️ Built With

Technology	Purpose
Python	Application logic
Flask	Web backend
HTML, CSS, JavaScript	Frontend
Ollama	Local model runtime
Gemma 2B	AI content generation

🚀 Explore the Project

Want to check out the code or run MarketMint yourself?

👉 GitHub Repository: https://github.com/Maheshwar247/Market-Mint

The repository includes the application source code, requirements.txt, and setup instructions in the README.

To run it locally, you'll need Python, the project's required packages, Ollama, and the gemma2:2b model.

If you try it, I'd love to hear what works well and what you think could be improved!

📚 What I Learned

Building MarketMint gave me the opportunity to bring together a Python web application, a browser-based interface, and a locally running language model.

More importantly, it helped me think about AI in terms of the problem it solves rather than the technology alone.

I learned that a useful AI project doesn't necessarily need a complicated architecture. Sometimes, a focused application that makes a repetitive task easier is a great place to start.

🔮 What's Next?

Some improvements I'd like to explore:

More language and tone options
Reusable brand details and writing preferences
More specialized templates for different businesses
Better customization of generated content
Feedback from real users to guide future development

🙌 Final Thoughts

MarketMint started with a simple idea: make AI-assisted marketing more approachable for people who don't have a dedicated team or a large budget.

By combining a local open-weight model with a straightforward web interface, this project is my attempt to turn that idea into something practical.

It's a work in progress, and there's plenty more to learn and improve. I'm excited to keep building, experimenting, and exploring what open-source AI makes possible.

Thanks for checking out MarketMint! 🌱

Built for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

devchallenge #hf26challenge #hacktoberfest #opensource #gemma

🌿 TrailBuddy AI: Turning Open-Source AI Into Real-World Adventures

Ch Umamaheshwar — Mon, 12 Oct 2026 03:57:34 +0000

🌿 TrailBuddy AI — Plan Your Adventure, Then Put Your Phone Away

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

What I Built

🌱 TrailBuddy AI is a local-first AI outdoor adventure companion that helps people spend less time staring at screens and more time exploring the real world.

The idea behind this project is simple: technology should help us experience the world, not keep us glued to our screens.

TrailBuddy AI lets users create personalized outdoor micro-adventures based on their available time, environment, preferred activity, and mood. Instead of endlessly scrolling to decide what to do, users can generate a plan, head outside, complete their missions, and enjoy some screen-free time.

🌳 Key Features

🧭 Personalized Adventure Planner: Choose from 10, 20, 30, or 60 minutes and select an environment, activity, and mood.
🎯 AI-Generated Nature Missions: Uses the Gemma 2 model to generate achievable outdoor challenges tailored to your preferences.
📵 Go Outside Mode: Includes a countdown and a reminder to leave the screen behind and enjoy the adventure.
✅ Mission Tracking: Check off your completed missions after returning from your outing.
📋 Local Adventure History: Saves completed adventures in your browser using localStorage, without requiring an account or cloud database.
🛡️ Safety-Focused Prompts: Encourages responsible outdoor exploration, avoiding dangerous activities, trespassing, approaching wildlife, and touching unknown plants.

TrailBuddy AI is built for students, nature lovers, beginners, and anyone who wants to turn a little free time into a meaningful outdoor experience.

The goal isn't to keep users engaged with the app. It's to help them plan something worthwhile, put their phones away, and actually do it.

Demo

🌿 GitHub Repository: https://github.com/Maheshwar247/Trailbuddy-AI

TrailBuddy AI is designed to run locally on your computer. Follow the setup instructions in the repository to install the dependencies, configure Ollama, and start the application.

The repository also contains screenshots of the application interface and its adventure-planning experience.

Code

💻 Explore the source code: https://github.com/Maheshwar247/Trailbuddy-AI

The project is open source under the MIT License.

Feel free to explore the code, try it locally, suggest improvements, or contribute ideas that make outdoor adventures more accessible and enjoyable.

How I Built It

I built TrailBuddy AI using a simple frontend-and-backend architecture with local AI inference.

🛠️ Tech Stack

Python + Flask: Backend and communication with the local AI model.
TypeScript: Application logic, compiled into browser-compatible JavaScript.
HTML5 + CSS3: Responsive, nature-inspired user interface.
Ollama: Runs the AI model locally on the user's computer.
Gemma 2 (gemma2:9b): The open-weight language model used to generate personalized outdoor missions.
Browser localStorage: Stores completed adventures locally.

⚙️ How It Works

The user selects their available time, environment, activity, and mood.
The frontend sends the adventure preferences to the Flask backend.
The backend communicates with the locally running Gemma 2 model through Ollama.
The generated missions are presented in the interface for the user to follow.
The user heads outside, completes the adventure, and can mark missions as completed when they return.

One of my main goals was to make AI a meaningful part of the application rather than simply adding an AI button. The model helps create the adventure itself, while the rest of the app encourages users to spend less time interacting with their devices.

Why Does Open Innovation Matter?

Open innovation matters because developers should have the freedom to understand, experiment with, and adapt the tools they build with.

For TrailBuddy AI, using an open-weight model through Ollama makes local inference possible without depending on a paid, hosted AI API.

This brings several advantages:

Privacy and control: With the default local setup, adventure preferences are processed on the user's own machine rather than sent to a hosted AI inference service.
Accessibility: Users can experiment without needing a paid AI API key.
Flexibility: The model can be changed through configuration to try other compatible models supported by Ollama.
Learning: Building with an open-weight model helped me explore how an AI model can connect to a real application through a backend.
Community collaboration: Other developers can improve the prompts, interface, accessibility, and safety features.

For me, this project demonstrates how open-source AI can be used to build something practical while keeping the user in control.

The most important part is that the technology supports an offline activity instead of encouraging endless screen time.

My Agent Session

I don't have a DevRelay session link to include in this submission yet. If I record and publish one, I'll add it here.

Prize Categories

My primary focus is the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

TrailBuddy AI combines an open-weight AI model, local inference, and a practical goal: encouraging people to step away from their screens and spend more time outdoors.

🌿 Plan the adventure. Put your phone away. Go explore.

I'd love to hear your feedback and suggestions for making TrailBuddy AI better!

Hydrate Water Tracker

Ch Umamaheshwar — Mon, 05 Oct 2026 04:40:03 +0000

💧 Hydrate Water Tracker

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

What I Built

I built Hydrate Water Tracker, a simple web application designed to help my friend remember to drink enough water throughout the day.

The idea came from a very simple problem: when you're busy studying, working, or spending hours at your computer, it's surprisingly easy to forget to drink water.

Hydrate keeps the experience simple. You can:

💧 Track how many glasses of water you've had today
🎯 Set and track a daily hydration goal
➕ Add a glass whenever you drink water
➖ Remove a glass if you accidentally add one
🔄 Automatically reset your daily count
⏰ Enable customizable water-drinking reminders
🎉 Get a celebration when you reach your daily goal

The goal was to make something that takes only a few seconds to use rather than creating another complicated health-tracking app.

Demo

🌐 Live Demo: https://maheshwar247.github.io/hydrate-water-tracker/

Code

💻 GitHub Repository:
https://github.com/Maheshwar247/hydrate-water-tracker

How I Built It

The most important part of this project is how it was built.

For this challenge, I wanted to experiment with building an application primarily through an open-source AI model rather than relying on a closed AI API.

I used Hermes as my AI coding agent, powered by the Qwen3.5:4B open-weight model running locally.

The development process involved giving Hermes the project requirements, iterating on the application, testing the results, identifying issues, and asking the agent to improve the implementation.

The application itself is a lightweight web app built with:

HTML
CSS
JavaScript
Qwen3.5:4B
Hermes

I chose a relatively small model because I wanted to see how capable an open model could be for building a complete, useful application rather than simply using the largest available model.

Why Does Open Innovation Matter?

This project is a good example of why open models matter.

As a student, being able to run an open model locally means I can experiment with AI-assisted development without depending entirely on a proprietary API or paying for every interaction.

Using Qwen3.5:4B through Hermes also gave me the opportunity to actually work with an open model as part of my development workflow.

The project wasn't about asking AI to generate one piece of code and calling it finished. It was about using an open model as an interactive development partner — giving it requirements, reviewing what it produced, testing the application, and iterating on the result.

Open models make this kind of experimentation much more accessible to students and independent developers.

What I Learned

Building Hydrate Water Tracker taught me that a small idea can still become a useful project when you focus on solving a real problem.

More importantly, this was my first opportunity to seriously experiment with open models as part of the software development process.

Using Hermes with Qwen3.5:4B helped me understand how an AI agent can be used not just for answering coding questions, but for iterating on an entire application.

I'm still learning and improving my development skills, so this project was also an experiment in understanding where an open model can help, where I still need to make the decisions myself, and how much can actually be built with a relatively small open model.