RecoSense 🚀

Find Exactly What You'll Love Tomorrow

A production-grade, full-stack e-commerce marketplace powered by a dual-mode hybrid recommendation engine,
combining LightFM collaborative filtering, RoBERTa sentiment analysis, and a Groq-powered AI Consultant.

Quick Start » Engine Deep-Dive » Deploy Guide »

🔭 Overview

RecoSense is a premium, AI-driven electronics marketplace that transforms traditional e-commerce browsing into an intelligent product discovery experience. Built as a B.Tech Project (BTP), the system demonstrates advanced concepts in:

Hybrid Recommendation Systems — combining collaborative filtering with content-based features
Aspect-Based Sentiment Analysis (ABSA) — extracting granular product insights from user reviews
LLM-Powered Shopping Assistance — real-time conversational product analysis via Groq
Production-Grade Full-Stack Engineering — JWT auth, caching, CI/CD, and cloud deployment

The platform serves a catalog of electronics products with intelligent discovery features that adapt to each user's behavior, preferences, and demographic profile in real time.

🌟 Key Features

🧠 Intelligence & Analytical Discovery

Feature	Description
AI Consultant (Groq)	LLM-powered assistant (Llama 3.3 70B via Groq API) providing real-time product analysis, pros/cons summaries, and multi-turn conversational follow-ups grounded in actual review sentiment data.
Hybrid Recommendation Engine	Dual-mode engine using LightFM for matrix factorization with WARP loss and ABSA feature vectors from RoBERTa for content-aware hybrid filtering.
Aspect-Based Sentiment Analysis	RoBERTa (Robustly Optimized BERT Pretraining Approach) processes review text to extract per-aspect scores (Battery, Camera, Screen, Price, Software, Build Quality) used as item feature vectors.
Smart Cold-Start Resolution	New users receive curated recommendations via demographic profiling (age group + gender popularity), with graceful fallback to global trending products.
Auto-Triggered Retraining	Counter-based pipeline tracks user interactions (likes + reviews) and automatically recomputes recommendations when the configurable threshold is reached.
Dual Computation Modes	Level 1 (Quick Re-run): ~5s Node.js popularity heuristic. Level 2 (Heavy Retrain): ~30-60s Python LightFM deep learning pipeline.

🎨 Premium User Experience

Feature	Description
Cinematic Dark Theme	Modern design system with glassmorphism, CSS custom properties, and fluid animations via Framer Motion.
Responsive Design	Mobile-first layouts across all pages with collapsible navigation, adaptive grids, and touch-friendly interactions.
AI Chat Modal	In-product AI assistant with conversation history, streaming-like UX, and context-aware responses.
Scroll-to-Top	Automatic scroll restoration on route changes for seamless navigation.
Accessibility	ARIA attributes, `focus-visible` outlines, lazy-loaded images, and semantic HTML throughout.

🛒 E-Commerce Marketplace

Feature	Description
Product Catalog	Paginated, searchable product browsing with high-detail cards, category filtering, and sorting options.
Product Detail Pages	Rich product views with image galleries, description panels, community reviews, and integrated AI analysis.
Wishlist System	Real-time like/unlike with global state synchronization (UserContext) — persisted across sessions.
Shopping Cart	Full cart system with quantity management, price calculations, and persistent state (CartContext).
Checkout & Orders	Complete checkout flow with order creation, order history, status tracking, and detailed order views.
Review System	Submit, browse, and manage reviews with star ratings — reviews feed into the ABSA pipeline for improved recommendations.
User Profiles	Profile management with personal info editing, demographic data, and activity history.
Authentication	Secure JWT-based auth with bcrypt password hashing, login/register, and password change flows.
Admin Dashboard	Role-based admin panel for triggering model runs, monitoring system status, resetting counters, and managing inventory.

🛠️ Tech Stack

Frontend

