DEV Community: Ãbhishek

STILL: Less Noise, More Stillness | Building a Local-First AI Assistant with Gemma 3

Ãbhishek — Sat, 24 Oct 2026 18:07:16 +0000

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

What I Built

Meet STILL, a local-first AI assistant that helps you declutter your digital life.

Feed it messy notes, unfinished tasks, or meeting summaries, and let AI organize them into four categories: Act, Keep, Rest, and Archive.

The goal? Spend less time organizing your thoughts and more time on what actually matters.

Demo

Try STILL →

Code

GitHub Repository →

How I Built It

Built with Next.js, TypeScript, Bun, Tailwind CSS, and GSAP, with Gemma 3 running through Ollama for local AI inference.

Gemma 3 analyzes notes, identifies potential priorities, detects overlapping information, and suggests what can wait.

Why Does Open Innovation Matter?

Personal notes can contain sensitive thoughts and unfinished work. Running Gemma 3 locally gives users more control over their data and reduces dependence on paid, proprietary AI APIs.

Open-weight models also let developers experiment with model configurations and build AI tools on their own terms.

The Lazy Payoff

Instead of manually sorting every unfinished thought, let STILL help you find the few things worth your attention.

Not another AI that gives you more work. An AI that helps you do less.

Built for Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

GarageScribe: Bringing Local Open-Source AI to the Neighborhood Mechanic 🔧

Ãbhishek — Sun, 18 Oct 2026 06:21:19 +0000

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

What I Built

GarageScribe is an AI-powered assistant for independent motorcycle repair garages. It transforms mechanic notes into structured job cards, repair estimates, and customer-ready service summaries, helping small workshops save time and manage records efficiently.

Demo

Live Demo

Code

GitHub Repository: GarageScribe

How I Built It

Built with Next.js, TypeScript, MongoDB, Python, FastAPI, and Ollama with an open-weight Gemma model. The goal is to use local AI for structuring mechanic notes while keeping customer data under the workshop's control.

Why Does Open Innovation Matter?

Open-weight models enable local inference, reduce dependency on paid AI APIs, and allow models to be swapped or adapted. GarageScribe is designed to support offline workflows after initial setup and model downloads.

WildSense: An Offline AI Nature Companion That Gets You to Touch Grass

Ãbhishek — Sun, 11 Oct 2026 14:40:23 +0000

WildSense: An Offline AI Nature Companion That Gets You to Touch Grass 🌿

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

What I Built

WildSense is an AI-powered nature companion designed to get people off their screens and into the real world.

We spend so much time staring at screens that we often overlook the world right outside our doors. A walk becomes another opportunity to check notifications, and a park becomes just another place to scroll through our feeds.

I wanted to build something that uses AI to encourage the opposite.

WildSense helps turn an ordinary walk into a small adventure. It generates nature missions that encourage users to slow down, explore their surroundings, and notice things they might otherwise miss.

Here are a few things you can do with WildSense:

🌿 AI-powered nature missions: Generate personalized outdoor challenges based on your available time, surroundings, interests, and difficulty level.
🔎 Explore the little things: Discover activities involving leaves, textures, colours, natural sounds, and the details hiding in plain sight.
🌳 Get outside, not stuck inside the app: Read your mission, put your phone away, and complete the activity in the real world.
📔 Keep a nature journal: Record your observations, discoveries, and reflections so you can revisit your outdoor experiences.
🤖 Local AI with Gemma: Use an open-weight model through Ollama for locally generated missions and reflections when the local model is available.
🔒 Privacy-conscious by design: The goal is to keep personal observations under the user's control and make the core experience useful without depending on a cloud AI API.

Imagine spending ten minutes looking for five different shades of green, listening carefully to the sounds around you, or exploring a tiny patch of ground that you would normally walk straight past.

That's the idea behind WildSense.

The goal isn't to spend more time using the app. It's to discover more reasons to put it away.

Try it out

🌐 Live application: https://wildsense-xx4s.onrender.com/

💻 GitHub repository: https://github.com/abhishek-IITP/wildsense

Code

The project is open source, and you can explore the implementation, inspect the code, and contribute improvements.

GitHub: https://github.com/abhishek-IITP/wildsense

If you find the idea interesting, feel free to explore the repository, suggest improvements, or contribute a new way to make outdoor exploration more engaging.

How I Built It

WildSense combines a modern web experience with open-weight AI and an offline-first product philosophy.

The technology behind it

