DEV Community: Avinash Kumar

🦥 LazySummarizer Pro: Turn Group Chat Noise into Actionable Notes with Gemma

Avinash Kumar — Fri, 23 Oct 2026 11:05:55 +0000

Group chats are useful—until important information gets buried under dozens of messages. A deadline, a tentative plan, or one unanswered question can be surprisingly easy to miss.

For Hacktoberfest 2026 Week 3 — “Slow and Steady,” I built LazySummarizer Pro, a small AI-powered tool that turns a pasted group-chat transcript into a structured summary, so you spend less time scrolling and more time acting on what matters.

🔗 Source code: Avinash-sdbegin/lazy-summarizer-pro

💡 The idea: less scrolling, more clarity

Imagine opening a busy college group chat and needing to figure out:

What was actually decided?

Which tasks need to be completed?

Who owns each task, and was a deadline specified?

Which plans are still tentative?

What questions remain unanswered?

Instead of manually scanning the entire conversation, LazySummarizer Pro organizes the information into sections that are easier to review.

The goal isn't to replace reading or judgment. It's to make the first pass through a long conversation less tedious.

⚙️ How it works

The current prototype follows a simple workflow:

Provide a transcript: Paste chat text into the Gradio interface or use the sample conversation.

Process the text: Python sends the transcript to Google's Gen AI SDK.

Generate a summary: The app calls the hosted Gemma model gemma-4-26b-a4b-it.

Review structured results: The interface presents the generated summary and extracted information.

The output is organized around five useful categories:

📝 Quick Summary — the main points in a few bullets.

✅ Confirmed Decisions — decisions distinguished from proposals where possible.

📌 Action Items — tasks, owners, and deadlines, with missing information marked as Not specified.

❓ Open Questions — issues that still need an answer.

📅 Dates and Deadlines — dates and times mentioned in the conversation.

🧪 Example: keeping uncertainty intact

Consider this sample conversation:

Riya: I may send the report tomorrow.
Aman: We can meet next week if everyone is free.

A useful summary should preserve two important details:

Riya's report is a possibility, not a confirmed commitment.

The meeting is conditional on everyone's availability, and no exact meeting date has been agreed upon.

The model should not turn these messages into definite commitments or invent calendar dates. This is an important behavior to check when using AI for summarization.

📸 Screenshots

Dashboard
Summary Results

🌱 Why open-weight AI matters

For this project, I chose Gemma, Google's open-weight model family.

Open-weight models give developers more flexibility to explore model behavior and build on the model rather than relying only on a closed model offering. Depending on the model, its license, hardware, and deployment setup, developers can also investigate self-hosting, fine-tuning, or alternative inference arrangements.

There is an important distinction in my current implementation: LazySummarizer Pro uses Gemma through a hosted API. It does not run the model locally or operate offline. The transcript is sent to the API for processing.

This makes the project a practical starting point for experimenting with open-weight AI, while leaving room to explore local inference in a future version.

🛠️ Tech stack

Python — application logic

Google Gen AI SDK (google-genai) — model API integration

Gemma gemma-4-26b-a4b-it — text summarization

Gradio — user interface

Google Colab — development and testing environment

🚀 Try it or explore the code

The repository contains the runnable notebook, dependencies, screenshots, and setup instructions.

📂 GitHub repository

📓 Open the notebook file

📋 Read the setup instructions

To run the prototype, open the notebook in Google Colab, configure GEMMA_API_KEY using Colab Secrets, and execute the cells in order. The Gradio share URL is temporary and may expire when the runtime stops.

Never commit an API key or place private chat transcripts in a public repository.

🔭 What's next?

There are several areas I want to improve:

Add regression tests for missed deadlines, tentative plans, and conflicting messages.

Validate the generated output before displaying it.

Handle longer transcripts with chunking and cross-chunk context.

Evaluate summary quality on a documented collection of synthetic conversations.

Explore local inference and text or Markdown export.