Technology	Version	Purpose
React	19.1	UI component library
Vite	7.1	Build tool & dev server
React Router DOM	7.9	Client-side routing with protected routes
Framer Motion	12.34	Animations, transitions, and micro-interactions
Axios	1.12	HTTP client for API communication
Lucide React	0.564	Modern icon library
Vanilla CSS	—	Design system with CSS custom properties, glassmorphism, dark theme tokens

Backend

Technology	Version	Purpose
Node.js	18+	Runtime environment
Express	5.1	Web framework & REST API
MongoDB	—	Document database (via Mongoose 8.18 ODM)
Redis	5.11 (client)	Response caching layer with in-memory fallback
JWT	9.0	Stateless authentication tokens
bcryptjs	2.4	Password hashing
Groq SDK	0.37	LLM API integration for AI Consultant
node-cron	3.0	Scheduled retraining jobs
CORS	2.8	Cross-origin request handling
dotenv	17.2	Environment variable management

AI / ML (Python)

Technology	Purpose
LightFM	Hybrid collaborative + content-based filtering with WARP loss
RoBERTa (HuggingFace Transformers)	Aspect-Based Sentiment Analysis for feature extraction
Pandas	Data manipulation & interaction matrix construction
NumPy	Numerical computations
SciPy	Sparse matrix operations for LightFM
PyMongo	Direct MongoDB access from Python training scripts

DevOps & Infrastructure

Technology	Purpose
GitHub Actions	CI/CD pipeline (build validation + Render deploy triggers)
Render	Cloud hosting (Web Service + Static Site)
Vercel	Alternative frontend hosting (with `vercel.json` config)
Nodemon	Development hot-reload
ESLint	Code quality and linting

🏗️ System Architecture

graph TD
    subgraph "Frontend (React 19 + Vite 7)"
        A[Landing Page] --> B[Product Catalog]
        B --> C[Product Detail + AI Chat]
        B --> D[Wishlist / Cart / Orders]
        A --> E[Auth: Login / Register]
        B --> F[Recommendations Page]
        B --> G[Admin Dashboard]
    end

    subgraph "Backend (Express 5 API)"
        H[API Gateway + CORS + JWT Auth]
        H --> I[Product Controller]
        H --> J[User Controller]
        H --> K[Review Controller]
        H --> L[Recommendation Controller]
        H --> M[AI Controller - Groq]
        H --> N[Cart Controller]
        H --> O[Order Controller]
        H --> P[Admin Controller]
    end

    subgraph "Data Layer"
        Q[(MongoDB Atlas)]
        R[(Redis Cache)]
        S[lightfm_recs.json]
        T[retrain_counters.json]
    end

    subgraph "ML Pipeline (Python)"
        U[train_lightfm.py]
        V[ABSA Feature Vectors]
        W[LightFM Model Training]
    end

    C --> H
    D --> H
    F --> H
    G --> H

    L --> S
    L --> Q
    L --> R
    M -->|Llama 3.3 70B| X[Groq Cloud API]

    I --> Q
    J --> Q
    K --> Q
    N --> Q
    O --> Q

    L -->|Threshold Trigger| Y[RetrainManager]
    Y -->|Level 1: Quick Re-run| Z[Node.js Inference]
    Y -->|Level 2: Heavy Retrain| U
    U --> V
    V --> W
    W --> S
    Z --> S

Request Flow

Client Request
  → React Router (protected routes)
    → Axios (with JWT header)
      → Express API Gateway
        → CORS validation
          → JWT middleware (auth.js)
            → Controller logic
              → MongoDB / Redis / JSON file reads
                → Response with caching headers

🧠 Recommendation Engine

The engine operates in a dual-mode architecture with automatic threshold-based triggering:

Level 1 — Quick Re-run (Node.js)

Attribute	Detail
Language	JavaScript (Node.js)
Speed	< 5 seconds
CPU Usage	Minimal
Algorithm	Weighted popularity heuristic with personal filtering
Trigger	Auto (every N interactions) or manual via Admin Panel

