A local-first AI meal planner built for real-life PG kitchens.
Meal Prepper helps you decide what to cook with what you already have.
Living in a PG often means having limited ingredients, limited cooking equipment, and very little motivation to figure out what to make. When deciding what to cook becomes a hassle, ordering food becomes the easier option.
Meal Prepper reduces that decision fatigue by generating meals based on available ingredients, cooking tools, and meal type — while also providing deterministic nutrition information.
When living in a PG, cooking often looks like:
What ingredients do I have?
↓
What can I make with them?
↓
Do I have the equipment required?
↓
How much should I use?
↓
Fuck it, let's order.
This becomes even more important when trying to follow a diet or hit a daily protein goal.
Meal Prepper turns this into:
Ingredients + Quantities + Tools + Meal Type
↓
Gemma
↓
Feasible Recipe
↓
Nutrition Engine
↓
Recipe + Nutrition
- 🥘 Generate meals based on available ingredients
- ⚖️ Support different ingredient units such as grams, pieces, and ml
- 🔧 Consider available cooking tools
- 🍳 Support different meal types:
- Breakfast
- Lunch
- Snacks
- Dinner
- 🤖 Local AI-powered recipe generation using Gemma
- 📴 Works offline once the local model and application are available
- 🔒 Ingredient and meal data can remain local
- 🧮 Deterministic nutrition calculation using a local nutrition database
- 💪 Protein information for generated meals
- ✅ Recipe validation to prevent impossible recipes
- 📊 Nutrition calculated from ingredient quantities rather than relying on the LLM's arithmetic
Meal Prepper separates AI reasoning from deterministic application logic.
The user provides:
Ingredients:
- Rice: 200g
- Eggs: 3 pieces
- Onion: 1 piece
Meal:
Lunch
Tools:
- Pan
- Stove
- Knife
The input is sent to a locally running Gemma model through Ollama.
Gemma determines a suitable recipe while considering:
- Available ingredients
- Available quantities
- Meal type
- Available cooking tools
Gemma returns a structured recipe containing ingredient quantities and cooking steps.
The application validates the generated recipe.
It checks that:
- Ingredients actually exist in the user's inventory
- The recipe doesn't use more than the available quantity
- Required cooking tools are available
- Unsupported or missing ingredients aren't silently introduced
- Cooking steps are compatible with the available equipment
Invalid recipes are rejected instead of being blindly shown to the user.
Nutrition data is stored primarily on a per-100g basis.
Ingredients already provided in grams can be used directly.
Supported piece-based ingredients can be converted using explicit application-level conversion data.
For example:
1 egg ≈ 50g
1 onion ≈ 100g
These are approximate MVP conversions and are not generated by the LLM.
Unsupported conversions are rejected rather than guessed.
The application uses the local nutrition.json dataset to calculate:
- Calories
- Protein
- Carbohydrates
- Fat
For example:
per-100g nutrition × ingredient weight / 100
The nutrition calculator is deterministic and does not rely on Gemma for nutritional arithmetic.
┌───────────────┐
│ Web UI │
└───────┬───────┘
│
▼
┌───────────────┐
│ Node.js API │
└───────┬───────┘
│
▼
┌───────────────┐
│ Meal Flow │
└───────┬───────┘
│
┌──────────────┴──────────────┐
▼ ▼
┌───────────────┐ ┌────────────────┐
│ Local Gemma │ │ Recipe │
│ via Ollama │ │ Validation │
└───────┬───────┘ └───────┬────────┘
│ │
└──────────────┬──────────────┘
▼
┌───────────────┐
│ Unit │
│ Conversion │
└───────┬───────┘
▼
┌───────────────┐
│ Nutrition │
│ Calculator │
└───────┬───────┘
▼
┌───────────────┐
│ nutrition.json│
└───────────────┘
- Node.js — application server and backend logic
- Ollama — local LLM runtime
- Gemma — local recipe reasoning
- JavaScript — application logic
- HTML/CSS/JavaScript — minimal frontend
- JSON — local nutrition database
- ICMR-NIN IFCT 2017 — primary nutrition data source
.
├── nutrition.json
├── nutritionCalculator.js
├── recipeGenerator.js
├── mealFlow.js
├── server.js
├── unitConversions.json
├── public/
│ ├── index.html
│ ├── app.js
│ └── styles.css
├── test/
│ ├── nutritionCalculator.test.js
│ ├── recipeGenerator.test.js
│ └── mealFlow.test.js
├── package.json
└── README.md
Install:
- Node.js
- Ollama
- The required Gemma model
Check Node:
node -vCheck Ollama:
ollama listMake sure the required Gemma model is available locally.
From the project directory:
node server.jsThe application runs at:
http://127.0.0.1:3000
Open that address in your browser.
Run the complete test suite:
npm testThe tests cover:
- Nutrition calculations
- Ingredient lookup
- Ambiguous ingredients
- Invalid quantities
- Unknown ingredients
- Recipe generation
- Recipe validation
- Unit conversion
- Recipe-to-nutrition integration
- API behavior
The local-first architecture is intentional.
PG Wi-Fi can be unreliable, and mobile networks can also become unavailable.
Because the core model runs locally through Ollama, Meal Prepper does not need an internet connection to generate meals once the required software/model is installed.
Ingredients, meals, and dietary information can stay on the user's machine rather than being sent to an external AI API.
There is no dependency on paid LLM API calls for the core meal-generation functionality.
The project currently uses nutritional data based primarily on:
Indian Food Composition Tables (IFCT) 2017
Published by:
ICMR — National Institute of Nutrition
Nutrition values are stored on a per-100g edible-portion basis where applicable.
The application intentionally distinguishes between:
- Raw foods
- Boiled foods
- Dry foods
- Other preparation states
Missing nutritional values are treated as unavailable, not automatically as zero.
Input:
Ingredients:
- Rice: 200g
- Egg: 3 pieces
- Onion: 1 piece
Meal:
Lunch
Tools:
- Pan
- Stove
- Knife
Possible output:
Egg Fried Rice
Ingredients:
- Rice: 150g
- Egg: 2 pieces
- Onion: 1/2 piece
Steps:
1. Heat the pan.
2. Prepare the onion.
3. Add rice.
4. Add the eggs.
5. Cook until done.
Nutrition:
Calories: ...
Protein: ...
Carbohydrates: ...
Fat: ...
The exact nutrition values are calculated by the application's nutrition engine rather than generated by Gemma.
Potential future improvements include:
- Better recipe retry/recovery when validation fails
- More comprehensive ingredient and unit conversion data
- Daily protein tracking
- Meal history
- Better ingredient input UX
- Ingredient inventory tracking
- Meal ranking based on protein/calorie goals
- More cooking constraints
- Improved UI
- Optional workflow orchestration
Meal Prepper is intentionally built around a simple principle:
Let the AI reason. Let deterministic code enforce the rules.
Gemma handles the fuzzy problem of deciding what meal could be made.
The application handles things that should not be guessed:
- Available ingredients
- Quantities
- Equipment constraints
- Unit conversion
- Nutrition calculations
This keeps the system useful while avoiding unnecessary reliance on the LLM for things that normal software can handle more reliably.
Add your chosen license here.