⚠️ Limitations

LazySummarizer Pro is an educational prototype, not a guaranteed fact-checking system. It does not currently connect directly to WhatsApp or automatically read group chats; users provide the transcript themselves.

AI can omit details, misunderstand context, or present a tentative statement as a confirmed one. Relative dates such as “tomorrow” also need suitable date context to be interpreted correctly. Always review names, decisions, deadlines, and action items before relying on the result.

Because the current version uses a hosted API, avoid submitting sensitive or private messages unless you have permission and have reviewed the provider's applicable data-handling terms.

🦥 Final thoughts

LazySummarizer Pro is my take on the “Slow and Steady” theme: use AI to reduce repetitive work without pretending that human review is unnecessary.

This project gave me an opportunity to build a practical interface around Gemma, experiment with structured summarization, and identify the reliability and privacy trade-offs that come with hosted AI.

The next step is to make its summaries more consistent and evaluate them more systematically.

Thanks for reading! 🚀

Hacktoberfest #Gemma #Python #AI

🏪 Ranchi Dukaan Pro — Predicting Stock Demand with TabPFN-TS

Avinash Kumar — Fri, 23 Oct 2026 11:03:23 +0000

Smart Stock & Demand Predictor

Can an AI forecast help a small shopkeeper make better stocking decisions?

Small retailers have to decide what to reorder, how much stock to keep, and when to place the next order. Too little stock can mean missed sales, while too much inventory can tie up money or increase the risk of expiry and waste.

For the Hacktoberfest 2026 Open-Source AI Challenge: Week 2 — Side Hustle, I built Ranchi Dukaan Pro, a prototype that uses TabPFN-TS to estimate the next seven days of product demand and turn those estimates into simple inventory recommendations.

The goal is to explore whether a small, practical AI tool could be useful to a local kirana shop.

🛒 What I Built

Ranchi Dukaan Pro is a Python and Gradio dashboard where users can provide daily sales history and review their current inventory.

The prototype includes:

Seven-day demand forecasting for individual products using TabPFN-TS.
Editable inventory information, including current stock, incoming stock, supplier lead time, safety stock, and unit cost.
Restock recommendations that combine forecast demand with inventory rules.
Estimated order cost to help users review the financial impact of a suggested order.
Forecast evaluation comparing TabPFN-TS with a simple historical baseline.

The initial use case is deliberately narrow: helping a small kirana shop make more informed stock-planning decisions.

🧠 How It Works

The workflow is straightforward:

Enter daily sales history for each product.
Use TabPFN-TS to generate a seven-day demand forecast.
Check expected demand during the supplier's lead time.
Combine that estimate with current stock, incoming stock, and safety stock.
Display a suggested reorder quantity and its estimated cost.

The prototype uses this basic rule:

Reorder quantity = max(0, lead-time demand + safety stock - current stock - incoming stock)

The forecasting model estimates demand; the inventory formula makes the reorder recommendation. Keeping these parts separate makes the results easier to inspect and improve.

📊 What I Tested

I generated synthetic daily sales data for three example products: Milk 500 ml, Bread, and Rice 1 kg.

I then held out seven days of historical data and compared TabPFN-TS with a simple baseline that uses sales from the same weekday one week earlier.

The results from this single test window were:

Metric	TabPFN-TS	Simple baseline
Mean Absolute Error (MAE)	1.29 units	1.62 units
Weighted Absolute Percentage Error (WAPE)	9.18%	11.56%

The overall results favoured TabPFN-TS in this particular test window. However, the model did not outperform the baseline for every product: the baseline performed better for Bread.

Important limitation: these results come from synthetic data and one seven-day holdout. They do not establish real-world accuracy for Ranchi shops. More backtesting and evaluation on real sales records—with the business owner's permission—would be needed before relying on these forecasts for purchasing decisions.

🖥️ Try the Demo

Open Ranchi Dukaan Pro — Gradio Demo

