DEV Community: Akshay Chandra

Garden Mind AI

Akshay Chandra — Mon, 12 Oct 2026 06:00:55 +0000

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

What I Built

As a computer science student, I spend most of my days glued to monitors, terminal windows, and code editors. A few months ago, I started keeping houseplants in my room to bring some life to my workspace. But I quickly realized that keeping plants alive is surprisingly stressful when you are just starting out:

Inconsistent care schedules: Every plant has its own rhythm. My Monstera wants deep watering every week, while my Snake Plant (Sansevieria) barely needs water once every three weeks. Remembering what needs water, misting, or fertilizer becomes mental clutter.
Ambiguous plant health issues: The moment a leaf turns yellow or develops brown spots, you find yourself frantically searching online forums. Most commercial diagnostic apps either lock advice behind aggressive paywalls or immediately suggest chemical pesticides and synthetic sprays without explaining the real cause.
Scattered observations: Photos of new leaf unfurls, repotting dates, and pest treatments end up lost in the camera roll.

I built GardenMind AI to solve these problems. It is an intelligent, botanical-first web application designed to help people care for living greenery, understand early foliar stress signals, and cultivate a daily habit of stepping away from screens to connect with nature.

Figure 1: The Garden Overview dashboard showing botanical metrics, urgent attention alerts, and today's care checklist.

Connecting to "Touch Grass"

The goal of GardenMind AI is not to keep you staring at another app. It is designed to get you away from your desk. The application acts as a quiet companion that prompts you to check on your living plants, feel the soil with your fingers to test moisture, inspect the undersides of leaves, and record physical growth milestones.

Whether you have a single pothos on your desk or an urban balcony terrace, GardenMind AI encourages mindful, hands-on gardening:

My Garden (Collection Management): Catalog indoor and outdoor specimens with custom nicknames, botanical species, room locations, and care statuses (Looking healthy, Needs attention, Care info needed).
Plant Doctor AI (Vision Diagnostics): Upload leaf photos to receive on-device computer vision assessments that identify possible pathologies while strictly prioritizing non-chemical cultural remedies (airflow, bottom-watering, sanitized pruning).
Smart Care Planner: An interactive routine engine with recurring tasks (watering, fertilizing, misting, rotating) that automatically schedules forward when you check off an action.
Growth Journal: A timeline archive where you document physical milestones, upload photo progress strips, and track quantitative growth metrics (like leaf height and new fenestrations).

Figure 2: The My Garden collection view displaying individual botanical profiles, environmental tags, and watering rhythms.

Demo

Live Frontend Demo: https://akshay118r.github.io/Garden-Mind-AI/

The frontend is deployed live on GitHub Pages as a fully interactive Single Page Application. You can explore the pre-seeded botanical collection, test the Care Planner, browse the Growth Journal, and inspect the Plant Doctor workflow directly in your browser.

Note on Backend & Full Local Experience:

The static GitHub Pages deployment operates client-side with a pre-seeded in-memory catalog. To run the full stack with the local ONNX vision inference engine and persistent SQLite disk storage, you can easily spin it up locally in about two minutes using the commands below.

Code

The complete source code is public and open-source under the MIT License:

GitHub Repository: https://github.com/akshay118R/Garden-Mind-AI

Figure 3: The public GardenMind AI repository on GitHub showing the full-stack codebase, MIT license, and documentation.

Running the Project Locally

1. Clone the repository

git clone https://github.com/akshay118R/Garden-Mind-AI.git
cd Garden-Mind-AI

2. Start the FastAPI Python Backend

cd backend
python -m venv .venv

# On Windows:
.\.venv\Scripts\activate
# On macOS / Linux:
# source .venv/bin/activate

pip install -r requirements.txt
uvicorn app.main:app --host 127.0.0.1 --port 8000

The backend API will be live at http://127.0.0.1:8000, with interactive OpenAPI Swagger docs at http://127.0.0.1:8000/docs.

3. Start the React Vite Frontend

In a second terminal window at the project root:

npm install
npm run dev -- --host 127.0.0.1 --port 5173

Open http://127.0.0.1:5173 to interact with the full application.

How I Built It

I designed GardenMind AI as a clean, decoupled full-stack architecture focused on speed, privacy, and botanical accuracy:

Figure 4: The Plant Doctor AI interface where gardeners upload foliage photos and provide optional context to receive structured evaluations.