Pipeline: Merge historical reviews + live MongoDB likes → Compute global popularity scores → Filter per-user (remove already-interacted) → Enrich with metadata → Write lightfm_recs.json → Sync to MongoDB.

Level 2 — Heavy Retrain (Python LightFM)

Attribute	Detail
Language	Python 3.8+
Speed	30–60 seconds
CPU Usage	High (matrix factorization)
Algorithm	LightFM hybrid filtering with WARP loss + ABSA feature vectors
Trigger	Admin Panel click, CLI, or scheduled via cron

Pipeline: Load ABSA feature vectors from RoBERTa → Build sparse interaction matrix → Train LightFM (20-30 epochs, WARP loss) → Batch predict Top-20 per user → Write lightfm_recs.json → Bulk update MongoDB.

Recommendation Priority Logic

1. LightFM precomputed  →  User has ≥ LIGHTFM_THRESHOLD interactions & recs file exists
2. Demographic popularity →  User has age_group + gender → popular items in cohort  
3. Global popularity     →  Fallback for new users with no profile data

Auto-Trigger Pipeline

User likes a product or submits a review
  → incrementCounter('like' | 'review')
    → if (pending >= MODEL_RUN_THRESHOLD)
      → startModelRun() (async, non-blocking)
        → Recompute all recommendations
          → Reset counters to 0

🤖 AI Consultant

The AI Consultant is powered by Groq's Llama 3.3 70B Versatile model and provides two capabilities:

1. Product Analysis (`GET /api/ai/analyze/:asin`)

Fetches product details + aggregated ABSA sentiment scores from MongoDB
Generates structured output: Summary, 3 Pros, 2 Cons
Grounded in actual community review data (not hallucinated)

2. Conversational Follow-up (`POST /api/ai/ask`)

Multi-turn conversation with full message history
Context-aware responses anchored to the specific product
Temperature 0.7 for natural, varied responses

📁 Project Structure