The prototype lets you review sample sales, edit inventory quantities, generate forecasts, and inspect suggested orders.

The Gradio share link is temporary and may stop working when its session ends.

Source code: GitHub — ranchi-dukaan-pro

The repository includes the main application, setup information, and a downloadable project bundle.

🌱 Why Open-Source AI?

This project uses TabPFN-TS for its forecasting component. I wanted to explore a tabular/time-series model that can be inspected and adapted rather than building the entire application around a closed forecasting service.

The current prototype uses client/cloud inference; it does not claim to run entirely offline. This distinction matters because shop sales can be commercially sensitive. Before using real business data, it is important to review the provider's data-handling terms and get appropriate permission.

The wider opportunity with open-source AI is flexibility: developers can study the implementation, experiment with different approaches, and adapt a tool for a specific problem.

💼 Who Might Pay for It?

The intended users are small retailers who struggle to track demand and decide what to reorder.

A future version could offer an affordable subscription for features such as recurring forecasts, inventory reports, expiry-aware suggestions, and easier sales imports.

This is currently a business hypothesis, not validated demand. I have not yet established that a real shopkeeper would pay for this prototype. The next step is to show it to a local retailer, understand their current workflow, and learn whether the forecasts and recommendations would actually help.

🔧 What I Learned

Building this prototype reinforced three lessons:

A forecast is only useful when it supports a real decision.
A simple baseline is essential for evaluating whether a more sophisticated model adds value.
A successful demo on synthetic data is a starting point, not proof of business impact.

Next, I would like to test multiple historical windows, handle missing records and stock-outs more carefully, account for expiry and supplier constraints, and collect feedback from a real shopkeeper.

🌿 Final Thoughts

Ranchi Dukaan Pro is an early experiment in making demand forecasting more accessible to small retailers.

It is not yet a production inventory system, and its predictions should not be treated as guaranteed demand. But it provides a working starting point for exploring how open-source AI can support everyday business decisions.

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

devchallenge #hf26challenge #tabpfn #opensource

🏪 Ranchi Dukaan Pro — Predicting Stock Demand with TabPFN-TS

Avinash Kumar — Fri, 16 Oct 2026 03:21:32 +0000

Smart Stock & Demand Predictor

Can an AI forecast help a small shopkeeper make better stocking decisions?

Small retailers need to decide what to reorder, how much inventory to keep, and when to place orders. Too little stock can mean missed sales, while excess inventory can tie up cash and increase the risk of expiry or waste.

For the Hacktoberfest 2026 Open-Source AI Challenge: Week 2 — Side Hustle, I built Ranchi Dukaan Pro, a prototype that uses TabPFN-TS to estimate product demand over the next seven days and combine those estimates with simple inventory rules.

The goal is to explore whether a focused, affordable AI tool could help a local kirana shop make more informed stock-planning decisions.

🛒 What I Built

Ranchi Dukaan Pro is a Python and Gradio dashboard with the following features:

Seven-day demand forecasting for individual products using TabPFN-TS.
Editable inventory information, including current stock, incoming stock, supplier lead time, safety stock, and unit cost.
Restock recommendations that combine estimated demand with available inventory.
Estimated order costs to help users evaluate suggested purchase quantities.
Forecast evaluation comparing TabPFN-TS with a simple historical baseline.

The current prototype uses example products—Milk 500 ml, Bread, and Rice 1 kg—to demonstrate the complete workflow.

🧠 How It Works

The workflow is straightforward:

Load daily sales history for each product.
Use TabPFN-TS to generate a seven-day demand forecast.
Estimate demand during the supplier's lead time.
Combine that estimate with current stock, incoming stock, and safety stock.
Display a suggested reorder quantity and its estimated cost.

The stock recommendation uses this rule:

Reorder quantity = max(0, lead-time demand + safety stock - current stock - incoming stock)

The forecasting model estimates demand; a separate inventory calculation produces the reorder recommendation. The recommendation is a decision-support estimate, not an automatic purchase instruction.

