🌱 PotWise: Because My Plants Deserve More Attention Than My Phone

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

What I Built

I'm the kind of person whose first target in the morning is to water my plants. 😂
That's honestly my therapy.
Subah uthna, apne plants ko dekhna, check karna ki kitni growth hui, koi nayi leaf aayi ya nahi, and just spending a few minutes with them before starting my day.
I'm definitely not a pro at gardening though.
For the longest time, my gardening strategy was basically:
Plant hai → paani do → plant khush rahega. 🌱

Until one day, I noticed the leaves of my Jade plant were falling.
And if you know me, I'm a very possessive plant parent. 😭
Seeing those leaves fall genuinely broke my heart.
So, without thinking twice, I went straight to Google:
"Why are the leaves of my jade plant falling?"
And honestly, the answers were pretty good.
I could find information about the kind of soil I should use, how much water the plant needs, light requirements, possible causes, and what I could do about it.
But there was one problem.
It took time.
I'd have to search for my specific plant, go through multiple articles, figure out which information actually applied to my situation, and then translate all of that into:
"Okay... so what exactly do I do right now?"
And as an undergraduate student, I already have assignments, exams, projects, learning new technologies, hackathons... basically a never-ending list of things.
I didn't want gardening to become another research assignment.
I wanted to be able to simply look at my plant and ask:
"What's wrong with you?"

And that's where PotWise came into my mind.

The Idea Behind PotWise

PotWise is an AI-powered plant-care assistant built around one simple idea:
Not sure what your plant needs? Just ask PotWise.

You upload a photo of your plant.
PotWise identifies it.
You confirm the identification.
And then you can simply talk to it about your plant.
You can ask things like:

• Why are these leaves turning yellow?
• How often should I water this plant?
• What soil mix should I use?
• What should I check if my plant is drooping?
• What should I do differently this season? And instead of giving the model complete control over the answer, PotWise combines AI with a trusted plant knowledge base and deterministic Python logic. The goal is simple: Ask → understand → act → get back to your plant.

Why Gemma?

Okay, the honest answer first:
Because it had the highest prize money. 😂

Just kidding.
...mostly. XD
But the actual reason I chose Gemma was because I wanted to build something with an open-weight model that I could actually run locally.
This was also my first time properly building an application around AI, rather than just calling an API and putting the response on a screen.
So I wanted something that I could experiment with and understand.
I ended up using Gemma 3 through Ollama for local development.
And it turned out to be a really good fit for PotWise.
My application needed a model that could:

• look at a plant image,
• understand natural-language questions,
• work with contextual information,
• and act as the conversational layer of the assistant. Gemma fit naturally into that role. More importantly, running it locally meant I could actually experiment with the model on my own machine rather than treating AI as a black box somewhere in the cloud.

But I Didn't Want the LLM to Know Everything

This was one of the biggest architectural decisions I made while building PotWise.
I didn't want to create:
**User → LLM → whatever the LLM says

and call that a plant-care application.**
Instead, I separated AI reasoning from trusted plant information.
PotWise has a structured knowledge base containing information about 15 supported plants. Properly researched and stored.
The model can propose:
"This looks like a Jade Plant."

But the model doesn't decide the application's internal plant record.
PotWise checks that proposed identification against:
data/plants.json

So the basic flow becomes:
Plant Image
↓
Gemma
↓
Proposed Identification
↓
Trusted Plant Knowledge Base
↓
Confirmed Plant

I liked this approach because it gave the AI enough freedom to understand the user while keeping important plant information under application control.

Making Plant Problems Conversational

Another thing I didn't want was a huge form asking:
"Select your leaf color."

"Select your soil moisture."

"Select your symptom."

"Select your environmental condition."

Plants don't really work like that.
The same symptom can have multiple possible causes.
So instead, PotWise has structured diagnostic context that the assistant can use while having a conversation.
For example, if someone says:
"My leaves are turning yellow."

the assistant shouldn't immediately declare:
"You have overwatered your plant."

Instead, it can ask about things such as:

• root-zone moisture
• recent watering
• drainage
• light
• rain exposure
• environmental changes and discuss possible causes. That distinction was important to me because PotWise is meant to be a screening and guidance tool, not some magical plant doctor.

The Soil Calculator

I also wanted PotWise to go beyond simply telling me:
"Use a well-draining soil mix."

Because... okay, but how much? 😂
So each supported plant can have a stored soil-mix ratio.
If the knowledge base says:
1 part potting mix
1 part perlite
1 part pumice

and I enter a total pot volume, Python calculates the actual quantities required.
For example:
3 L total

Potting mix → 1 L
Perlite → 1 L
Pumice → 1 L

This is intentionally handled by Python rather than the LLM.
The model doesn't need to do arithmetic.
It needs to understand me.
The application needs to calculate things correctly.

Why ElevenLabs?

This one came directly from the Touch Grass theme.
I could have stopped at a normal text chatbot.
But imagine I'm actually repotting my Jade plant.
My hands are covered in soil.
I'm trying to mix potting mix and perlite.
And PotWise gives me a long answer.
Am I really going to keep picking up my phone every few seconds to read it?
No. 😂
That's exactly what I wanted to avoid.
I wanted an assistant that could actually assist me while I'm gardening.
So I added voice interaction using ElevenLabs.
The flow is:
🎙️ User speaks
↓
Speech recognition
↓
PlantWise Assistant
↓
ElevenLabs Text-to-Speech
↓
🔊 User listens

There's also a Hands-Free Mode that automatically speaks new assistant responses.
So instead of:
Look at phone → read → put phone down → garden → pick phone up again

