Author: arustogi

Progress:

• Made a trip to Aldi’s to test full pipeline and collect footage for demo video

• Successfully transitioned all component communication (profile processing, product scanning, meal recommendation, ingredient substitution) to MQTT broker

• Subsystems now fully decoupled and interact via MQTT publish/subscribe model.

• Ran extensive unit tests for each module

Next goals:

• Get ready for demo/demo video

Images:

Progress:

• Built a semantic product matcher using sentence-transformers (all-MiniLM-L6-v2) to match ingredient names with Aldi product listings.

• Filtered grocery list recommendations based on cosine similarity thresholds to avoid irrelevant matches.

Goals:

• Add product ranking logic based on nutritional tags (e.g., high protein, low sugar).
• Expand allergen support to include nested ingredients (e.g. “mayo” contains eggs).

For this update, I built out the logic that takes a meal plan and turns it into a personalized grocery list with real Aldi product suggestions. If the user has any allergens, our system catches those and swaps the ingredients out with safe alternatives, pulling real options using Spoonacular and Aldi’s product data. I also connected everything through MQTT, so now the backend listens for meal plans, processes them with allergy-aware substitutions, and sends back a clean grocery draft for the user to review.

Progress:

• Implemented logic to analyze meal plan ingredient lists and cross-reference against user allergens.
• Integrated substitution logic with a mapping function to recommend safe alternatives when allergens are detected.
• Integrated API to fetch 1–3 real Aldi products for each ingredient.

Goals:

• Finalizing dynamic frontend integration to reflect real product recommendations.

• Begin auto-updating the bill as products are added (real-time tallying).

Risks & Management

• Risk: With multiple components (LangChain, Spoonacular, barcode scanning, MQTT) now functioning independently, the risk lies in delays or errors during integration of the full end-to-end workflow.
• Management: A system-level integration plan is being developed. Tasks have been divided to ensure frontend and backend components communicate seamlessly through MQTT, and fallback logs are in place to trace errors.

Design Changes & Justification:

• Reorganized backend into modular components for easier testing and debugging.

• Added a persistent product object structure for better real-time tracking and removal from cart UI.

Progress:

• 3D printed outer shell for device

• Completed LangChain + OpenAI integration for dietary-specific meal plan generation

• Developed object structure for in-store ingredient tracking and real-time tally

• Frontend tested receiving product data

Work Accomplished:

• Completed a modular backend design that outlines the full data flow, from user profile intake to product tracking and budgeting. The system now supports clear separation of concerns across user_profile, meal_planner, ingredient_substitutor, grocery_tracker, product_scanner, and mqtt_handler
  • Successfully integrated LangChain with the GPT-4 model to extract dietary preferences, allergens, and cultural requirements from user input and generate personalized meal plans
  • Wrote standalone test files for each backend component to ensure correctness and maintainability

Progress Status:

I am now on track with the backend development roadmap. The foundation is built and tested. Modules are independently working, with API integrations functional. Code is modular and testable.

Goals:

• Complete MQTT-to-frontend integration with real hardware input.

• Connect product substitution logic with real scanned products.

• Worked on Allergen Filtering Module
  Developed and tested an NLP-based allergen detection function to parse ingredient lists and flag common allergens. Wrote a modular script that supports updates to allergen keywords and is usable with incoming Spoonacular ingredient strings.

• Tools Used: Python, Regular Expressions, unittest

• Next Week Goals:

  • Integrate the allergen detection with the existing barcode -> Spoonacular pipeline.

  • Connect to personalized allergens

  • Send flags via MQTT to frontend.

  • Begin testing on dietary profile filtering logic.

Progress:

• Successfully connected the Raspberry Pi to the HiveMQ Cloud MQTT broker.
• Implemented a robust publish-subscribe system to send scanned UPC data and receive product details.
• Developed and tested API calls to Spoonacular for retrieving product details, including title, brand, price, image, and ingredients.
• Published test UPC codes to HiveMQ Web Client to verify data flow from backend to frontend.
• Ensured that product information updates in real-time upon scanning new items.

Goals:

• Work closely with the frontend to integrate the correct API response format
• Implement caching for frequent scans to minimize redundant API requests

Progress:

Backend API Integration:

• Implemented barcode scanning API using Spoonacular UPC lookup instead of Open Food Facts, reducing API latency and improving product data accuracy.
• Optimized API usage by implementing Redis caching to store frequently scanned products and reduce redundant API calls.

Goals for Next Week:

Refine Allergen Detection & Database Structure

• Implement database indexing for faster allergen lookup queries.
• Test OpenAI API’s NLP model for edge cases in ingredient parsing.

Optimize Barcode Processing & API Calls

• Fine-tune Redis caching logic to prioritize frequently scanned items.
• Implement error handling & API fallback strategy if Spoonacular is unavailable.
• Expand the database to store scanned products for historical tracking.

I started building out the backend for SmartCart, focusing on getting the barcode scanning and meal plan updates working together. Using FastAPI, I set up the initial API endpoints to handle barcode scans, pull product details from the Open Food Facts (OFF) API, and return structured grocery data. To make meal plans adjust in real-time, I began integrating LangChain, which takes the scanned items, checks them against the planned meals, and queries Spoonacular for substitutions if an ingredient is missing. Next week I want to focus more on the database side, to set up a PostgreSQL schema to store scanned products, user dietary preferences, and updated meal plans, along with basic CRUD operations for easy data access. The main challenges are making sure FastAPI, LangChain, Spoonacular, and OFF API communicate smoothly, improving query efficiency, and ensuring grocery matching happens in real-time without delays.