RecoSense/
├── .github/
│   └── workflows/
│       └── ci-render-deploy.yml       # CI/CD: Build + Render deploy triggers
│
├── backend/
│   ├── server.js                      # Express app entry, CORS, MongoDB, cron
│   ├── package.json                   # Node.js dependencies
│   ├── seed.js                        # Database seeding (users, products, reviews)
│   ├── seed_full.js                   # Extended seed with full dataset
│   ├── createAdmin.js                 # Quick admin account creation
│   ├── simulate_interactions.js       # Generate test interactions
│   │
│   ├── controllers/
│   │   ├── productController.js       # CRUD, search, pagination, bulk fetch
│   │   ├── userController.js          # Auth (login/register), profile, likes
│   │   ├── reviewController.js        # Review submission & retrieval
│   │   ├── recommendationController.js # Rec logic, priority selection, merging
│   │   ├── aiController.js            # Groq AI analysis & chat
│   │   ├── cartController.js          # Cart CRUD operations
│   │   ├── orderController.js         # Order creation & history
│   │   └── adminController.js         # Admin inventory management
│   │
│   ├── models/
│   │   ├── userModel.js               # User schema (demographics, likes, admin)
│   │   ├── productModel.js            # Product schema (ASIN, metadata, pricing)
│   │   ├── reviewModel.js             # Review schema (ratings, ABSA scores)
│   │   ├── cartModel.js               # Shopping cart schema
│   │   ├── orderModel.js              # Order schema (items, totals, status)
│   │   ├── recommendationModel.js     # Cached recommendations
│   │   └── systemConfigModel.js       # System state & retrain status
│   │
│   ├── routes/
│   │   ├── productRoutes.js           # /api/products
│   │   ├── userRoutes.js              # /api/user
│   │   ├── reviewRoutes.js            # /api/reviews
│   │   ├── recommendationRoutes.js    # /api/recommendations
│   │   ├── aiRoutes.js                # /api/ai
│   │   ├── cartRoutes.js              # /api/cart
│   │   ├── orderRoutes.js             # /api/orders
│   │   └── adminRoutes.js             # /api/admin
│   │
│   ├── middleware/
│   │   ├── auth.js                    # JWT verification middleware
│   │   └── requireAdmin.js            # Admin role-gating middleware
│   │
│   ├── recommender/
│   │   ├── retrainManager.js          # Dual-mode engine orchestrator
│   │   ├── train_lightfm.py           # Python LightFM training script
│   │   ├── requirements.txt           # Python deps (lightfm, pandas, scipy...)
│   │   ├── retrain_status.json        # Model run status tracking
│   │   ├── retrain_counters.json      # Interaction counter state
│   │   └── logs/                      # Model run stdout/stderr logs
│   │
│   ├── utils/
│   │   └── cacheManager.js            # Redis + in-memory cache abstraction
│   │
│   ├── data/
│   │   ├── filtered_smartphone_reviews.json    # Historical review corpus
│   │   ├── filtered_smartphone_metadata.json   # Product metadata
│   │   └── lightfm_recs.json                   # Precomputed recommendations
│   │
│   └── tools/
│       ├── set_admin.js               # CLI: Grant admin privileges
│       ├── create_admin_user.js       # CLI: Create admin account
│       ├── set_default_passwords.js   # CLI: Reset user passwords
│       └── add_likes.js              # CLI: Add test likes
│
├── frontend/
│   ├── index.html                     # SPA entry point
│   ├── vite.config.js                 # Vite build configuration
│   ├── vercel.json                    # Vercel deployment config
│   ├── STYLEGUIDE.md                  # Design tokens & component guidelines
│   │
│   └── src/
│       ├── main.jsx                   # React DOM render + providers
│       ├── App.jsx                    # Route definitions + layout
│       ├── index.css                  # Global design system (68KB+ tokens)
│       ├── App.css                    # App-level overrides
│       │
│       ├── pages/
│       │   ├── Landing.jsx            # Hero landing page with animations
│       │   ├── Home.jsx               # Product catalog with search & filters
│       │   ├── ProductDetail.jsx      # Rich product view + AI chat
│       │   ├── Recommendations.jsx    # Personalized recommendation feed
│       │   ├── LikedProducts.jsx      # Wishlist dashboard
│       │   ├── MyReviews.jsx          # User review management
│       │   ├── Cart.jsx               # Shopping cart
│       │   ├── Checkout.jsx           # Checkout flow
│       │   ├── Orders.jsx             # Order history & tracking
│       │   ├── Profile.jsx            # User profile management
│       │   ├── Login.jsx              # Authentication
│       │   ├── Register.jsx           # User registration (with demographics)
│       │   ├── ChangePassword.jsx     # Password change form
│       │   └── AdminPanel.jsx         # Admin controls & system monitoring
│       │
│       ├── components/
│       │   ├── Navbar.jsx             # Responsive nav with mobile toggle
│       │   ├── Footer.jsx             # Global footer
│       │   ├── ProductCard.jsx        # Product display card with like button
│       │   ├── ReviewCard.jsx         # Review display component
│       │   ├── AddReviewForm.jsx      # Review submission form
│       │   ├── AIChatModal.jsx        # AI Consultant chat interface
│       │   └── ScrollToTop.jsx        # Route-change scroll restoration
│       │
│       ├── context/
│       │   ├── UserContext.jsx        # Auth state, user profile, wishlist sync
│       │   └── CartContext.jsx        # Cart state management
│       │
│       ├── services/
│       │   └── api.js                 # Axios API client (all endpoints)
│       │
│       └── styles/
│           ├── Profile.css            # Profile page styles
│           ├── Cart.css               # Cart page styles
│           ├── Checkout.css           # Checkout page styles
│           └── Orders.css             # Orders page styles
│
├── render.yaml                        # Render IaC deployment config
├── RECOMMENDATION_SYSTEM.md           # Complete engine documentation (1000+ lines)
├── QUICK_RE_RUN.md                    # Level 1 engine documentation
├── LIGHTFM_RETRAIN.md                 # Level 2 engine documentation
├── DEPLOY.md                          # Deployment guide (Render, Vercel, single-service)
└── .gitignore