1. Technology Stack

Frontend: React 18, TypeScript, Vite, Tailwind CSS, Lucide React icons. Built with an organic botanical design system featuring sage greens, warm ivories, and forest tones.
Backend API: Python 3.11/3.14, FastAPI, Uvicorn, Pydantic v2 schemas. Provides RESTful endpoints under /api/v1 for plants, tasks, journals, uploads, and AI diagnostics.
Database & Persistence: SQLite via SQLAlchemy 2.0 ORM. Uses foreign-key relational integrity, safe archiving deletion policies, and multipart file upload management with image decompression bomb validation.
Computer Vision AI Engine: onnxruntime executing a quantized MobileNetV2 classifier locally on the CPU.

2. How the AI Works: Local ONNX Vision Inference

Rather than sending personal photos to an expensive third-party closed API for basic image classification, GardenMind AI uses an embedded open-source neural network:

Model Architecture: MobileNetV2 (1.0_224) image classification model (MobileNetV2ForImageClassification).
Checkpoint Source: Open-source ONNX checkpoint fine-tuned on the PlantVillage dataset (38 crop condition classes across 14 agricultural species, CC BY 4.0 Open Access), hosted on Hugging Face (onnx-community/mobilenet_v2_1.0_224-plant-disease-identification-ONNX).
Runtime & Latency: Executed locally via Microsoft's onnxruntime C++ engine in Python. Inference takes approximately 25–45 milliseconds on a standard modern CPU without needing a GPU or CUDA drivers.
Preprocessing Pipeline: Input images are normalized using ImageNet channel statistics (mean [0.485, 0.456, 0.406], std [0.229, 0.224, 0.225]), resized to (1, 3, 224, 224) float32 tensors, and evaluated with a numerically stable softmax function.

Figure 5: The Growth Journal archive tracking multi-photo observations, repotting dates, and dimensional growth metrics.

3. Diagnostic Safeguards & Scientific Boundaries

One of the biggest pitfalls in consumer AI health tools is overconfidence. A raw softmax score from a neural network is a mathematical normalization across closed classes, not an empirically calibrated diagnostic truth. I built strict engineering guardrails into GardenMind AI:

Heuristic Confidence Tiers:
- Softmax $\ge 0.70 \to$ High alignment (candidate_identified)
- $0.45 \le \text{Softmax} < 0.70 \to$ Moderate alignment (candidate_identified)
- $0.30 \le \text{Softmax} < 0.45 \to$ Low alignment (inconclusive)
- Softmax $< 0.30 \to$ Uncertain (inconclusive)
Honest Inconclusive Reporting: If a photo is blurry, unidentifiable, or outside the training distribution, the model transparently states that the symptoms are inconclusive rather than inventing a hallucinated diagnosis.
Conservative Cultural Care Only: Suggested remedies are strictly non-chemical (isolating the pot, enhancing airflow, bottom-watering, pruning damaged leaves with sanitized shears). The system explicitly forbids chemical pesticide dosages.
Physical Limitation Disclosure: Every report clarifies that a 2D photograph cannot detect subterranean root rot, soil pH imbalances, or microscopic soil pests.

4. Automated Testing & Verification

Reliability matters when managing data and model inference:

Backend: 31 Pytest unit and integration tests covering CRUD operations, safe deletion policies, and error handling.
End-to-End Persistence: 16 live HTTP verification checks confirming disk write integrity and server reboot data retention.
AI Inference Checks: 5 live verification tests confirming ONNX execution speed and schema conformity.
Frontend: 101 automated TypeScript assertions across 3 test suites verifying care scheduling recurrence, journal filters, and doctor workflow logic.

Why Does Open Innovation Matter?

Working on GardenMind AI reinforced why open source and open-weight models are vital for the future of technology:

True Privacy and Local Ownership: When someone takes pictures inside their living room or garden, those photos shouldn't have to leave their device. By using a lightweight, open-weight ONNX model running locally on the CPU, GardenMind AI proves that practical AI features can run entirely on consumer hardware without sending private data to corporate cloud servers.
Zero Marginal Inference Cost: Closed proprietary APIs charge per token or per image query. That pricing model makes it financially impractical for students, indie developers, and hobbyists to build free tools for their communities. Open-source models eliminate paywalls and rate limits.
Reproducibility and Scientific Scrutiny: Because the PlantVillage dataset is openly documented and the ONNX model architecture is transparent, anyone can inspect the label mappings, study the training limitations, or fine-tune the model for specific local flora. Closed AI black-boxes offer no such accountability.
Community Extension: Open-sourcing this project allows other botanical enthusiasts to fork the repository, add support for regional plant species, integrate soil moisture IoT sensors, or deploy their own personal care companions.