📊 Sample Results

The sample forecast generated these estimated total sales over seven days:

Product	Estimated 7-day demand
Milk 500 ml	134 units
Bread	96 units
Rice 1 kg	49 units

Using the example inventory values, the application initially suggested:

Product	Suggested order	Estimated order cost
Milk 500 ml	13 units	₹312
Bread	9 units	₹252
Rice 1 kg	1 unit	₹52
Total	23 units	₹616

I also tested the editable inventory input: increasing the example milk stock from 10 to 30 units changed the recommended milk order from 13 units to zero and reduced the total estimated order cost from ₹616 to ₹304.

These are illustrative results using synthetic sales and example inventory values, not actual data from a Ranchi shop. The estimated order cost is not a demonstrated saving.

🧪 Forecast Evaluation

I generated synthetic daily sales data for three example products and held out the final seven days for testing. I compared TabPFN-TS with a simple baseline that uses sales from the same weekday one week earlier.

Evaluation	TabPFN-TS MAE	Baseline MAE	TabPFN-TS WAPE	Baseline WAPE
All products	1.29	1.62	9.18%	11.56%
Milk 500 ml	1.14	2.14	5.71%	10.71%
Bread	1.43	1.29	10.00%	9.00%
Rice 1 kg	1.29	1.43	16.67%	18.52%

Lower MAE and WAPE indicate lower prediction error. In this particular test window, the overall metrics favoured TabPFN-TS, but the simple baseline performed better for Bread.

Important limitation: this was one seven-day holdout on synthetic data. It does not establish real-world forecasting accuracy for local shops. Multiple backtesting windows and evaluation on real sales records, with the shop owner's permission, would be needed before relying on forecasts for purchasing decisions.

📸 Dashboard Screenshots

1. Main Dashboard

2. Inventory Editing Test

3. Forecast Results

🖥️ Try the Demo

Open Ranchi Dukaan Pro — Gradio Demo

The prototype lets users review the sample data, edit inventory values, generate forecasts, and inspect restock suggestions.

The Gradio share link is temporary and may stop working when its session ends.

Source code and evaluation files: GitHub — ranchi-dukaan-pro

The repository contains the application, setup instructions, sample CSV files, screenshots, and synthetic-data evaluation outputs.

🌱 Why Open-Source AI?

I used TabPFN-TS to explore time-series forecasting through an open-source implementation instead of building the entire application around a closed forecasting service.

The current prototype uses client/cloud inference. It does not claim to run entirely offline, and users should review the provider's data-handling terms before sending commercially sensitive sales records for inference.

Open-source tools provide room to inspect the implementation, experiment with alternatives, and adapt the surrounding application to a particular use case. However, model selection alone does not guarantee accuracy or business value; evaluation remains essential.

💼 Who Might Pay for It?

The intended users are small retailers who find it difficult to track demand and decide when to reorder inventory.

A future version could explore an affordable subscription with recurring forecasts, inventory reports, expiry-aware suggestions, and easier sales imports.

This is a business hypothesis, not validated customer demand. I have not yet established that a real shopkeeper would pay for this prototype. The next step is to demonstrate it to a local retailer, understand their current workflow, and learn whether the forecasts and recommendations are genuinely useful.

🔧 What I Learned

This project reinforced three lessons:

A forecast becomes more useful when it supports a concrete business decision.
A simple baseline helps establish whether a more complex model adds value.
A working demo on synthetic data is a starting point, not proof of real-world impact.

Future improvements include walk-forward evaluation across multiple time windows, better handling of missing records and stock-outs, expiry-aware ordering, supplier constraints, and usability testing with a local shopkeeper.

🌿 Final Thoughts

Ranchi Dukaan Pro is an early experiment in making demand forecasting and stock planning more accessible to small retailers.

It is an educational and hackathon prototype, not a production inventory system. Its predictions may be wrong, and its real-world usefulness remains to be validated.

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