🚀 Quick Start

Prerequisites

Requirement	Version	Notes
Node.js	18+	Required
MongoDB	6+	Local instance or MongoDB Atlas
Python	3.8+	Optional — only needed for Level 2 Heavy Retrain
Redis	7+	Optional — falls back to in-memory cache
Groq API Key	—	Optional — needed for AI Consultant feature

1. Clone & Install

git clone https://github.com/ateebarman/RecoSense.git
cd RecoSense

# Install backend dependencies
cd backend
npm install

# Install frontend dependencies
cd ../frontend
npm install

2. Configure Environment

Create a .env file in the backend/ directory:

# ─── Required ───────────────────────────────
MONGO_URI=mongodb://localhost:27017/recommender_db
PORT=5001

# ─── Authentication ─────────────────────────
JWT_SECRET=your_super_secret_key_here

# ─── AI Consultant (optional) ───────────────
GROQ_API_KEY=your_groq_api_key

# ─── Recommendation Thresholds ──────────────
MODEL_RUN_THRESHOLD=10       # Interactions before auto-trigger
LIGHTFM_THRESHOLD=3          # Interactions to use LightFM recs

# ─── Demographic Weighting ──────────────────
DEMO_LIKED_WEIGHT=4.0        # Weight for likes in popularity calc
DEMO_REVIEW_WEIGHT=1.0       # Weight for reviews in popularity calc

# ─── Admin Configuration ────────────────────
ADMIN_USERS=TEST_USER_101
ADMIN_SECRET=your_admin_secret

# ─── Caching (optional) ─────────────────────
REDIS_URL=redis://localhost:6379

# ─── Scheduled Retrain (optional) ───────────
RETRAIN_CRON=0 3 * * *       # Daily at 03:00

# ─── Frontend Serving (optional) ────────────
SERVE_FRONTEND=false
FRONTEND_URL=http://localhost:5173

3. Setup Python Environment (Optional — Level 2 only)

cd backend
python -m venv ../.venv

# Windows
..\.venv\Scripts\activate

# macOS / Linux
source ../.venv/bin/activate

pip install -r recommender/requirements.txt

4. Seed Database & Run

# In backend directory
npm run seed           # Seed users, products, and reviews
npm run create-admin   # Create admin account (user_id: 1, password: 123456)
npm run dev            # Start API server with hot-reload (port 5001)

# In frontend directory (new terminal)
npm run dev            # Start Vite dev server (port 5173)

5. Open in Browser

Navigate to http://localhost:5173 — you'll see the landing page. Log in with:

Field	Value
User ID	`1`
Password	`123456`

⚙️ Environment Variables

Variable	Required	Default	Description
`MONGO_URI`	✅	—	MongoDB connection string
`PORT`	❌	`5001`	API server port
`JWT_SECRET`	⚠️	Fallback	Secret for JWT signing (set in production!)
`GROQ_API_KEY`	❌	—	Groq API key for AI Consultant
`MODEL_RUN_THRESHOLD`	❌	`10`	Interactions before auto model run
`LIGHTFM_THRESHOLD`	❌	`3`	Interactions needed to use LightFM recs
`DEMO_LIKED_WEIGHT`	❌	`4.0`	Weight for likes in popularity scoring
`DEMO_REVIEW_WEIGHT`	❌	`1.0`	Weight for reviews in popularity scoring
`ADMIN_USERS`	❌	—	Comma-separated admin user IDs
`ADMIN_SECRET`	❌	—	Secret for admin registration
`REDIS_URL`	❌	—	Redis connection URL (falls back to memory)
`RETRAIN_CRON`	❌	—	Cron expression for scheduled retrains
`SERVE_FRONTEND`	❌	`false`	Serve frontend from backend (single-service)
`FRONTEND_URL`	❌	—	Frontend URL for CORS
`VITE_API_URL`	❌	`/api`	Backend API URL (set in frontend)
`PYTHON_EXECUTABLE`	❌	Auto-detect	Path to Python venv executable