Gemma 3 4B: The open-weight language model used for generating nature missions and reflections.
Ollama: Runs the model locally and provides the inference interface.
React / Next.js: Provides the application experience and its interactive frontend, depending on the deployed project configuration.
TypeScript: Helps structure the application's data models and application logic.
MongoDB: Provides a database option for persistent server-side records and synchronization.
Tailwind CSS: Supports the responsive, nature-inspired visual design.

How the AI fits into the experience

The AI isn't intended to be another chatbot that users spend hours talking to.

Instead, it helps prepare a small, actionable outdoor experience.

A user can choose how much time they have, what kind of environment they plan to explore, and what interests them. The AI can then generate a mission with practical steps and a curiosity prompt.

For example:

Mission: The Shape Collector

Duration: 10 minutes

Find three leaves with noticeably different outlines.
Compare their edges, textures, and colours.
Choose one detail you hadn't noticed before.
Leave everything where you found it.

After completing the mission, the user can record what they observed and receive an optional AI-generated reflection.

The important distinction is that the AI helps create the experience, but the experience itself happens outside the application.

Designing for offline use

I wanted local AI to be a meaningful part of the architecture rather than simply connecting another API to a frontend.

Using Gemma through Ollama makes local inference possible without sending every prompt to a hosted language-model provider.

The application is designed around the idea that core activities should remain useful even when AI or network connectivity is unavailable. Built-in missions and local persistence can provide a fallback when the local model or server is unavailable.

One important distinction: local inference, offline application access, and database synchronization are separate capabilities. A complete offline experience requires the frontend assets and local storage to be available on the device, while remote synchronization naturally requires connectivity.

Why Does Open Innovation Matter?

For WildSense, open innovation is about control, accessibility, and building AI that serves people rather than capturing their attention.

1. Local inference makes a different experience possible

A conventional application built entirely around a hosted AI API depends on network connectivity and an external inference service.

With an open-weight model such as Gemma running through Ollama, local inference becomes possible. Users and developers can experiment with AI-generated missions without requiring a paid cloud-model API for every request.

2. Privacy matters when the experience is personal

A nature journal can contain personal observations, thoughts, and reflections.

A local-first architecture makes it possible to keep those records on the user's device by default rather than automatically sending everything to a remote service.

This is an architectural goal, not a claim that every deployment is automatically private. Any remote synchronization or external service must be configured and communicated clearly.

3. Developers can experiment and adapt

Open-weight models give developers greater flexibility to experiment with prompts, swap compatible models, evaluate different behaviours, and adapt the application to their needs.

That matters for WildSense because the model should produce safe, practical outdoor activities rather than generic chatbot responses.

4. AI doesn't have to mean more screen time

Perhaps the most important reason is philosophical.

Many AI products are designed to maximize the amount of time users spend interacting with them. WildSense explores a different direction: use AI to create a reason to leave the screen.

Generate a mission. Go outside. Notice something new. Return when you're ready.

The best AI interaction might be the one that gives you a reason to stop interacting with AI for a while.

That's the kind of open innovation I wanted to explore with this project.

My Agent Session

I don't have a DevRelay session link to include yet. If you have a saved session, you can embed it here using the agent_session tag specified in the challenge instructions, or link directly to the session.

Prize Categories

WildSense is submitted for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

The project aligns with the challenge's focus on open-weight AI and applications that encourage people to spend more time outdoors.

I'll leave additional partner prize categories out unless the project meets their specific eligibility requirements.

Thanks for checking out WildSense! 🌱

If you try it, I'd love to hear what kind of nature mission you would complete first.

Live: https://wildsense-xx4s.onrender.com/

Source code: https://github.com/abhishek-IITP/wildsense

Sometimes the best thing technology can do is remind us to look up.

Saarthi: A Local AI Companion That Remembers What Matters

Ãbhishek — Sun, 04 Oct 2026 20:49:32 +0000

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

What I Built

I built Saarthi, a local AI companion that remembers what matters to you and uses that context to help you decide what to do next.

I built it for a close friend who often has a lot going on at the same time: exams, projects, personal goals, things they want to learn, and deadlines they don't want to forget.

The problem wasn't that they needed another chatbot.

They needed something that actually understood their context.

With Saarthi, they can naturally tell it things like:

"I have my DBMS exam on Friday and normalization is really confusing me."

Instead of simply replying to that message, Saarthi can understand that:

There is an upcoming DBMS exam.
Normalization is a weak area.
The exam should probably become a high-priority task.

The user gets to decide whether Saarthi should remember that information.

