🌱 TouchGrass-AI: Your Local AI Guide to Get Outside
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
What I Built
TouchGrass-AI is a local-first AI outdoor activity guide designed to help people spend less time on their screens and more time outside.
The idea is simple:
Tell the AI where you are, what you want to do, and how much time you have — then go touch some grass. 🌱
A user provides:
📍 Their general area
🌳 The outdoor activity they want to do
⏱ How much time they have
💪 Their fitness/experience level
✨ Their preferences
⚠️ Any constraints
TouchGrass-AI then generates a personalized outdoor plan containing:
An activity recommendation
Difficulty level
Suggested duration
Best time of day
A step-by-step activity plan
Things to bring
Safety considerations
A small "Touch Grass Challenge"
An offline tip so the user can put their phone away
The project is aimed at people who want to explore their surroundings but don't know what outdoor activity to do or how to start.
The most important UX principle is:
The screen should be the shortest part of the experience.
The user gets their plan, reads it, puts their phone away, and goes outside.
Demo
Local Demo
The application runs locally at:
Demo Flow
Enter location
↓
Choose outdoor activity
↓
Set available time
↓
Set fitness level
↓
Add preferences
↓
TouchGrass-AI generates a plan
↓
Read the plan
↓
Put the phone away 📵
↓
GO OUTSIDE 🌱
Example
Input:
Location: Bandra, Mumbai
Activity: Walking
Time: 1-2 hours
Experience: Beginner
Preferences: Photography and quiet places
Constraints: Avoid steep climbs
TouchGrass-AI generates a personalized walking experience with a practical plan, preparation checklist, safety suggestions, and a small outdoor challenge.
Code
🌱 GitHub Repository
Repository:
https://github.com/Bharatefb/TouchGrass-AI
The complete source code is available on GitHub:
https://github.com/Bharatefb/TouchGrass-AI
The project is built as a simple local-first application:
TouchGrass-AI/
│
├── app/
│ ├── init.py
│ ├── main.py
│ └── prompts.py
│
├── static/
│ ├── index.html
│ ├── style.css
│ └── app.js
│
├── requirements.txt
└── README.md
Architecture
┌─────────────────────────────┐
│ HTML + JavaScript │
│ Frontend │
└──────────────┬──────────────┘
│
│ POST /api/guide
▼
┌─────────────────────────────┐
│ FastAPI │
│ Python Backend │
└──────────────┬──────────────┘
│
│ localhost
▼
┌─────────────────────────────┐
│ Ollama │
│ Local AI Runtime │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ gemma4:e2b │
│ Local AI Model │
└──────────────┬──────────────┘
│
▼
Personalized Guide
│
▼
🌱 OUTSIDE
The code is intentionally simple so that someone can clone the project, install Ollama, download the model, and run the entire application locally.
How I Built It
TouchGrass-AI uses Ollama for local model execution and the open-weight Gemma model gemma4:e2b as the AI engine.
The backend is built with Python and FastAPI.
The frontend uses:
HTML
CSS
Vanilla JavaScript
There is no React and no cloud AI API required.
When the user submits the form, the browser sends the information to the FastAPI backend:
Browser
↓
POST /api/guide
↓
FastAPI
↓
Prompt construction
↓
Ollama
↓
gemma4:e2b
↓
Structured JSON
↓
FastAPI
↓
Browser
The model is instructed to return structured JSON containing the activity, plan, preparation checklist, safety information, and the final "Touch Grass Challenge".
I also added response parsing and validation so that the backend can handle cases where the model accidentally returns JSON wrapped in markdown.
Local AI
The model runs through:
The application communicates with Ollama locally instead of sending the user's request to a hosted LLM API.
To run the project:
git clone https://github.com/Bharatefb/TouchGrass-AI.git
cd TouchGrass-AI
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
ollama pull gemma4:e2b
uvicorn app.main:app --reload
Then open:
Why Does Open Innovation Matter?
For TouchGrass-AI, local and open AI isn't just a technical choice — it is part of the product idea.
The application asks for information that can be personal, such as someone's location, preferences, fitness level, and outdoor habits.
Instead of requiring that information to be sent to a proprietary AI service, TouchGrass-AI can process the AI request locally through Ollama.
That gives the project several advantages.
🔒 Privacy
The AI inference happens locally.
The user's request goes from:
TouchGrass-AI → localhost → Ollama → Local Model
rather than requiring a cloud AI API.
For an application involving location and personal preferences, keeping this information on the user's machine can be a meaningful advantage.
🧩 Model Flexibility
Because the application communicates with Ollama, the AI model can potentially be changed without rebuilding the entire application.
The architecture separates:
Application
↓
AI Runtime
↓
Model
This means the project isn't fundamentally tied to one proprietary AI provider.
💻 Local-First Experience
A major goal of the challenge is getting people outside.
Ironically, an AI outdoor application shouldn't require a permanent cloud connection just to generate a simple activity plan.
Running the model locally makes a local-first experience possible.
🛠 Open Development
Using open AI infrastructure also makes the project easier to experiment with.
Developers can modify:
The system prompt
The model
The application logic
The response format
The frontend
The safety rules
The activity recommendation strategy
without having to rebuild the entire product around a closed AI API.
My Agent Session
I built TouchGrass-AI as a local AI application and iterated on the architecture, prompt design, JSON response format, and user experience.
Agent session:
Prize Categories
Open-Source AI / Local AI
TouchGrass-AI is built around local AI inference using:
Ollama
Gemma open-weight model
FastAPI
HTML/CSS/JavaScript
Touch Grass Theme
The entire product is designed around the theme:
Use AI to spend less time using AI.
The AI creates the plan.
Then the user closes the screen and goes outside.
🌱 Plan less. Explore more. Touch grass.
Top comments (0)