📡 API Reference

Authentication

Method	Endpoint	Auth	Description
`POST`	`/api/user/register`	❌	Register new user (with demographic data)
`POST`	`/api/user/login`	❌	Login → returns JWT token
`GET`	`/api/user/me`	🔐 JWT	Get authenticated user profile
`POST`	`/api/user/change-password`	🔐 JWT	Change password

Products

Method	Endpoint	Auth	Description
`GET`	`/api/products`	❌	List products (paginated, searchable)
`GET`	`/api/products/:asin`	❌	Get product by ASIN
`GET`	`/api/products/bulk`	❌	Bulk-fetch multiple products by ASINs

User Interactions

Method	Endpoint	Auth	Description
`PUT`	`/api/user/:user_id/like`	🔐	Toggle product like (auto-increments counter)
`POST`	`/api/reviews`	🔐	Submit a review (auto-increments counter)
`GET`	`/api/reviews`	❌	Get reviews (by product or user)

Recommendations

Method	Endpoint	Auth	Description
`GET`	`/api/recommendations`	🔐	Get personalized recommendations
`POST`	`/api/recommendations/model/run`	🔐 Admin	Trigger infer-only model run
`GET`	`/api/recommendations/retrain/status`	❌	Check model run status
`GET`	`/api/recommendations/model/counters`	🔐 Admin	View interaction counters
`POST`	`/api/recommendations/model/counters/reset`	🔐 Admin	Reset counters
`POST`	`/api/recommendations/retrain`	🔐 Admin	Trigger full LightFM retrain
`POST`	`/api/recommendations/retrain/clean`	🔐 Admin	Clean stale users from recs file

AI Consultant

Method	Endpoint	Auth	Description
`GET`	`/api/ai/analyze/:asin`	🔐	AI product analysis (summary, pros, cons)
`POST`	`/api/ai/ask`	🔐	Conversational follow-up question

Cart & Orders

Method	Endpoint	Auth	Description
`GET`	`/api/cart`	🔐	Get user's cart
`POST`	`/api/cart/add`	🔐	Add item to cart
`PUT`	`/api/cart/update`	🔐	Update cart item quantity
`DELETE`	`/api/cart/remove`	🔐	Remove item from cart
`POST`	`/api/orders`	🔐	Create order from cart
`GET`	`/api/orders`	🔐	Get order history
`GET`	`/api/orders/:id`	🔐	Get order details

Admin

Method	Endpoint	Auth	Description
`GET`	`/api/admin/products`	🔐 Admin	Admin product management
`PUT`	`/api/admin/products/:asin`	🔐 Admin	Update product details

🔧 Admin Dashboard

Access the admin panel at /admin (visible only to admin users).

Capabilities

Action	Description
Run Model (Infer-Only)	Trigger Level 1 Quick Re-run (~5s)
Trigger Retrain	Trigger Level 2 Heavy Retrain (~60s, requires Python)
Clean Rec File	Remove stale/deleted users from `lightfm_recs.json`
Get Model Counters	View current interaction counts
Reset Counters	Manually reset interaction counters to 0
Refresh Status	Poll current model run status

Become an Admin

# Option 1: CLI Tool
cd backend && node tools/set_admin.js YOUR_USER_ID

# Option 2: Create admin script
npm run create-admin   # Creates user_id=1 with admin privileges

# Option 3: Environment variable (restart required)
ADMIN_USERS=YOUR_USER_ID_1,YOUR_USER_ID_2

# Option 4: Register with admin secret
curl -X POST http://localhost:5001/api/user/register \
  -H "x-admin-secret: your-secret" \
  -H "Content-Type: application/json" \
  -d '{"user_id":"ADMIN_2","reviewerName":"Admin","isAdmin":true}'

