DEV Community: Prabodh Kr

🌱 GardenBuddy: An AI Garden Agent That Gets You Off the Screen

Prabodh Kr — Sun, 11 Oct 2026 10:12:37 +0000

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

What if an AI application helped you close your laptop instead of keeping you chatting?

That was the idea behind GardenBuddy, my project for Hacktoberfest 2026 Week 1: Touch Grass.

Instead of building another general-purpose chatbot, I wanted to build something practical: an AI gardening assistant that helps users organize their gardens, consider weather conditions, and get a plan for what to do outside.

🔗 Try GardenBuddy · GitHub Repository

🌿 What I Built

GardenBuddy is an AI Garden Weather Agent with a simple goal:

Help people spend less time on screens and more time growing things.

Here's what the application looks like.

The dashboard displays the daily garden plan, weather status, selected garden, and plant-management section.

The main features include:

🌱 Create a garden with its location, type, and sunlight exposure.
🪴 Add plants with species, planting dates, locations, and care notes.
🌦️ Use weather information to inform gardening plans when the weather service is available.
✅ Review suggested tasks and use them to guide real gardening activities.
🧠 Build toward more personalized planning using AI reasoning and persistent memory.

🪴 How to Use GardenBuddy

1. Create Your Garden

Start by clicking + New in the top navigation bar.

Enter the following information:

Field	Example
Garden name	My Home Garden
City / Region	Kolkata, India
Garden type	Balcony
Sunlight exposure	Partial Sun

The location is especially important because weather and growing conditions vary by region.

Click Save Garden to create your garden.

2. Add Your Plants

Once your garden is created, click + Add Plant.

For example, you could add a tomato plant:

Field	Example
Plant name	Tomato
Species / Variety	Your tomato variety
Date planted	The actual planting date
Location in Garden	Balcony pot 1
Notes / Care Observations	Soil condition, compost, or growth notes

Click Save Plant.

You can repeat this for coriander, spinach, mint, or any other plants you're growing.

The purpose of recording this information is to give GardenBuddy useful context about the garden rather than treating every request as an unrelated question.

3. Get Your Daily Garden Plan

After selecting your garden, open Today's Daily Garden Plan and use Refresh Plan when you want to generate or refresh the plan.

A plan might include tasks such as:

Check soil moisture before watering.
Prepare a garden bed.
Review which crops are suitable for your growing conditions.

Weather-aware recommendations depend on the weather service returning valid data. If the service is unavailable, the application should communicate that limitation rather than pretend it has a reliable forecast.

The intended workflow is straightforward:

Create garden
     ↓
Add plants
     ↓
Get daily plan
     ↓
🌱 Go outside
     ↓
Complete garden tasks

That's the part of the project I care about most: turning an AI-generated plan into a real-world activity.

🏗️ How I Built It

I structured GardenBuddy around separate responsibilities instead of putting everything into one large AI prompt.

Here's the intended architecture:

              🌱 GardenBuddy
                    │
              Frontend (Vercel)
                    │
                    ▼
                 FastAPI
                    │
          ┌─────────┼──────────┐
          ▼         ▼          ▼
     PostgreSQL  Weather API  AI Layer
                               │
                     ┌─────────┴────────┐
                     ▼                  ▼
               Thinking Machines    Backboard.io
                 AI reasoning       AI memory

              RAG → Gardening knowledge

              Render → Backend hosting

Technology choices

Technology	Role
FastAPI	Backend API and application logic
PostgreSQL	Structured garden and plant data
Weather API	Current and forecast weather
Thinking Machines	AI reasoning integration
Backboard.io	Persistent AI memory integration
RAG	Retrieval of gardening knowledge
Render	Backend deployment and hosting

DevRelay MCP is part of my exploration of agent tooling. MCP can expose tools to an AI agent, but it does not provide weather data by itself.

I want each technology to solve a real problem rather than add tools just to make the stack look impressive.

Project structure

The project is organized around the frontend, backend, and project documentation.