Once remembered, MongoDB becomes Saarthi's long-term memory.

Later, asking:

"What should I focus on today?"

can produce a personalized answer based on those memories.

Saarthi can also:

Identify useful information from natural conversations
Ask before permanently remembering inferred information
Track goals, weaknesses, preferences and upcoming events
Detect when something changes
Update existing memories instead of creating duplicates
Show why a particular recommendation was made
Generate a personalized plan for the day
Show the context that influenced an AI response
Visualize the user's context through a timeline and context graph

The idea is simple:

Saarthi doesn't just remember what you said. It uses what it remembers to understand what matters next.

Demo

Live Demo: https://saarthi-gb4r.onrender.com/

One of the main things I demonstrate in the video is Saarthi running with the internet disconnected.

The flow is:

Tell Saarthi something
        ↓
Gemma understands it
        ↓
User approves the memory
        ↓
MongoDB stores it
        ↓
Saarthi uses that context later
        ↓
Gemma provides a personalized recommendation

Code

GitHub: https://github.com/Abhishek-IITP/Saarthi

The project is built around a deliberately simple architecture:

Next.js
   │
   ├── MongoDB
   │      └── Personal Context / Memories
   │
   └── Ollama
          └── Gemma

There is no complicated microservice architecture behind the prototype.

The goal was to keep the product small while making the AI behavior meaningful.

How I Built It

The core of Saarthi is Gemma running locally through Ollama.

When a user sends a message, Saarthi can pass it to Gemma to identify useful information that could become part of the user's long-term context.

For example:

"I have my DBMS exam on Friday and
normalization is really confusing me."

can become structured context such as:

DBMS exam → Friday
Normalization → Weakness

The user can then approve or reject what should be remembered.

MongoDB stores that context along with information such as:

category
importance
confidence
source
status
createdAt
updatedAt

This lets Saarthi distinguish between something the user explicitly said and something the AI inferred.

When the user asks a question, relevant context is retrieved from MongoDB and provided to Gemma.

For example:

User:
"What should I focus on today?"

        ↓

MongoDB

DBMS exam → Friday
Normalization → Weakness
Placement preparation → Goal
Night study → Preference

        ↓

Gemma

        ↓

Personalized recommendation

I also added a "Why this?" interaction so Saarthi can show which memories influenced its recommendation.

For example:

Why this?

• Your DBMS exam is Friday
• You identified normalization as difficult
• You prefer studying at night

This makes the connection between memory and AI reasoning visible instead of hiding it behind a black box.

Another part I wanted to explore was changing context.

If a user initially says:

"My project submission is tomorrow."

and later says:

"My project submission is finally done."

Saarthi shouldn't create two unrelated memories.

It should understand that the existing event has changed:

Project submission

Upcoming
    ↓
Completed

That allows the assistant's priorities to change as the user's situation changes.

The main technologies are:

Next.js for the application
TypeScript for the implementation
MongoDB for persistent personal context
Gemma for local AI reasoning and memory extraction
Ollama for running Gemma locally
Tailwind CSS for the interface
Framer Motion for subtle interactions

I intentionally avoided adding a large agent framework or complicated infrastructure.

The interesting part of the project is the interaction between memory, context and local AI, not the number of technologies used.

Why Does Open Innovation Matter?

Personal context is exactly the kind of information I don't want to blindly send to a third-party AI provider.

Saarthi uses Gemma locally through Ollama, which means the AI inference can happen directly on the user's machine.

That gives the user more control.

They can:

Run the model locally
Use Saarthi without an internet connection
Change the model
Modify the prompts
Change how memories are extracted
Change how the assistant prioritizes information
Experiment with the AI behavior without depending on a proprietary API

The open approach also changed what I could build.

With a closed API, I could have made:

Question → API → Answer

Instead, I could build the AI into the actual product behavior:

Conversation
     ↓
Memory extraction
     ↓
User approval
     ↓
Persistent context
     ↓
Context updates
     ↓
Prioritization
     ↓
Planning
     ↓
Personalized answer

Gemma isn't just being used to generate text.

It is part of the application's memory and reasoning system.

That's what made open innovation particularly useful for Saarthi.

And the most satisfying part is being able to turn off the internet and still have the core AI experience work.

Prize Categories

Build for a Friend
Open-source AI / Open-weight AI

Saarthi was built specifically around a real person's needs rather than as a generic AI demo.

The project also relies on locally running open-weight AI through Gemma and Ollama as a core part of its functionality.