Manual CLI Engine Triggers

# Level 1: Quick Re-run (Node.js)
node -e "require('./recommender/retrainManager').startModelRun()"

# Level 2: Heavy Retrain (Python LightFM)
node -e "require('./recommender/retrainManager').startRetrain()"

# Or via npm scripts
npm run model:run           # Python infer-only
npm run train:lightfm       # Full LightFM training

☁️ Deployment

Render (Recommended)

The project includes a render.yaml Infrastructure-as-Code config for one-click deployment:

Two-Service Architecture:

Service	Type	Root Dir	Build	Start
Backend	Web Service	`backend`	`npm ci`	`npm start`
Frontend	Static Site	`frontend`	`npm ci && npm run build`	Publish `dist/`

Single-Service Architecture: Set SERVE_FRONTEND=true and use a combined build command.

Vercel

Frontend can be deployed directly to Vercel with the included vercel.json config.

CI/CD

GitHub Actions workflow (.github/workflows/ci-render-deploy.yml) automates:

Frontend build validation
Backend dependency installation
Render deploy trigger via API

See DEPLOY.md for step-by-step deployment instructions for Render, Vercel, and single-service setups.

📄 Documentation

Document	Description
RECOMMENDATION_SYSTEM.md	Complete engine guide (1000+ lines): architecture, data flow, API specs, DB schemas, troubleshooting
QUICK_RE_RUN.md	Level 1 engine: Node.js popularity heuristic, step-by-step lifecycle
LIGHTFM_RETRAIN.md	Level 2 engine: LightFM + ABSA hybrid pipeline, vector interaction logic
DEPLOY.md	Deployment guide: Render, Vercel, single-service, CI/CD setup
frontend/STYLEGUIDE.md	Design system: color palette, typography, spacing, component guidelines
backend/RECOMMENDER.md	Backend recommender quickstart: install, train, endpoints, scheduler
backend/README_AI_DIVE.md	Technical deep-dive: retrain vs re-run, matrix factorization, threshold pipeline

🤝 Contributing

Fork the repository
Create a feature branch: git checkout -b feat/your-feature
Commit changes: git commit -m "feat: add your feature"
Push to branch: git push origin feat/your-feature
Open a Pull Request

npm Scripts Reference

Backend (cd backend):

Script	Command	Description
`npm start`	`node server.js`	Production server
`npm run dev`	`nodemon server.js`	Dev server with hot-reload
`npm run seed`	`node seed.js`	Seed database
`npm run create-admin`	`node tools/create_admin_user.js`	Create admin (user_id=1)
`npm run set-passwords`	`node tools/set_default_passwords.js`	Reset passwords to default
`npm run train:lightfm`	`python ./recommender/train_lightfm.py`	Full LightFM training
`npm run model:run`	`python ./recommender/train_lightfm.py --infer-only`	Infer-only run

Frontend (cd frontend):

Script	Command	Description
`npm run dev`	`vite`	Start Vite dev server
`npm run build`	`vite build`	Production build
`npm run preview`	`vite preview`	Preview production build
`npm run lint`	`eslint .`	Run linter

📜 License

ISC

Built with ❤️ by RecoSense Engineering
Empowering the future of personalized tech discovery. ✨

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
backend		backend
frontend		frontend
tools		tools
.gitignore		.gitignore
DEPLOY.md		DEPLOY.md
FRONTEND_UPDATES.md		FRONTEND_UPDATES.md
LIGHTFM_RETRAIN.md		LIGHTFM_RETRAIN.md
PR_BODY.md		PR_BODY.md
QUICK_RE_RUN.md		QUICK_RE_RUN.md
README.md		README.md
RECOMMENDATION_SYSTEM.md		RECOMMENDATION_SYSTEM.md
render.yaml		render.yaml

Latest commit

History

Folders and files

Repository files navigation