garden_buddy/
│
├── PROJECT.md       # Product requirements and architecture
├── AGENTS.md        # Coding-agent instructions
├── TASKS.md         # Development roadmap
├── SECURITY.md      # Security boundaries
├── README.md        # Project documentation
│
├── frontend/        # Garden dashboard and forms
├── backend/         # FastAPI application
│
└── .env.example     # Required configuration names

This illustrates the intended organization; check the repository for the exact current directory and file names.

I also defined project instructions for AI-assisted development. They explain what the application should do, how implementation should proceed, and which security boundaries must be respected.

How the components fit together

The core workflow is:

Garden + Plant Data
        │
        ▼
Weather Information
        │
        ▼
Relevant Gardening Knowledge
        │
        ▼
AI Reasoning + Garden Context
        │
        ▼
Today's Garden Plan
        │
        ▼
Real-world Gardening 🌱

The important distinction is that the AI should use available garden information and actual weather data. It should not invent a forecast or assume that a plant needs watering without considering the situation.

💻 Code and Demo

🌐 Live demo: https://gardenbuddy-frontend.vercel.app/

🐙 Source code: https://github.com/PrabodhKumar01/garden_buddy

I'd welcome feedback, bug reports, and contributions that make GardenBuddy more useful for real gardeners.

🌍 Why Does Open Innovation Matter?

For me, open innovation is about being able to inspect, experiment with, and improve the technology behind an application.

With an open-source project like GardenBuddy, contributors can help improve the garden-planning workflow, add regional gardening knowledge, test recommendations, and explore different AI approaches.

It also makes the project easier to extend without committing its entire future to one provider.

The broader opportunity is to build AI that supports useful activities outside the digital world.

🏆 Prize Categories

These are the partner tracks relevant to the technologies I am exploring. Actual eligibility depends on the challenge rules and the integrations demonstrated in the submitted version.

🚀 Best Use of Render: Hosting the GardenBuddy backend and supporting its deployment workflow.
🧠 Backboard.io: Persistent garden memory, where implemented and demonstrated.
🤖 Thinking Machines: AI-powered garden planning and reasoning, where implemented and demonstrated.

Each integration should have a clear responsibility and a working demonstration. I don't want to claim that a planned integration is already complete.

🌱 What's Next?

My next priorities are to improve weather reliability, strengthen personalized recommendations, expand the gardening knowledge base, and test the application through actual gardening activities.

I'd also like to improve how GardenBuddy remembers observations over time so that future plans can make better use of a garden's history.

Final Thoughts

Hacktoberfest's Touch Grass theme challenged me to think beyond building another application that keeps people online.

GardenBuddy is my attempt to use AI for something simple and tangible: helping people care for plants and spend more time outdoors.

The idea is straightforward:

Let AI help with the planning. Let people do the gardening. 🌱

Thanks for reading! If you have ideas for improving GardenBuddy, I'd love to hear them.

📚 I Built an AI Study Buddy That Runs on Open-Weight AI

Prabodh Kr — Sun, 04 Oct 2026 19:50:40 +0000

What if your study notes could actually talk back to you?
For Hacktoberfest 2026, I decided to build something that solves a real problem for a friend: Study Buddy — a simple AI-powered study assistant that lets you upload your study PDFs and ask questions about them.
Instead of searching through hundreds of pages manually, you can upload your notes and simply ask:
"What is deadlock and what are its necessary conditions?"

or:
"Who is Morrie and why did Mitch visit him every Tuesday?"

Study Buddy searches your uploaded material and generates an answer based on the relevant sections of the document.
🎯 Why I Built Study Buddy
As students, we often have:

📄 Large PDFs
📚 Lecture notes
📝 Reference books
😵 Too much information to search manually I wanted to build something simple: Upload → Ask → Get an answer from your own study material. The important part is that the AI isn't simply answering from general knowledge. It first searches the uploaded documents and uses the relevant content to generate the answer. That is where RAG (Retrieval-Augmented Generation) comes in. 🖥️ What Study Buddy Looks Like Here's the current interface:

The application has two simple steps:

Upload Study Materials You can upload a PDF containing your notes or study material. Study Buddy extracts the text, divides it into smaller chunks, generates embeddings, and stores those chunks locally. In my example, I uploaded: Tuesdays with Morrie and the application indexed 435 chunks from the document.
Ask a Question You can then ask questions about the uploaded material. For example: Who is Morrie and why did he meet his teacher every Tuesday?

Study Buddy searches the indexed document and retrieves the most relevant sections.
🧠 How It Works
The basic architecture looks like this:
┌──────────────────┐
│ Study PDF │
└────────┬─────────┘
↓
┌──────────────────┐
│ Text Extraction │
│ (pypdf) │
└────────┬─────────┘
↓
┌──────────────────┐
│ Text Chunking │
└────────┬─────────┘
↓
┌──────────────────┐
│ Embeddings │
└────────┬─────────┘
↓
┌──────────────────┐
│ Local Vector │
│ Store + NumPy │
└────────┬─────────┘
↓
User asks a question
↓
┌──────────────────┐
│ Similarity Search│
└────────┬─────────┘
↓
Relevant document
chunks retrieved
↓
┌──────────────────┐
│ LLM │
│ │
│ Local: Ollama │
│ Cloud: Groq │
└────────┬─────────┘
↓
┌──────────────────┐
│ Answer │
│ + Sources │
└──────────────────┘

🔎 What is RAG?
One of the biggest things I learned while building this project was RAG — Retrieval-Augmented Generation.
Normally, if you ask an LLM:
"What does my PDF say about Morrie's illness?"

the model doesn't automatically know what's inside your PDF.
RAG solves this by giving the model relevant information from your own documents.
The process is roughly:
Question
↓
Find relevant chunks
↓
Give those chunks to the LLM
↓
Generate an answer

This makes the application much more useful for studying because the answer can be grounded in the uploaded material.
🤖 Open-Weight AI
One of the requirements of the Hacktoberfest challenge I chose was to have open-source/open-weight AI at the core of the project.
For local usage, Study Buddy can use:
Ollama + Llama 3.1 8B
This means the model can run directly on your own computer instead of sending your study documents to a remote AI provider.
That has some useful advantages:

🔒 Better privacy
💻 Can work locally
🌐 Doesn't require internet for local inference
💰 No per-request API cost
🔄 Models can be swapped
🧪 Easier experimentation with open-weight models For the deployed Vercel version, I use cloud inference through Groq because Vercel's serverless environment cannot simply run my local Ollama installation. So the architecture becomes: LOCAL Ollama ↓ Llama 3.1 8B ↓ Study Buddy

DEPLOYED
Vercel
↓
Groq API
↓
Open-weight LLM
↓
Study Buddy

This gives me both a local/private mode and a web-deployed mode.
🛠️ Tech Stack
The project is intentionally lightweight.
Backend

🐍 Python
⚡ FastAPI
📄 pypdf
🔢 NumPy
🔐 python-dotenv AI
🦙 Llama 3.1 8B
🦙 Ollama
🤖 Groq
🧠 Embeddings
🔎 RAG Storage Instead of using a heavy vector database, I built a simple local vector store using: JSON + NumPy

This keeps the project easy to understand and run.
Frontend

HTML
CSS
JavaScript Deployment
GitHub
Vercel 🏗️ Project Structure The project currently looks like this: study-buddy/ │ ├── api/ │ └── index.py │ ├── app/ │ ├── main.py │ │ │ ├── routes/ │ │ ├── documents.py │ │ └── chat.py │ │ │ ├── services/ │ │ ├── llm.py │ │ ├── embeddings.py │ │ ├── vector_store.py │ │ └── rag.py │ │ │ ├── static/ │ │ └── index.html │ │ │ └── utils/ │ └── pdf_loader.py │ ├── data/ │ └── vector_store.json │ ├── documents/ │ ├── tests/ │ └── test_main.py │ ├── requirements.txt ├── README.md ├── .env ├── run.bat └── run.sh