My Agent Session

Development workflow was designed and verified using pair-programming in Antigravity IDE, with automated testing suites for both Python FastAPI and React TypeScript layers.

Prize Categories

Best Use of Render ($200 Featured Partner Category)

GardenMind AI includes a complete production deployment configuration specifically engineered for Render:

Render Blueprint: The repository provides a tested render.yaml specification defining an automated Render Web Service with health checks (/api/v1/health) and build/start commands.
Persistent Disk Storage: Because SQLite and user-uploaded plant photos require persistence across container rebuilds, the render.yaml configuration configures a 1 GB Render Persistent Disk mounted at /var/data.
Environment & Containerization: Pre-configured environment variables for CORS, upload directories, and database paths ensure the backend runs out-of-the-box on Render's managed infrastructure alongside the containerized backend/Dockerfile.

Thank you to DEV, GitHub, and the open-source community for organizing Hacktoberfest 2026. Happy gardening, and remember to step outside and touch grass! 🌱

AI Study Planner

Akshay Chandra — Mon, 05 Oct 2026 03:21:21 +0000

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

Inspiration

Planning a long-term learning journey can become difficult when there are many things to manage at the same time.

I was trying to balance programming, DSA, AI/ML, projects, university exams, and other technical skills. I could create a large roadmap, but turning that roadmap into realistic monthly, weekly, and daily tasks was much harder.

That led to the idea for AI Study Planner.

Instead of manually creating hundreds of study tasks, the user can describe what they want to learn, how much time they have available, their priorities, goals, projects, and target duration.

The application uses a locally running AI model to turn those requirements into a structured study plan.

A key part of the idea was keeping the user in control. The AI does not immediately modify the tracker. The generated plan is first presented for review, and only after approval is it implemented into the application.

The goal is simple:

Turn learning goals into an actionable plan without taking control away from the learner.

What it does

AI Study Planner is an AI-assisted study and career planning application that converts learning goals into an organized:

Month → Week → Day → Tasks

The user can provide information such as:

Skills they want to learn
Existing knowledge
Available study time
Learning priorities
Target completion period
Projects they want to build
Career-related goals
Other commitments

The local AI analyzes these requirements and generates a structured study plan.

The workflow has three main stages:

1. Describe

The user describes their learning goals and constraints.

2. Generate & Review

The AI generates monthly goals, weekly objectives, and daily tasks.

The user can inspect the generated plan before making any changes to their tracker.

3. Implement

After approval, the plan is converted into actual tracker tasks.

The application also provides:

AI-assisted study plan generation
Monthly, weekly, and daily planning
Task tracking and completion
Progress tracking
Streak tracking
Focus Mode
Daily study organization
Review-before-implementation workflow
Local AI inference using Ollama and Gemma
Open-source project structure

The important distinction is that AI planning and task tracking are separate steps. The AI suggests a plan, while the user decides what actually gets added to the tracker.

How I built it

The project was built as a web-based application using standard web technologies combined with local AI inference.

Technologies Used

HTML
CSS
JavaScript
Node.js
Ollama
Gemma
Git
GitHub
Antigravity for AI-assisted development

Local AI Architecture

The study-planning functionality uses Gemma through Ollama.

Instead of relying on a paid external AI API, the application communicates with an Ollama instance running locally on the user's computer.

The basic architecture is:

User Input

↓

AI Study Planner

↓

Local Ollama API

↓

Gemma

↓

Structured Study Plan

↓

User Review

↓

Approve / Modify

↓

Implement into Tracker

↓

Monthly → Weekly → Daily Tasks

This approach allows the AI component to run locally while keeping the application's planning workflow under the user's control.

Development with Antigravity

I used Antigravity as an AI-assisted development environment throughout the project.

It helped with:

Application development
Feature implementation
Debugging
Testing
Performance improvements
Project organization
Local AI integration
Documentation
Code cleanup