🌿 Ranchi EcoRoute — An Outdoor Activity Planner Powered by Google Gemma

Avinash Kumar — Wed, 07 Oct 2026 05:49:25 +0000

Plan quickly. Go outside. Touch grass. 🌱

Students often decide they want to go outside, but spend more time deciding what to do than actually doing it.

For the Hacktoberfest 2026 Open-Source AI Challenge: Week 1, themed Touch Grass, I built Ranchi EcoRoute — a small AI-powered outdoor activity planner that turns a few seconds of planning into a practical activity plan.

The idea is simple:

Use the screen briefly to make a plan, then put the phone away and go outside.

🤔 What I Built

Ranchi EcoRoute asks the user for:

Outdoor activity
Available time
Energy level
Optional custom activity

It then uses Google's Gemma open-weight model to generate:

A suggested outdoor activity
A suitable type of place
A time-based activity plan
Things to carry
Basic safety tips
A screen-break goal

The project is intentionally simple because the screen should be the shortest part of the experience.

🧠 How It Works

User Input
(Activity + Time + Energy)
        |
        v
   Google Gemma
        |
        v
Outdoor Activity Plan
        |
        v
Suggested Place Type
+ Time-based Plan
+ What to Carry
+ Safety Tips
+ Screen Break Goal
        |
        v
     Gradio UI

Gemma handles the natural-language generation of the outdoor plan.

Python validation and prompt constraints are used to keep the generated plan aligned with the user's available time and energy.

The project does not claim to provide live weather, traffic, opening hours, or real-time route information.

🌱 The Touch Grass Idea

The core idea behind the project is:

Less screen time
       ↓
Quick plan
       ↓
Go outside
       ↓
More real-world activity

Instead of building another tool that keeps users inside an app, I wanted the app to make itself unnecessary as quickly as possible.

🖥️ Demo

The prototype runs in Google Colab and launches a Gradio web interface.

Example

Outdoor Activity:
Morning Walk

Time Available:
45 minutes

Energy Level:
Low

Gemma generated a structured plan with a short walking schedule, suggested place type, things to carry, safety tips, and a screen-break goal.

Live Demo

🌿 Open Ranchi EcoRoute

⚠️ The Gradio share link is temporary. The source code and screenshots are available in the GitHub repository.

🧪 Testing

I tested the prototype with multiple activity configurations.

Morning Walk

Input:

45 minutes
Low energy

The model generated a short nature-oriented walking plan suitable for the available time and energy level.

Nature Photography

Input:

60 minutes
Medium energy

The model generated a photography-focused outdoor plan with a time breakdown, things to carry, safety tips, and a screen-break goal.

These tests helped verify that the generated plan changes according to the user's activity, available time, and energy level.

🌱 Why Open Innovation & Gemma Matter

Ranchi EcoRoute uses Google's Gemma, an open-weight model, as the core AI component.

I wanted the model to handle the actual natural-language planning rather than simply placing an AI chatbot inside a conventional interface.

An open-weight approach also leaves room for future experimentation such as:

Swapping models
Adapting the model for local use cases
Exploring local or offline inference
Running the model in more constrained environments

The interesting part is that the AI is used for planning, while the real goal happens away from the screen.

📸 Screenshots

Morning Walk

Nature Photography

📚 What I Learned

The biggest lesson from this project was that a useful AI application does not need to be complicated.

A small set of inputs, a focused prompt, and a simple interface can turn a general-purpose model into a useful tool for a specific real-world goal.

I also learned that an AI product can be more meaningful when its purpose is to reduce screen time rather than increase it.

🔮 Future Improvements

Real-time weather integration
Verified local place information
Map-based route suggestions
Offline/local Gemma inference
Personalized activity history
Better accessibility support
Group activity planning
More detailed outdoor difficulty levels

📁 Source Code

GitHub:

https://github.com/Avinash-sdbegin/ranchi-ecoroute