⚙️ API Endpoints
The backend is built with FastAPI.
Some of the main endpoints are:
POST /documents

Upload and index a PDF.
GET /documents

View indexed documents.
POST /chat

Ask a question and retrieve an AI-generated answer with references.
FastAPI also provides the usual interactive API documentation through:
/docs

💡 What I Learned
This project was especially interesting because I didn't start with a deep understanding of RAG or embeddings.
While building it, I had to understand how several different pieces fit together:

Embeddings Text can be converted into numerical vectors that capture semantic meaning. That allows the application to compare a user's question with document chunks.
Vector similarity Study Buddy uses vector similarity to determine which chunks are most relevant to the question.
RAG Instead of asking the LLM to answer blindly, I retrieve relevant information first and then provide it to the model.
Local LLMs Running an open-weight model locally with Ollama showed me that AI applications don't necessarily have to depend entirely on cloud APIs.
FastAPI I also got more practical experience connecting AI functionality to a real backend API.
Deployment Getting the project from: Local machine ↓ GitHub ↓ Vercel

was another learning experience by itself.
🚧 Challenges I Faced
The project wasn't completely smooth.
One of the problems I encountered was the retirement of the Groq model I initially used:
llama-3.1-8b-instant

The API returned:
model_not_found

This forced me to understand the difference between:

the model I want to run locally
the model available through a cloud inference provider
environment variables
local .env configuration
Vercel environment variables It also taught me that deployment isn't simply "push code and you're done." There are infrastructure, environment, API, and configuration issues that have to be handled separately. 🔐 Privacy Matters One of the main reasons I wanted local AI support was privacy. Imagine uploading:
Personal notes
College assignments
Private study material
Class documents to an external service. With local inference, the model can run on your own machine. Your documents don't need to leave your computer simply because you want to ask questions about them. That's one of the things I find most interesting about open-weight AI. 🚀 What's Next? Study Buddy is still an MVP. Some things I'd like to add in the future:
📚 Multiple document collections
🧠 Better retrieval
💬 Conversation memory
📖 Better citation handling
🎤 Voice questions
🔊 Voice answers
👥 User accounts
🗃️ PostgreSQL/vector database support
📱 Better mobile UI
📊 Study progress tracking
📝 Automatic quizzes from uploaded notes I'd also like to experiment with different open-weight models and compare their performance on educational tasks. ❤️ Built for a Friend The challenge wasn't just about building an AI application. The idea was to build something that could actually be useful to another person. A student shouldn't have to manually search through hundreds of pages every time they have a question. That's the problem Study Buddy is trying to solve: Turn your study material into something you can have a conversation with.

🌱 Why Open Innovation Matters
This project made me appreciate something important about open-weight AI.
You don't always need access to an expensive proprietary AI system to build something useful.
With open models, local inference tools, and open-source frameworks, developers can experiment, modify, learn, and build applications around their own needs.
For students especially, that's powerful.
You can take an idea from:
"I wonder if this is possible..."

to:
"I built it."

using tools that are accessible to you.
🎉 Final Thoughts
Study Buddy started as an idea for a Hacktoberfest challenge and became a practical way for me to learn about:
FastAPI → RAG → Embeddings → Vector Search → LLMs → Ollama → Groq → Deployment
I still have a lot to learn about AI systems, but building this project gave me a much better understanding of how the individual pieces fit together.
And that's probably my biggest takeaway:
You don't need to know everything before building. Sometimes building is how you learn.

🔗 Project
GitHub: https://github.com/PrabodhKumar01/Study-Buddy
Live Demo: https://studybuddy-kohl-delta.vercel.app/

📸 Where to put your screenshot
For the image you uploaded, I'd place it immediately after the "What Study Buddy Looks Like" heading. It gives readers an instant visual understanding of the project before they read the technical details.
For the DEV post's cover image, I'd recommend making a separate 16:9 image with:
Study Buddy
Your AI-powered study companion
📚 PDF → 🔎 RAG → 🤖 Open-Weight AI