the interaction becomes:
Ask → listen → garden.

And that's really what I wanted from the Touch Grass challenge.
The phone should be the shortest part of the experience.

How PotWise Actually Works

Putting everything together:-
USER
│
▼
┌─────────────┐
│ Streamlit UI│
└──────┬──────┘
│
▼
┌─────────────┐
│ AI Provider │
└──────┬──────┘
│
┌─────────┴─────────┐
▼ ▼
Ollama + Gemma Gemini API
Local Hosted
│ │
└─────────┬─────────┘
▼
Plant Identification
│
▼
Trusted Plant Knowledge
│
▼
Python Personalization
/ \
▼ ▼
Soil Calculator PlantWise
│
┌──────┴──────┐
▼ ▼
Chat Voice
│
ElevenLabs
│
▼
Audio

                   SQLite
                  /      \
         Conversations  My Pots

The philosophy behind the architecture is:
Gemma identifies.
Knowledge Base informs.
Python personalizes.
ElevenLabs speaks.
SQLite remembers.

Local AI → Hosted AI

One challenge I ran into was deployment.
Locally, I could happily run:
PotWise → Ollama → Gemma

But running a local model isn't practical when someone else opens my deployed Streamlit application.
So instead of rewriting the application, I created an AI provider abstraction.
Locally:
AI_PROVIDER=ollama
↓
Ollama
↓
Gemma 3

For the deployed application:
AI_PROVIDER=gemini
↓
Gemini API

The rest of PotWise doesn't need to care which provider is being used.
This was probably one of the most useful architectural things I learned while building the project:
Don't make your entire application depend directly on one model provider.

And Then There Was SQLite

PotWise doesn't require users to create an account.
But I still wanted it to remember:

• conversations
• messages
• saved plants
• My Pots That introduced another problem. If everyone used the same SQLite database, anonymous users could potentially see each other's data. So I created a separate SQLite database for each active Streamlit session. Conceptually: Browser Session A ↓ potwise_A.sqlite3

Browser Session B
↓
potwise_B.sqlite3
**
No login system.**
No complicated authentication layer.
Just session-level data isolation appropriate for the hackathon application.

Why Open Innovation Matters to Me

Building PotWise with an open-weight model changed the way I approached the project.
If I had started with:
"I'll just call an AI API."

I probably would have built a chatbot.
Instead, working with Gemma locally made me think about:
What exactly should the model be responsible for?
Should it store plant facts?
No.
Should it calculate soil quantities?
No.
Should it decide whether something is definitely wrong with a plant?
Definitely not.
Should it understand the image, understand what I'm asking, and help me reason through the problem?
Yes.
That separation ended up shaping the entire architecture.
Open models also gave me something I really valued as a student:
the ability to experiment.
I could run Gemma locally, change the prompts, test different inputs, inspect failures, and build the application around it.
And because I created a provider abstraction, I could later switch between local and hosted inference without rewriting PotWise.

What I Learned Building This

This was my first time building an AI application at this level, and honestly, the biggest lesson wasn't about prompting.
It was learning that AI application development is still application development.
The model is only one part.
I had to think about:

• data validation
• model uncertainty
• trusted knowledge
• deterministic calculations
• conversation state
• voice interaction
• persistence
• session isolation
• deployment
• and a ridiculous number of bugs along the way. 😂 I also learned that giving an AI model less responsibility can sometimes make the overall application better. Let the model handle what it's good at. Let code handle what code is good at. Let trusted data handle what needs to be trusted.

Why This Fits "Touch Grass"

At the beginning, PotWise was just about helping me figure out why my Jade plant was losing its leaves.
But the more I built it, the more the theme made sense.
I don't want PotWise to become another app that keeps me staring at my phone.
I want it to do the opposite.
Ask it a question.
Listen to the answer.
Put the phone down.
Go take care of your plant. 🌱
That's the whole point.

What's Next?

There are still things I'd love to add:

• more source-backed plant knowledge
• more sophisticated plant-problem reasoning
• authenticated accounts for cross-device history
• better accessibility for voice-first interaction
• more automated UI testing
• more local/open model options But for now, I'm happy that the thing that started because my Jade plant's leaves were falling has turned into an actual deployed AI application. And yes... I still check my plants first thing in the morning. 😂🌱

Demo

https://ritika-sharma013-potwise-app-xe7gco.streamlit.app/

Code

ritika-sharma013 / PotWise

PotWise

Not sure what your plant needs? Just ask PotWise.

PotWise is an AI-powered plant-care assistant built for Hacktoberfest 2026. Upload a plant photo, confirm the identification, and get grounded care guidance through chat or voice.

Overview

PotWise combines multimodal AI with a trusted plant knowledge base and small, explicit Python calculations. An AI model helps identify the plant and understand the user's question, while the application remains responsible for trusted plant matching, care context, soil calculations, conversation persistence, and saved pots.

The result is a plant-care companion that is useful for everyday questions without treating a language model as the sole source of horticultural facts.

Why PotWise?

Many plant owners can see that something is wrong but do not know whether the next step is to check light, moisture, drainage, soil, or the plant's recent environment. Care advice is also often needed while someone's hands are busy watering, repotting…

View on GitHub

Prize Categories

I'm submitting PotWise for:

🏆 Best Use of Gemma

Gemma 3 is used as the open-weight AI model for local plant identification and conversational reasoning.

🎙️ Best Use of ElevenLabs

ElevenLabs powers PotWise's voice interaction, allowing users to receive spoken plant-care guidance while their hands are busy gardening.

Built solo