Antigravity was used as a development assistant. It is separate from the AI that powers the final study-planning functionality.

The study-planning AI itself runs through Ollama + Gemma.

Project Structure

The project is organized so that application code, services, data, assets, and documentation remain separated.

A simplified structure is:

The project does not contain my personal study data or personal tracker information.

Running the AI Locally

First, install Ollama and verify the installation:

Then download the required Gemma model:

Verify that the model is available:

You can also test Gemma directly:

Once Ollama and Gemma are running locally, the application can communicate with the local AI service.

Running the Project

Clone the repository:

Open the project in your preferred development environment and start it using the project's normal local development method.

For the AI planning functionality, Ollama must also be installed and the required Gemma model must be available locally.

Demo

Video Demo:
https://youtu.be/smpteorWVU0

** Live Local Demo :** Open
[https://akshay118r.github.io/AI-Study-Planner/ ] in any modern browser.

The demo shows the application interface, study-planning workflow, tracker functionality, and integration of the AI-assisted planning process.

The AI functionality requires Ollama and the required Gemma model to be installed locally.

Code

GitHub Repository:
https://github.com/akshay118R/AI-Study-Planner

The source code is available for developers to inspect, run locally, modify, and contribute to.

Challenges we ran into

One of the main challenges was designing the application so that AI-generated plans were actually useful instead of simply producing a long list of generic tasks.

A study plan needs to consider multiple factors at the same time, including:

Available study time
Learning priorities
Target duration
Existing knowledge
Multiple subjects or skills
Projects and other goals

Another challenge was deciding how the AI should interact with the tracker.

Automatically inserting AI-generated tasks could make the application unpredictable. Instead, the project was designed around a review-before-implementation workflow.

The AI generates the plan first.

The user reviews it.

The user decides whether to approve or modify it.

Only then is it implemented into the tracker.

Integrating a locally running model also introduced additional considerations around Ollama availability, model installation, communication with the local service, and differences in inference performance depending on the user's hardware.

Finally, building and debugging the application while using an AI-assisted development environment required continuous testing and review. Generated implementations still needed to be inspected, tested, and adjusted to match the intended behavior.

Accomplishments we're proud of

One of the biggest accomplishments was turning a simple study-planning idea into a functional application that combines AI planning with actual task management.

The project goes beyond a traditional to-do list by connecting:

AI Planning + Study Management + Progress Tracking

We are particularly proud of the review-before-implementation workflow.

The AI does not directly take over the user's schedule. Instead, it acts as a planning assistant and allows the user to make the final decision.

Another accomplishment is integrating Gemma through Ollama so that the planning functionality can run locally without requiring a proprietary cloud AI API.

This demonstrates how an open-weight model can be integrated into a practical application rather than being used only as a standalone chatbot.

The project is also structured as an open-source GitHub repository, allowing other developers to inspect the implementation, experiment with the AI planning logic, and contribute improvements.

What we learned

This project taught us that integrating AI into an application is not just about connecting a model to an input box.

The surrounding workflow is equally important.

We learned how to:

Integrate a locally running AI model into a web application
Work with Ollama and Gemma
Design prompts for structured AI output
Separate AI generation from application state changes
Build a review-and-approval workflow
Organize a web application into maintainable components
Debug and test AI-assisted implementations
Use an AI coding agent as part of the development process
Think about privacy when designing AI-powered applications
Build an open-source project that can be run locally by other developers

We also learned that AI-generated results need to be treated as suggestions that should be reviewed, especially when they are being converted into real tasks or schedules.

The combination of a local AI model and an application workflow can provide a useful balance between automation and user control.

What's next

There are several areas we would like to improve in future versions.

Planned improvements include:

Support for additional local AI models
Better study-plan customization
More advanced learning-time estimation
Automatic workload balancing
More detailed progress analytics
Improved project planning
Additional tracker views
Better model configuration
More personalization options
More intelligent scheduling based on completed tasks and progress

The longer-term goal is to make the planner more adaptive.

Instead of generating a plan once, future versions could continuously analyze progress and help adjust upcoming tasks while still keeping the learner in control of major changes.

The project will remain focused on the combination of open-source software, local AI, practical study management, and user-controlled planning.

Prize Categories

Open-source AI
Local AI / Local Inference

New to community

Akshay Chandra — Fri, 02 Oct 2026 23:17:05 +0000

Hello!