The repository contains the Colab notebook, README, and screenshots.

⚠️ Safety & Limitations

This is an educational and hackathon prototype.

It does not provide live weather information, real-time traffic information, live route tracking, verified opening hours, or medical advice.

Always verify weather, location access, local conditions, and personal safety before heading outdoors.

Built for the Hacktoberfest Open-Source AI Challenge: Week 1 — Touch Grass 🌿

devchallenge #hf26challenge #gemma

🍛 Khana Kya Hai? — Ranchi Hostel Mess & Allergy Planner with Google Gemma

Avinash Kumar — Sat, 03 Oct 2026 06:28:49 +0000

"Aaj mess mein kya kha sakta hoon?"

That is a simple question, but hostel mess menus become much harder to deal with when someone has a food allergy, intolerance, or dietary restriction.

For the Hacktoberfest 2026 Weekend Challenge: Build for a Friend, I built Khana Kya Hai?, a small AI-powered hostel mess planner that helps turn a daily mess menu into practical avoid, verify, and suitable-looking options.

🤝 Building for a Friend

I built this around a real hostel problem faced by a friend.

In a hostel, students often do not get detailed ingredient information for every dish. Even when a dish looks safe, its ingredients or cooking method may be unclear.

The goal of Khana Kya Hai? is not to provide medical advice. Instead, it helps a student organize the available menu and identify which items should be avoided, which need verification, and which appear suitable based on the information provided.

I also showed the prototype to my hostel roommate Rahul, who deals with dairy sensitivities. He found the practical backup suggestions useful because hostel mess staff may not always be able to change the cooking method for an individual request.

✨ What I Built

Khana Kya Hai? takes four inputs:

Today's hostel mess menu
Allergies or intolerances
Dietary preference
Daily food budget

It then uses Google's Gemma open-weight model to analyze the menu and generate a structured recommendation.

The interface is built with Gradio and runs from a Google Colab notebook.

🧠 How It Works

User Input
   |
   v
Mess Menu + Allergy + Diet + Budget
   |
   v
Google Gemma 4 31B
   |
   v
Menu Analysis
   |
   v
Python Safety / Consistency Layer
   |
   v
Final Recommendation

Gemma handles the natural-language reasoning around the menu.

A separate Python layer performs deterministic checks for known allergy-related keywords and cleans the model output.

This extra layer also helps prevent contradictions, such as recommending a menu item after it has already been placed in the avoid list.

The application separates results into:

AVOID — the item conflicts with the provided restriction
VERIFY — ingredients or preparation are uncertain
SUITABLE-LOOKING — the item appears compatible based on the available information

🛡️ Why Add a Deterministic Layer?

Generative AI is flexible, but food restrictions are a situation where blindly displaying generated text is not a good design.

Khana Kya Hai? therefore keeps explicit keyword-based checks outside the model.

For example, dairy-related inputs can expand into related terms such as:

milk
dairy
paneer
cheese
butter
cream
curd
yogurt
kheer
ghee

The Python layer checks the generated categories against these terms and removes contradictory suitable/recommended results when an item is identified as conflicting with the provided restriction.

This is not a medical safety guarantee. It is a deterministic consistency layer around a generative model.

🖥️ Demo

🔗 Live Demo

Open Khana Kya Hai?

Example Input

Today's Mess Menu:
Aloo Paratha, Paneer Butter Masala, Rice, Dal, Kheer

Allergy:
Milk / Dairy

Diet:
Vegetarian

Budget:
₹100

Example Output

Avoid:
- Paneer Butter Masala
- Kheer

Verify:
- Aloo Paratha
- Dal

Suitable-looking:
- Rice

Recommended Meal:
- Rice

The application can also provide a low-cost alternative when the available mess menu does not fit the user's restrictions.

🧪 Testing

I tested the prototype with several hostel-style cases:

Dairy restriction

The application identified clearly dairy-heavy items such as paneer-based dishes and kheer for avoidance, while uncertain preparation cases such as paratha or dal could be placed under verification.

Peanut restriction

The application was tested with peanut as a restriction and checked that unrelated menu items were not automatically classified as peanut-containing.

Vegetarian preference

When a menu included chicken curry and the selected diet was vegetarian, the application classified chicken as an item to avoid and did not recommend it as a meal.

Consistency testing

I also tested cases where an item could potentially appear in both an unsafe category and a recommendation. The Python consistency layer was added to reduce that kind of contradiction.

💰 Practical Alternatives

When the available mess menu does not fit the user's restrictions, the prototype can suggest a simple low-cost backup option.

Current alternatives include:

Banana + Roasted Chana — ₹25
Aloo Sandwich — ₹40
Peanut + Banana — ₹25
Plain Rice + Ready-to-eat Dal — ₹45

These are application-defined alternative estimates, not prices claimed for the hostel mess.

The alternative logic also avoids the peanut option when peanut is provided as an allergy.

🌱 Why Open Innovation & Gemma Matter

This project uses Google's Gemma, an open-weight model, as the core AI component.

What interested me was using the model for the actual natural-language reasoning around messy hostel menu descriptions rather than simply adding an AI chatbot to the interface.

An open-weight approach also leaves room for future experimentation such as swapping models, adapting the model, or moving toward local inference.

For a project involving personal food restrictions, that future possibility is particularly interesting because local inference could reduce the need to send such information to an external service.

👥 Feedback From My Hostel Friend

After I showed the prototype to my hostel roommate Rahul, he liked the idea of having practical backup suggestions when the hostel mess cannot easily change its ingredients or cooking method.

His feedback made me think beyond simply identifying foods and focus more on what a student can realistically do when the menu does not fit their restrictions.

🏆 Hacktoberfest 2026

This project was built for the Hacktoberfest Weekend Challenge: Build for a Friend.

Submission Category

Best Use of Gemma

The project uses Google's Gemma as its core AI model and explores how an open-weight model can be used to solve a small, practical hostel problem.

The challenge asks participants to build a new project with open-source AI at its core, explain why open innovation matters, and show who the project was built for. :chatgpt-content-reference{index="4"}

📸 Screenshots

Home Interface

Dairy Allergy Test

🔐 API Key Handling

The API key is not stored in the GitHub repository.

For the Colab version, the key is stored using Google Colab Secrets.

Create:

GEMMA_API_KEY

and enable notebook access.

▶️ How to Run

Open khana_kya_hai.ipynb in Google Colab.
Add your Google AI Studio API key to Colab Secrets using:

GEMMA_API_KEY

Run the notebook cells in order.
Enter:

Mess menu
Allergies / intolerances
Dietary preference
Daily food budget

Click:

Analyze My Food

The notebook launches the Gradio interface.

📁 Source Code

GitHub Repository:

https://github.com/Avinash-sdbegin/khana-kya-hai

The repository contains the Colab notebook, README, and project screenshots.

📚 What I Learned

The biggest lesson from this project was that adding a language model is only one part of building a useful application.

The more interesting part was combining:

Generative AI
      +
Deterministic Python Rules
      +
Simple Human-Centered UI

Gemma provides flexible natural-language reasoning, while the Python layer provides predictable checks for known allergy-related terms.

Building this for an actual hostel use case also helped me think more about practical constraints instead of designing only for a technical demo.

🔮 Future Improvements

Better ingredient and allergen detection
Hostel-specific menu history
More accurate price estimation
Weekly meal planning
Local/offline model support
Personalized food preferences
Better handling of regional Indian dishes
More detailed cross-contact detection

⚠️ Safety Note

Khana Kya Hai? is an educational and hackathon prototype.

It is not a medical or allergy-diagnosis system and should not be treated as one.

Food ingredients, recipes, cooking methods, and cross-contact can vary between messes. Users should always verify ingredients, cooking medium, and possible cross-contact with the food provider before eating.