https://github.com/kjgpta/Vibe-Fusion.git

.env

@@ -1,11 +0,0 @@
-# OpenAI API Configuration
-openai_api_key='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'
-
-
-# App Configuration
-app_debug=False
-similarity_threshold=0.8
-
-# Data Configuration
-catalog_file=data/Apparels_shared.xlsx
-vibes_data_dir=data/vibes/

.gitattributes

@@ -33,5 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-design.png filter=lfs diff=lfs merge=lfs -text
-VibeFusion-DesignSpec.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,4 +0,0 @@
-venv/
-.env
-__pycache__/
-nltk_data/

Dockerfile

@@ -1,11 +0,0 @@
-# Dockerfile
-FROM python:3.9-slim
-
-WORKDIR /app
-COPY requirements.txt .
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-CMD ["python", "run.py"]

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Kshitij Gupta
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README copy.md

@@ -1,502 +0,0 @@
-# 🌟 Vibe Fusion
-
-AI-powered fashion recommendation system that transforms natural language style descriptions into personalized outfit suggestions. The system combines rule-based matching, semantic similarity, and GPT-powered inference to understand user "vibes" and translate them into actionable product recommendations.
-
-## ✨ Key Features & Innovations
-
-### 🧠 **Hybrid Intelligence Architecture**
-- **Rule-based + AI hybrid**: Combines fast, reliable rule-based matching with intelligent GPT fallback
-- **Confidence-aware processing**: Automatically determines when to use GPT vs rule-based matching
-- **Semantic understanding**: Uses spaCy word vectors and TF-IDF for contextual phrase matching
-- **Knowledge base approach**: Curated vibe-to-attribute JSON mappings for fashion domain expertise
-
-### 💬 **Conversational Interface**
-- **Multi-turn conversations**: Maintains context across multiple user interactions
-- **Smart follow-up questions**: Automatically asks for missing critical attributes
-- **Natural language processing**: Handles complex queries like "something elegant for a dinner date"
-- **Context preservation**: Remembers user preferences and partial requirements throughout the session
-- **Intelligent state management**: Tracks conversation history, pending attributes, and user preferences
-- **Progressive refinement**: Each interaction builds upon previous context for better recommendations
-- **Graceful conversation reset**: Users can start fresh while preserving useful context
-
-### 🎯 **Advanced Query Understanding**
-- **Compound phrase recognition**: Understands "summer brunch" as season+occasion combination
-- **Fashion-specific NLP**: Specialized entity extraction for clothing categories, fits, occasions
-- **Fuzzy matching**: "comfy" automatically maps to "comfortable" and "relaxed"
-- **Multi-modal attributes**: Processes style, season, occasion, fit, color, and occasion simultaneously
-
-### 📊 **Intelligent Product Filtering**
-- **Multi-criteria search**: Filters by category, price, size, fit, fabric, color, occasion
-- **Category-aware validation**: Different attributes are relevant for tops vs dresses vs pants
-- **Flexible size handling**: Supports both traditional (S/M/L) and numeric sizing
-- **Smart price context**: Provides value context based on user budget
-
-### 🎨 **Design & User Experience**
-- **Intuitive conversational interface**: Natural chat-based interaction with visual feedback
-- **Progressive disclosure**: Information revealed step-by-step to avoid overwhelming users
-- **Visual product showcase**: Rich product displays with images and detailed descriptions
-- **Responsive design**: Optimized for desktop, tablet, and mobile experiences
-- **Accessibility features**: Screen reader support, keyboard navigation, high contrast options
-
-## 🏗️ **System Architecture & Design Decisions**
-
-### **Modular Pipeline Design**
-
-The system follows a sophisticated pipeline architecture that processes user queries through multiple specialized stages:
-
-```
-User Query → NLP Analysis → Similarity Matching → GPT Inference → Product Filtering → NLG Response
-```
-
-### **1. NLP Analyzer (`modules/nlp_analyzer.py`)**
-
-**Design Decision**: Hybrid spaCy + NLTK approach
-- **Why chosen**: spaCy provides excellent tokenization and entity recognition, while NLTK offers robust stopword filtering
-- **Benefits over alternatives**: More accurate than pure regex, faster than full transformer models
-- **Fashion-specific patterns**: Curated lists of occasions, styles, fits, colors specific to fashion domain
-- **Compound phrase detection**: Recognizes multi-word fashion concepts like "summer brunch"
-
-**Key Features**:
-- Fashion-specific entity patterns for occasions, seasons, styles, categories, fits
-- Intelligent text cleaning that preserves fashion terminology
-- Confidence scoring for extracted attributes
-- Budget extraction with currency normalization
-
-### **2. Similarity Matcher (`modules/similarity_matcher.py`)**
-
-**Design Decision**: Dual similarity approach (spaCy + TF-IDF)
-- **Why chosen**: spaCy provides semantic understanding, TF-IDF provides robust string matching
-- **Benefits**: Handles both exact matches ("bodycon") and semantic matches ("form-fitting" → "bodycon")
-- **Knowledge base approach**: JSON mappings allow easy updates without retraining models
-
-**Vibe-to-Attribute Mappings**:
-- `fit_mapping.json`: 20+ fit descriptors → standardized fit attributes
-- `color_mapping.json`: Color families and style descriptors → specific color palettes  
-- `occasion_mapping.json`: 25+ complex occasion scenarios with full attribute sets
-- `fabric_mapping.json`: Fabric types and characteristics
-
-**Confidence-based Processing**:
-- Similarity threshold (default 0.8) determines when to trust rule-based matches
-- High confidence matches skip GPT inference for speed
-- Low confidence triggers GPT fallback for better coverage
-
-### **3. GPT Inference (`modules/gpt_inference.py`)**
-
-**Design Decision**: GPT-4 as intelligent fallback, not primary engine
-- **Why chosen**: GPT provides broad coverage but is slower and requires API calls
-- **Benefits**: Handles edge cases and complex queries that rule-based matching misses
-- **Structured output**: Enforces JSON schema with validation against known valid values
-- **Graceful degradation**: System works without GPT, just with reduced functionality
-
-**Smart Prompting Strategy**:
-- Category-aware attribute validation (tops have different attributes than dresses)
-- Extensive valid value lists prevent hallucination
-- Context injection from existing rule-based matches
-- Temperature 0.3 for consistent, focused responses
-
-### **4. Catalog Filter (`modules/catalog_filter.py`)**
-
-**Design Decision**: Pandas-based flexible filtering with category awareness
-- **Why chosen**: Fast filtering on structured data, easy to extend with new criteria
-- **Benefits**: Supports complex multi-criteria searches with partial matching
-- **Category-specific logic**: Different filtering rules for tops, dresses, skirts, pants
-
-**Advanced Filtering Features**:
-- **Color family matching**: "pastels" expands to multiple specific colors
-- **Size compatibility**: Flexible size matching across different size systems
-- **Fabric lists**: Handles multiple fabric preferences (["silk", "satin"])
-- **Price context awareness**: Sorts and prioritizes based on budget constraints
-
-### **5. NLG Generator (`modules/nlg_generator.py`)**
-
-**Design Decision**: Template-based generation with contextual adaptation
-- **Why chosen**: More reliable and controllable than pure generative models
-- **Benefits**: Consistent tone, factual accuracy, domain-appropriate language
-- **Context-aware**: Different response styles for single vs multiple products
-
-## 🎯 **Why This Architecture? Benefits Over Alternatives**
-
-### **Hybrid Approach vs Pure AI/Pure Rules**
-- **Pure rule-based systems**: Limited to predefined patterns, can't handle edge cases
-- **Pure AI systems**: Expensive, unpredictable, require constant fine-tuning
-- **Our hybrid approach**: Fast rule-based for common cases + AI for complexity = best of both worlds
-
-### **Knowledge Base vs End-to-End Learning**
-- **End-to-end neural models**: Require massive training data, black box decisions
-- **Our curated knowledge base**: Transparent, easily updatable, leverages human expertise
-- **Benefits**: Explainable recommendations, easy maintenance, domain expert friendly
-
-### **Modular vs Monolithic Design**
-- **Monolithic systems**: Hard to debug, upgrade, or customize
-- **Our modular pipeline**: Each component can be independently improved or replaced
-- **Benefits**: Easier testing, flexible deployment, clear separation of concerns
-
-### **Conversational vs Form-Based Interface**
-- **Traditional forms**: Limited expression, rigid interaction patterns
-- **Our conversational UI**: Natural expression, progressive refinement, context awareness
-- **Benefits**: Better user experience, handles ambiguity, learns user preferences
-
-## 🎨 **Design Documentation**
-
-Vibe Fusion features a carefully crafted user experience designed to make fashion discovery intuitive and enjoyable.
-
-### **Visual Design System**
-![Vibe Fusion Design](design.png)
-
-The application follows modern design principles with:
-- **Clean, minimalist interface** that puts content first
-- **Warm, approachable color palette** that reflects fashion and style
-- **Typography hierarchy** that guides users through conversations
-- **Consistent iconography** for actions and status indicators
-
-### **Complete Design Specification**
-📋 [VibeFusion Design Specification](VibeFusion-DesignSpec.pdf)
-
-Our comprehensive design document covers:
-- **User Experience Strategy**: Conversational flow design and interaction patterns
-- **Visual Identity**: Color schemes, typography, iconography, and branding guidelines  
-- **Component Library**: Reusable UI components and design tokens
-- **Responsive Layouts**: Multi-device experience optimization
-- **Accessibility Guidelines**: Inclusive design practices and WCAG compliance
-- **Usability Testing Results**: User feedback integration and iterative improvements
-
-### **Key Design Principles**
-
-**1. Conversation-First Design**
-- Natural language input prioritized over complex forms
-- Visual feedback for each step in the recommendation process
-- Context preservation through visual conversation history
-
-**2. Progressive Enhancement**
-- Core functionality works without JavaScript
-- Enhanced interactions for modern browsers
-- Graceful degradation for accessibility devices
-
-**3. Fashion-Forward Aesthetics**
-- Visual design reflects current fashion trends
-- Product imagery and styling considerations
-- Color psychology applied to enhance user engagement
-
-**4. Performance-Optimized**
-- Fast loading times with optimized assets
-- Lazy loading for product images and recommendations
-- Efficient state management for smooth interactions
-
-## 🚀 **Quick Start & Setup**
-
-### **One-Command Launch**
-```bash
-python3 run.py
-```
-
-This automated setup script:
-1. ✅ Validates Python 3.8+ compatibility
-2. 📦 Installs all dependencies from `requirements.txt`
-3. 🤖 Downloads spaCy English model (`en_core_web_md`)
-4. 📊 Generates sample product catalog with realistic fashion data
-5. 🔧 Checks environment configuration and provides guidance
-6. 🚀 Launches Streamlit web application on `localhost:8501`
-
-### **Manual Setup (Alternative)**
-```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Download required spaCy model  
-python -m spacy download en_core_web_md
-
-# Create sample catalog
-python create_catalog.py
-
-# Configure environment (optional)
-cp env.example .env
-# Edit .env with your OpenAI API key
-
-# Start application
-python run.py
-```
-
-## 🔧 **Configuration & Customization**
-
-### **Environment Variables**
-```bash
-# OpenAI API (enables GPT inference)
-openai_api_key=your_openai_api_key_here
-
-# System tuning
-similarity_threshold=0.8        # Rule-based confidence threshold
-streamlit_server_port=8501      # Web interface port
-```
-
-### **Data Configuration**
-
-**Product Catalog** (`data/Apparels_shared.xlsx`):
-- Structured product data with category-specific attributes
-- Flexible schema supporting different clothing types
-- Price, size, and availability information
-
-**Vibe Knowledge Base** (`data/vibes/`):
-- **`fit_mapping.json`**: Maps casual language ("comfy", "snug") to standard fits
-- **`color_mapping.json`**: Maps color families ("pastels", "earth tones") to specific colors
-- **`occasion_mapping.json`**: Complex scenario mappings ("romantic dinner date" → full attribute set)
-- **`fabric_mapping.json`**: Fabric characteristics and style associations
-
-**Knowledge Base Structure Example**:
-```json
-// fit_mapping.json - Simple term-to-attribute mapping
-{
-  "comfy": {"fit": "Relaxed"},
-  "bodycon": {"fit": "Body hugging"},
-  "oversized": {"fit": "Oversized"}
-}
-
-// occasion_mapping.json - Complex scenario mapping
-{
-  "romantic dinner date": {
-    "fabric": ["Silk", "Satin", "Chiffon"],
-    "neckline": ["V neck", "Sweetheart", "Cowl neck"],
-    "occasion": "Evening",
-    "fit": "Body hugging"
-  }
-}
-```
-
-**Catalog Schema Design**:
-- **Category-specific attributes**: Tops have sleeve_length, dresses have neckline, etc.
-- **Flexible sizing**: Supports both traditional (XS-XXL) and numeric sizes
-- **Color standardization**: Consistent color naming across products
-- **Price and availability**: Real-time inventory considerations
-
-## 📋 **Usage Examples & Capabilities**
-
-### **Conversational Interface Examples**
-
-The Vibe Fusion interface presents conversations in an intuitive chat format with visual cues, product images, and interactive elements. See our [design documentation](#-design-documentation) for complete UI/UX details.
-
-**Simple Request**:
-```
-User: "Something casual for a summer brunch"
-System: "Perfect! I found a light pink linen top that would be ideal for summer brunch. 
-        Relaxed fit with short sleeves. It's $40 and would work beautifully for casual occasions."
-```
-
-**Complex Multi-turn Conversation**:
-```
-User: "I need something elegant for a dinner date"
-System: "I'd love to help you find something elegant! What size do you prefer, and do you have a budget in mind?"
-
-User: "Size M, around $100"
-System: "Got it! Do you prefer a dress, or would you like separates like a top and skirt?"
-
-User: "A dress would be perfect"
-System: "Wonderful! I found a beautiful sapphire blue silk dress in size M. Body-hugging fit 
-        with a V-neck, perfect for evening occasions. At $95, it's a great value and ideal for dinner dates."
-```
-
-### **Advanced Query Understanding**
-
-The system understands complex, nuanced requests:
-
-- **"Boho chic vibes"** → Linen/chiffon fabrics, bell sleeves, relaxed fits
-- **"Office-ready polish"** → Tailored fits, cotton fabrics, collar necklines  
-- **"Party ready sequin pieces"** → Sequin/metallic colors, bodycon fits
-- **"Minimalist aesthetic"** → Neutral colors, tailored fits, clean lines
-- **"Comfortable wide leg pants under $60"** → Specific category, fit, price filtering
-
-### **Smart Attribute Inference**
-
-- **Compound phrases**: "Summer brunch" = casual occasion + light fabrics + appropriate colors
-- **Style implications**: "Elegant" suggests tailored fits, premium fabrics, sophisticated colors
-- **Seasonal context**: "Winter formal" implies longer sleeves, darker colors, structured fits
-- **Budget optimization**: Prioritizes products within stated budget, provides value context
-
-## 🎯 **System Capabilities & Intelligence**
-
-### **Natural Language Understanding**
-- **Occasions**: brunch, work, party, date, wedding, gym, vacation, interview
-- **Styles**: casual, formal, elegant, edgy, bohemian, chic, minimalist, romantic
-- **Seasons**: summer, winter, spring, fall + seasonal implications
-- **Fits**: relaxed, tailored, bodycon, oversized, slim, flowy + casual descriptors
-- **Colors**: Complex color families, specific shades, pattern recognition
-- **Categories**: dress, top, blazer, jeans, pants, skirt, activewear + subcategories
-
-### **Smart Processing Features**
-- **Context preservation**: Maintains conversation state across multiple turns
-- **Confidence-based routing**: Automatically chooses optimal processing strategy
-- **Graceful degradation**: Functions without GPT API, provides useful feedback on missing components
-- **Real-time validation**: Checks user preferences against available inventory
-- **Flexible sizing**: Handles multiple size systems and conversions
-
-## 📁 **Project Structure & Technical Details**
-
-```
-VibeApparelRecommender/
-├── 📜 run.py                        # Automated setup and launch script
-├── 🌐 streamlit_app.py              # Conversational web interface
-├── 📊 create_catalog.py             # Sample data generator with realistic products
-├── 🧪 test_system.py               # Comprehensive system validation tests
-├── 📋 requirements.txt              # Python dependencies with version management
-├── 🔧 .env.example                 # Environment configuration template
-├── 📖 README.md                    # This comprehensive documentation
-├── 🎨 design.png                   # Visual design system overview
-├── 📋 VibeFusion-DesignSpec.pdf    # Complete design specification document
-├── 📄 LICENSE                      # MIT license file
-├── 📁 recommendation_system.py     # Main coordinator and pipeline orchestrator
-├── 📁 modules/                      # Modular system components
-│   ├── nlp_analyzer.py             # spaCy + NLTK natural language processing
-│   ├── similarity_matcher.py       # Cosine similarity + semantic matching
-│   ├── gpt_inference.py            # OpenAI GPT-4 intelligent fallback
-│   ├── catalog_filter.py           # Multi-criteria product filtering
-│   └── nlg_generator.py            # Template-based response generation
-└── 📁 data/                        # Knowledge base and catalog data
-    ├── Apparels_shared.xlsx        # Structured product catalog
-    └── vibes/                      # Fashion domain knowledge
-        ├── fit_mapping.json        # Fit terminology → standard attributes
-        ├── color_mapping.json      # Color families → specific colors
-        ├── occasion_mapping.json   # Complex scenarios → full attribute sets
-        └── fabric_mapping.json     # Fabric characteristics and associations
-```
-
-## 🛠️ **Development & Extension**
-
-### **Adding New Products**
-```python
-# Edit create_catalog.py to add more products
-catalog_data.append({
-    "Product_ID": "NEW001",
-    "Name": "Your New Product",
-    "Category": "Dress",
-    "Price": 75,
-    "Available_Sizes": "XS,S,M,L,XL",
-    "Fit": "Relaxed",
-    "Color": "Blue",
-    "Fabric": "Linen",
-    # ... other category-specific attributes
-})
-```
-
-### **Extending Vibe Knowledge Base**
-```json
-// Add to data/vibes/occasion_mapping.json
-{
-  "weekend farmers market": {
-    "category": "top",
-    "fit": "Relaxed", 
-    "fabric": ["Cotton", "Linen"],
-    "sleeve_length": "Short sleeves",
-    "color_or_print": ["Earth tones", "Natural"]
-  }
-}
-```
-
-### **Customizing Response Generation**
-```python
-# Modify modules/nlg_generator.py
-self.templates['single_product'].append(
-    "Perfect match! {description} would be amazing for {context}. {details} Only ${price}!"
-)
-```
-
-## 🔍 **Testing & Validation**
-
-### **Automated Testing Suite**
-```bash
-python test_system.py
-```
-
-**Test Coverage**:
-- ✅ File structure and dependency validation
-- ✅ JSON knowledge base loading and validation
-- ✅ Product catalog structure and content verification
-- ✅ System initialization and module integration
-- ✅ Basic recommendation pipeline functionality
-
-### **System Status Monitoring**
-The Streamlit interface provides real-time system status:
-- spaCy model availability and version
-- GPT API connectivity and quotas
-- Knowledge base loading status
-- Product catalog statistics and health
-
-### **Troubleshooting Common Issues**
-
-**spaCy Model Issues**:
-```bash
-# Download missing model
-python -m spacy download en_core_web_md
-
-# Verify installation
-python -c "import spacy; nlp = spacy.load('en_core_web_md'); print('✅ spaCy model loaded')"
-```
-
-**OpenAI API Issues**:
-- Ensure API key is valid and has sufficient credits
-- System gracefully degrades to rule-based matching without GPT
-- Check rate limits if experiencing delays
-
-**Import/Path Issues**:
-- Run from project root directory
-- Ensure virtual environment is activated if used
-- Check that all dependencies are installed: `pip install -r requirements.txt`
-
-## 🚀 **Performance & Scalability**
-
-### **Processing Speed**
-- **Rule-based matching**: ~10-50ms per query
-- **With GPT fallback**: ~1-3 seconds (network dependent)
-- **Catalog filtering**: ~1-10ms for 1000+ products
-- **Memory footprint**: ~100-200MB (including spaCy model)
-
-### **Scalability Considerations**
-- **Horizontal scaling**: Stateless design allows multiple instances
-- **Caching opportunities**: Vibe mappings, product catalog, spaCy models
-- **Database integration**: Easy migration from Excel to SQL/NoSQL
-- **API rate limiting**: Built-in GPT usage optimization
-
-### **Quality Assurance**
-- **Fallback mechanisms**: Multiple processing strategies ensure robustness
-- **Validation layers**: Input sanitization, output verification, error handling
-- **Confidence scoring**: Transparent quality metrics for recommendations
-- **User feedback integration**: Framework for continuous improvement
-
-## 🤝 **Contributing & Customization**
-
-### **Architecture Benefits**
-- **Modular design**: Easy to replace or enhance individual components
-- **Clear interfaces**: Well-defined APIs between modules
-- **Configuration-driven**: Behavior modification without code changes
-- **Extensible knowledge base**: JSON format allows non-technical updates
-- **Multi-modal input**: Text, preferences, historical data integration ready
-
-### **Extension Points**
-1. **New data sources**: Additional product catalogs, user preference databases
-2. **Enhanced NLP**: Sentiment analysis, brand preferences, style evolution
-3. **Recommendation algorithms**: Collaborative filtering, trend analysis
-4. **User personalization**: Purchase history, style profiles, size preferences
-5. **Business logic**: Inventory management, seasonal recommendations, promotions
-
-## 📄 **License & Acknowledgments**
-
-**License**: MIT License - see [LICENSE](LICENSE) file for details
-
-**Technologies & Dependencies**:
-- **spaCy** (3.4+): Advanced natural language processing and semantic similarity
-- **OpenAI GPT-4**: Intelligent attribute inference and complex query handling
-- **Streamlit** (1.28+): Interactive web interface with real-time updates
-- **Pandas** (1.5+): Efficient data manipulation and filtering
-- **scikit-learn** (1.2+): TF-IDF vectorization and cosine similarity
-- **NLTK** (3.8+): Text preprocessing and stopword filtering
-
-**Design Philosophy**:
-Vibe Fusion embodies a "human-AI collaboration" approach where AI augments human domain expertise rather than replacing it. The curated knowledge base captures fashion expertise, while AI handles the complexity of natural language understanding and edge cases.
-
-**User Experience Philosophy**:
-- **Conversation over forms**: Natural language interaction feels more personal and intuitive
-- **Progressive disclosure**: Information is revealed gradually to prevent cognitive overload
-- **Visual storytelling**: Product recommendations are presented with rich context and imagery
-- **Inclusive design**: Accessibility and usability considerations for diverse user needs
-- **Performance first**: Fast, responsive interactions that respect user time and attention
-
----
-
-**🌟 Built with intelligence and style** | Transform your fashion ideas into perfect recommendations!

VibeFusion-DesignSpec.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5e6ff96de3f9065d4d26ace64c18bf13f3b58730581039c2aaf0d18b4fb317f4
-size 542404

create_catalog.py

@@ -1,182 +0,0 @@
-import pandas as pd
-import os
-
-# Create sample product catalog data
-catalog_data = [
-    {
-        "Product_ID": "D001",
-        "Name": "Rosemary Floral Sundress",
-        "Category": "Dress",
-        "Price": 85,
-        "Available_Sizes": "XS,S,M,L,XL",
-        "Fit": "Relaxed",
-        "Color": "Pink",
-        "Pattern": "Floral",
-        "Sleeve_Length": "Sleeveless",
-        "Neckline": "V-neck",
-        "Length": "Knee-length",
-        "Occasion": "Casual",
-        "Season": "Summer",
-        "Brand": "SunnyDays",
-        "Description": "Light and airy floral sundress perfect for summer occasions"
-    },
-    {
-        "Product_ID": "D002", 
-        "Name": "Daisy Print Midi Dress",
-        "Category": "Dress",
-        "Price": 90,
-        "Available_Sizes": "S,M,L,XL",
-        "Fit": "Relaxed",
-        "Color": "Yellow",
-        "Pattern": "Floral",
-        "Sleeve_Length": "Sleeveless",
-        "Neckline": "Round neck",
-        "Length": "Midi",
-        "Occasion": "Casual",
-        "Season": "Summer",
-        "Brand": "FloralFashion",
-        "Description": "Cheerful daisy print midi dress with comfortable fit"
-    },
-    {
-        "Product_ID": "B001",
-        "Name": "Classic Navy Blazer",
-        "Category": "Blazer",
-        "Price": 120,
-        "Available_Sizes": "XS,S,M,L,XL,XXL",
-        "Fit": "Tailored",
-        "Color": "Navy",
-        "Pattern": "Solid",
-        "Sleeve_Length": "Long sleeve",
-        "Neckline": "Collared",
-        "Length": "Hip-length",
-        "Occasion": "Formal",
-        "Season": "All",
-        "Brand": "Professional",
-        "Description": "Timeless navy blazer for professional settings"
-    },
-    {
-        "Product_ID": "T001",
-        "Name": "Casual Cotton T-Shirt",
-        "Category": "Top",
-        "Price": 25,
-        "Available_Sizes": "XS,S,M,L,XL,XXL",
-        "Fit": "Relaxed",
-        "Color": "White",
-        "Pattern": "Solid",
-        "Sleeve_Length": "Short sleeve",
-        "Neckline": "Round neck",
-        "Length": "Hip-length",
-        "Occasion": "Casual",
-        "Season": "All",
-        "Brand": "BasicWear",
-        "Description": "Comfortable cotton t-shirt for everyday wear"
-    },
-    {
-        "Product_ID": "D003",
-        "Name": "Elegant Black Evening Dress",
-        "Category": "Dress",
-        "Price": 150,
-        "Available_Sizes": "XS,S,M,L,XL",
-        "Fit": "Bodycon",
-        "Color": "Black",
-        "Pattern": "Solid",
-        "Sleeve_Length": "Sleeveless",
-        "Neckline": "V-neck",
-        "Length": "Maxi",
-        "Occasion": "Formal",
-        "Season": "All",
-        "Brand": "ElegantEvening",
-        "Description": "Sophisticated black dress perfect for formal events"
-    },
-    {
-        "Product_ID": "J001",
-        "Name": "High-Waisted Skinny Jeans",
-        "Category": "Jeans",
-        "Price": 65,
-        "Available_Sizes": "24,26,28,30,32,34",
-        "Fit": "Slim",
-        "Color": "Blue",
-        "Pattern": "Solid",
-        "Sleeve_Length": "N/A",
-        "Neckline": "N/A",
-        "Length": "Full-length",
-        "Occasion": "Casual",
-        "Season": "All",
-        "Brand": "DenimCo",
-        "Description": "Classic high-waisted skinny jeans in dark wash"
-    },
-    {
-        "Product_ID": "S001",
-        "Name": "Flowy Maxi Skirt",
-        "Category": "Skirt",
-        "Price": 45,
-        "Available_Sizes": "XS,S,M,L,XL",
-        "Fit": "Relaxed",
-        "Color": "Mint Green",
-        "Pattern": "Solid",
-        "Sleeve_Length": "N/A",
-        "Neckline": "N/A",
-        "Length": "Maxi",
-        "Occasion": "Casual",
-        "Season": "Summer",
-        "Brand": "FlowingFashion",
-        "Description": "Comfortable maxi skirt with elastic waistband"
-    },
-    {
-        "Product_ID": "A001",
-        "Name": "Athletic Yoga Set",
-        "Category": "Activewear",
-        "Price": 55,
-        "Available_Sizes": "XS,S,M,L,XL",
-        "Fit": "Athletic",
-        "Color": "Black",
-        "Pattern": "Solid",
-        "Sleeve_Length": "Long sleeve",
-        "Neckline": "Round neck",
-        "Length": "Full-length",
-        "Occasion": "Workout",
-        "Season": "All",
-        "Brand": "FitLife",
-        "Description": "High-performance yoga set with moisture-wicking fabric"
-    },
-    {
-        "Product_ID": "D004",
-        "Name": "Bohemian Maxi Dress",
-        "Category": "Dress",
-        "Price": 95,
-        "Available_Sizes": "S,M,L,XL",
-        "Fit": "Relaxed",
-        "Color": "Multi",
-        "Pattern": "Paisley",
-        "Sleeve_Length": "Long sleeve",
-        "Neckline": "V-neck",
-        "Length": "Maxi",
-        "Occasion": "Casual",
-        "Season": "Fall",
-        "Brand": "BohoChic",
-        "Description": "Free-spirited maxi dress with paisley print"
-    },
-    {
-        "Product_ID": "T002",
-        "Name": "Pastel Pink Blouse",
-        "Category": "Top",
-        "Price": 40,
-        "Available_Sizes": "XS,S,M,L,XL",
-        "Fit": "Tailored",
-        "Color": "Light Pink",
-        "Pattern": "Solid",
-        "Sleeve_Length": "Short sleeve",
-        "Neckline": "Button-up",
-        "Length": "Hip-length",
-        "Occasion": "Business Casual",
-        "Season": "Spring",
-        "Brand": "ProfessionalPastels",
-        "Description": "Soft pink blouse perfect for office wear"
-    }
-]
-
-# Create DataFrame and save to Excel
-df = pd.DataFrame(catalog_data)
-os.makedirs('data', exist_ok=True)
-df.to_excel('data/Apparels_shared.xlsx', index=False)
-print("Sample catalog created successfully!") 

env.example

@@ -1,10 +0,0 @@
-# OpenAI API Configuration
-openai_api_key='api-key'
-
-# App Configuration
-app_debug=False
-similarity_threshold=0.8
-
-# Data Configuration
-catalog_file=data/Apparels_shared.xlsx
-vibes_data_dir=data/vibes/

recommendation_system.py

@@ -1,349 +0,0 @@
-"""
-Main Vibe-to-Attribute Clothing Recommendation System
-
-Coordinates all modules to provide end-to-end fashion recommendations
-from user queries to natural language suggestions.
-"""
-
-import os
-import sys
-from typing import Dict, List, Optional, Any
-
-# Add modules to path
-sys.path.append(os.path.join(os.path.dirname(__file__), 'modules'))
-
-from modules.nlp_analyzer import NLPAnalyzer
-from modules.similarity_matcher import SimilarityMatcher
-from modules.gpt_inference import GPTInference
-from modules.catalog_filter import CatalogFilter
-from modules.nlg_generator import NLGGenerator
-
-class VibeRecommendationSystem:
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
-        """
-        Initialize the complete recommendation system.
-        
-        Args:
-            config: Configuration dictionary with system settings
-        """
-        self.config = config or {}
-        
-        # Initialize all modules
-        self.nlp_analyzer = NLPAnalyzer()
-        self.similarity_matcher = SimilarityMatcher(
-            vibes_data_dir=self.config.get('vibes_data_dir', 'data/vibes/'),
-            similarity_threshold=self.config.get('similarity_threshold', 0.8)
-        )
-        self.gpt_inference = GPTInference()
-        self.catalog_filter = CatalogFilter(
-            catalog_file=self.config.get('catalog_file', 'data/Apparels_shared.xlsx')
-        )
-        self.nlg_generator = NLGGenerator()
-        
-        print("✓ Vibe Recommendation System initialized successfully!")
-    
-    def get_recommendations(self, 
-                          user_query: str,
-                          user_preferences: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Main method to get clothing recommendations from a user query.
-        
-        Args:
-            user_query: Natural language request from user
-            user_preferences: Additional user preferences (size, budget, etc.)
-            
-        Returns:
-            Dictionary containing recommendations and processing details
-        """
-        print(f"\n🔍 Processing query: '{user_query}'")
-        
-        # Step 1: NLP Analysis
-        print("Step 1: Analyzing natural language query...")
-        nlp_result = self.nlp_analyzer.analyze_query(user_query)
-        extracted_attributes = nlp_result['extracted_attributes']
-        key_phrases = nlp_result['key_phrases']
-        
-        print(f"✓ Extracted attributes: {extracted_attributes}")
-        print(f"✓ Key phrases: {key_phrases}")
-        
-        # Step 2: Similarity Matching
-        print("\nStep 2: Matching against vibe knowledge base...")
-        similarity_result = self.similarity_matcher.find_best_matches(
-            extracted_phrases=key_phrases,
-            individual_attributes=extracted_attributes
-        )
-        
-        rule_based_attributes = similarity_result['matched_attributes']
-        has_high_confidence = similarity_result['has_high_confidence_matches']
-        
-        print(f"✓ Rule-based matches: {rule_based_attributes}")
-        print(f"✓ High confidence matches: {has_high_confidence}")
-        
-        # Step 3: GPT Inference (if needed)
-        gpt_attributes = {}
-        if not has_high_confidence or len(rule_based_attributes) < 3:
-            print("\nStep 3: Using GPT for attribute inference...")
-            gpt_attributes = self.gpt_inference.infer_attributes(
-                user_query=user_query,
-                existing_attributes={**extracted_attributes, **rule_based_attributes},
-                vibe_mappings=self.similarity_matcher.vibe_mappings
-            )
-            
-            if gpt_attributes:
-                print(f"✓ GPT inferred attributes: {gpt_attributes}")
-            else:
-                print("⚠ GPT inference not available or failed")
-        else:
-            print("\nStep 3: Skipping GPT inference (high confidence rule-based matches)")
-        
-        # Step 4: Merge attributes
-        print("\nStep 4: Merging attributes...")
-        final_attributes = self._merge_all_attributes(
-            extracted_attributes,
-            rule_based_attributes,
-            gpt_attributes,
-            user_preferences or {}
-        )
-        
-        print(f"✓ Final attributes: {final_attributes}")
-        
-        # Step 5: Check for missing critical attributes
-        missing_attributes = self._check_missing_attributes(final_attributes)
-        if missing_attributes:
-            print(f"⚠ Missing critical attributes: {missing_attributes}")
-            
-            # Generate user-friendly questions and use the first one as the main message
-            follow_up_questions = self._generate_follow_up_questions(missing_attributes)
-            user_friendly_message = follow_up_questions[0] if follow_up_questions else "I need more information to help you find the perfect clothing item."
-            
-            return {
-                'success': False,
-                'message': user_friendly_message,
-                'missing_attributes': missing_attributes,
-                'suggested_questions': follow_up_questions,
-                'final_attributes': final_attributes,
-                'processing_details': {
-                    'nlp_analysis': nlp_result,
-                    'similarity_matching': similarity_result
-                }
-            }
-        
-        # Step 6: Product Filtering
-        print("\nStep 5: Filtering product catalog...")
-        matching_products = self.catalog_filter.filter_products(
-            attributes=final_attributes,
-            max_results=self.config.get('max_results', 5)
-        )
-        
-        print(f"✓ Found {len(matching_products)} matching products")
-        
-        # Step 7: Natural Language Generation
-        print("\nStep 6: Generating natural language response...")
-        suggestion = self.nlg_generator.generate_suggestion(
-            products=matching_products,
-            original_query=user_query,
-            attributes=final_attributes
-        )
-        
-        # Use the suggestion as-is (NLGGenerator already handles tone internally)
-        final_suggestion = suggestion
-        
-        print("✓ Generated recommendation response")
-        
-        return {
-            'success': True,
-            'recommendation': final_suggestion,
-            'products': matching_products,
-            'final_attributes': final_attributes,
-            'processing_details': {
-                'nlp_analysis': nlp_result,
-                'similarity_matching': similarity_result,
-                'gpt_inference': gpt_attributes,
-                'products_found': len(matching_products)
-            }
-        }
-    
-    def _merge_all_attributes(self, 
-                            extracted: Dict[str, Any],
-                            rule_based: Dict[str, Any],
-                            gpt_inferred: Dict[str, Any],
-                            user_prefs: Dict[str, Any]) -> Dict[str, Any]:
-        """Merge attributes from all sources with proper priority."""
-        
-        # Priority order: user_prefs > rule_based > gpt_inferred > extracted
-        merged = {}
-        
-        # Start with extracted (lowest priority)
-        for key, value in extracted.items():
-            if value:
-                merged[key] = value
-        
-        # Override with GPT inferred (handle None case)
-        if gpt_inferred:
-            for key, value in gpt_inferred.items():
-                if value:
-                    merged[key] = value
-        
-        # Override with rule-based (higher confidence)
-        for key, value in rule_based.items():
-            if value:
-                merged[key] = value
-        
-        # Override with user preferences (highest priority)
-        for key, value in user_prefs.items():
-            if value:
-                merged[key] = value
-        
-        return merged
-    
-    def _check_missing_attributes(self, attributes: Dict[str, Any]) -> List[str]:
-        """Check for missing critical attributes."""
-        critical_attributes = ['category', 'size', 'budget']  # Must have category, size, and budget
-        recommended_attributes = ['occasion', 'season']  # Good to have
-        
-        missing = []
-        
-        # Check critical attributes
-        for attr in critical_attributes:
-            value = attributes.get(attr)
-            is_missing = attr not in attributes or not value
-            print(f"✓ Checking {attr}: value={repr(value)}, type={type(value)}, is_missing={is_missing}")
-            if is_missing:
-                missing.append(attr)
-        
-        # Check if we have at least some context (only if we have category, size, and budget)
-        if 'category' in attributes and 'size' in attributes and 'budget' in attributes:
-            context_attributes = ['occasion', 'season', 'style', 'fit']
-            has_context = any(attr in attributes and attributes[attr] for attr in context_attributes)
-            
-            if not has_context:
-                missing.extend(['occasion or style'])
-        
-        return missing
-    
-    def _generate_follow_up_questions(self, missing_attributes: List[str]) -> List[str]:
-        """Generate follow-up questions for missing attributes with helpful examples."""
-        questions = []
-        
-        # Get available options from the system
-        available_categories = ["dress", "top", "pants", "skirt", "jacket", "shirt", "blouse"]
-        available_occasions = ["casual", "formal", "work", "party", "date", "wedding", "brunch", "vacation"]
-        available_styles = ["casual", "formal", "chic", "bohemian", "minimalist", "edgy", "romantic", "professional"]
-        available_fits = ["relaxed", "tailored", "loose", "fitted", "oversized", "slim", "regular"]
-        available_sizes = ["XS", "S", "M", "L", "XL", "XXL"]
-        
-        question_templates = {
-            'category': f"What type of clothing are you looking for? Choose from: {', '.join(available_categories)}",
-            'size': f"What size do you need? Available sizes: {', '.join(available_sizes)}",
-            'budget': "What's your budget? You can say something like '$50', 'under $100', or '200 dollars'",
-            'occasion': f"What's the occasion? For example: {', '.join(available_occasions[:6])}",
-            'season': "What season is this for? (spring, summer, fall, winter)",
-            'style': f"What style are you going for? Options include: {', '.join(available_styles[:6])}",
-            'fit': f"How would you like it to fit? Choose from: {', '.join(available_fits[:4])}"
-        }
-        
-        for attr in missing_attributes:
-            if attr in question_templates:
-                questions.append(question_templates[attr])
-            elif 'or' in attr:  # Handle compound attributes like "occasion or style"
-                if 'occasion' in attr:
-                    questions.append(f"Tell me about the occasion or style! For example: {', '.join(available_occasions[:4])} or {', '.join(available_styles[:4])}")
-                else:
-                    questions.append(f"Could you tell me more about the {attr}? Give me some details!")
-        
-        return questions
-    
-    def get_system_status(self) -> Dict[str, Any]:
-        """Get status of all system components."""
-        status = {
-            'nlp_analyzer': 'Ready',
-            'similarity_matcher': f"Loaded {len(self.similarity_matcher.all_vibe_keys)} vibe mappings",
-            'gpt_inference': 'Ready' if self.gpt_inference.available else 'Not configured (missing API key)',
-            'catalog_filter': f"Loaded {len(self.catalog_filter.catalog_df)} products" if not self.catalog_filter.catalog_df.empty else 'No catalog loaded',
-            'nlg_generator': 'Ready'
-        }
-        
-        return status
-    
-    def interactive_session(self):
-        """Run an interactive recommendation session."""
-        print("🌟 Welcome to the Vibe-to-Attribute Clothing Recommendation System!")
-        print("Ask me for clothing recommendations using natural language.")
-        print("Type 'quit' to exit, 'status' to see system status.\n")
-        
-        while True:
-            try:
-                user_input = input("👤 What are you looking for? ").strip()
-                
-                if user_input.lower() in ['quit', 'exit', 'bye']:
-                    print("👋 Thanks for using the recommendation system! Goodbye!")
-                    break
-                
-                if user_input.lower() == 'status':
-                    status = self.get_system_status()
-                    print("\n📊 System Status:")
-                    for component, status_msg in status.items():
-                        print(f"  • {component}: {status_msg}")
-                    print()
-                    continue
-                
-                if not user_input:
-                    print("Please enter a clothing request or type 'quit' to exit.\n")
-                    continue
-                
-                # Get recommendations
-                result = self.get_recommendations(user_input)
-                
-                if result['success']:
-                    print(f"\n🤖 {result['recommendation']}\n")
-                else:
-                    print(f"\n🤖 {result['message']}")
-                    if 'suggested_questions' in result:
-                        print("\nTo help me better, please answer:")
-                        for question in result['suggested_questions']:
-                            print(f"  • {question}")
-                    print()
-                
-            except KeyboardInterrupt:
-                print("\n👋 Thanks for using the recommendation system! Goodbye!")
-                break
-            except Exception as e:
-                print(f"❌ An error occurred: {e}")
-                print("Please try again with a different request.\n")
-
-# Example usage and testing
-if __name__ == "__main__":
-    # Initialize system
-    system = VibeRecommendationSystem()
-    
-    # Check system status
-    print("System Status:")
-    status = system.get_system_status()
-    for component, status_msg in status.items():
-        print(f"  • {component}: {status_msg}")
-    
-    # Test with sample queries
-    test_queries = [
-        "Something casual for a summer brunch",
-        "I need a formal black dress for an evening event",
-        "Comfortable workout clothes for the gym"
-    ]
-    
-    print("\n" + "="*50)
-    print("Testing with sample queries:")
-    print("="*50)
-    
-    for query in test_queries:
-        print(f"\n🧪 Testing: '{query}'")
-        result = system.get_recommendations(query)
-        
-        if result['success']:
-            print(f"✅ Success: {result['recommendation']}")
-        else:
-            print(f"❌ Failed: {result['message']}")
-    
-    # Start interactive session if run directly
-    print("\n" + "="*50)
-    print("Starting interactive session...")
-    print("="*50)
-    system.interactive_session() 

requirements.txt

@@ -1,12 +0,0 @@
-streamlit>=1.28.0
-spacy>=3.4.0
-nltk>=3.8
-pandas>=1.5.0
-numpy>=1.21.0
-scikit-learn>=1.2.0
-openai>=1.0.0
-python-dotenv>=0.19.0
-openpyxl>=3.0.0
-sentence-transformers>=2.2.0
-setuptools>=65.0.0
-en-core-web-md @ https://github.com/explosion/spacy-models/releases/download/en_core_web_md-3.8.0/en_core_web_md-3.8.0-py3-none-any.whl

run.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""
-Main run script for the Vibe-to-Attribute Clothing Recommendation System
-
-This script:
-1. Sets up the environment
-2. Creates the sample product catalog
-3. Downloads required models
-4. Starts the Streamlit application
-"""
-
-import os
-import sys
-import subprocess
-import platform
-from pathlib import Path
-
-def print_banner():
-    """Print welcome banner."""
-    banner = """
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                                                                              ║
-║           🌟 Vibe-to-Attribute Clothing Recommendation System 🌟             ║
-║                                                                              ║
-║  Transform your style ideas into perfect outfit recommendations using AI!    ║
-║                                                                              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-    """
-    print(banner)
-
-def check_python_version():
-    """Check if Python version is compatible."""
-    min_version = (3, 8)
-    current_version = sys.version_info[:2]
-    
-    if current_version < min_version:
-        print(f"❌ Python {min_version[0]}.{min_version[1]}+ is required. Current version: {current_version[0]}.{current_version[1]}")
-        return False
-    
-    print(f"✅ Python version: {current_version[0]}.{current_version[1]}")
-    return True
-
-def install_requirements():
-    """Install required Python packages."""
-    print("\n📦 Installing required packages...")
-    
-    try:
-        subprocess.check_call([
-            sys.executable, "-m", "pip", "install", "-r", "requirements.txt"
-        ])
-        print("✅ Requirements installed successfully!")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Failed to install requirements: {e}")
-        return False
-
-def create_sample_catalog():
-    """Create the sample product catalog."""
-    print("\n📊 Creating sample product catalog...")
-    
-    try:
-        # Run the catalog creation script
-        exec(open('create_catalog.py').read())
-        print("✅ Sample catalog created successfully!")
-        return True
-    except Exception as e:
-        print(f"❌ Failed to create sample catalog: {e}")
-        return False
-
-def check_environment():
-    """Check if environment file exists and provide guidance."""
-    print("\n🔧 Checking environment configuration...")
-    
-    env_file = Path('.env')
-    env_example = Path('env.example')
-    
-    if not env_file.exists():
-        if env_example.exists():
-            print("⚠️  No .env file found. Please:")
-            print("   1. Copy env.example to .env")
-            print("   2. Edit .env with your API keys")
-            print("   3. Set your OpenAI API key for GPT features")
-            print("\n   Example:")
-            print("   cp env.example .env")
-            print("   # Then edit .env with your actual API keys")
-        else:
-            print("⚠️  No environment configuration found.")
-        
-        print("\n💡 The system will work with limited functionality without API keys.")
-        print("   GPT inference will be disabled, but rule-based matching will work.")
-        return False
-    else:
-        print("✅ Environment file found!")
-        return True
-
-def start_streamlit():
-    """Start the Streamlit application."""
-    print("\n🚀 Starting Streamlit application...")
-    print("📍 The app will open in your default web browser")
-    print("\n⏹️  Press Ctrl+C to stop the application")
-    
-    try:
-        subprocess.run([
-            sys.executable, "-m", "streamlit", "run", "streamlit_app.py",])
-    except KeyboardInterrupt:
-        print("\n👋 Application stopped by user")
-    except Exception as e:
-        print(f"❌ Failed to start Streamlit: {e}")
-
-def main():
-    """Main execution function."""
-    print_banner()
-    
-    print("🔍 System Check...")
-    
-    # Check Python version
-    if not check_python_version():
-        sys.exit(1)
-    
-    # Check if we're in the right directory
-    if not Path("requirements.txt").exists():
-        print("❌ Please run this script from the project root directory")
-        sys.exit(1)
-    
-    print("✅ In correct directory")
-    
-    # Install requirements
-    if not install_requirements():
-        print("⚠️  Continuing with existing packages...")
-    
-    # Create sample catalog
-    create_sample_catalog()
-    
-    # Check environment
-    check_environment()
-    
-    print("\n" + "="*80)
-    print("🎉 Setup complete! Starting the application...")
-    print("="*80)
-    
-    # Start Streamlit
-    start_streamlit()
-
-if __name__ == "__main__":
-    main() 

streamlit_app.py

@@ -1,342 +0,0 @@
-"""
-Streamlit Web Application for Vibe-to-Attribute Clothing Recommendation System
-"""
-
-import streamlit as st
-import sys
-import os
-from typing import Dict, Any, List
-
-
-try:
-    from recommendation_system import VibeRecommendationSystem
-except ImportError as e:
-    st.error(f"Failed to import recommendation system: {e}")
-    st.stop()
-
-# Configure Streamlit page
-st.set_page_config(
-    page_title="Vibe Fashion Recommender",
-    page_icon="👗",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Custom CSS for better styling
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 3rem;
-        font-weight: bold;
-        text-align: center;
-        background: linear-gradient(45deg, #FF6B6B, #4ECDC4);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        margin-bottom: 2rem;
-    }
-    .subtitle {
-        text-align: center;
-        font-size: 1.2rem;
-        color: #666;
-        margin-bottom: 3rem;
-    }
-    .recommendation-box {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 2rem;
-        border-radius: 15px;
-        margin: 2rem 0;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state for conversation
-if 'recommendation_system' not in st.session_state:
-    with st.spinner("🔄 Initializing Fashion Recommendation System..."):
-        try:
-            st.session_state.recommendation_system = VibeRecommendationSystem()
-            st.session_state.system_initialized = True
-        except Exception as e:
-            st.session_state.system_initialized = False
-            st.error(f"Failed to initialize system: {e}")
-
-# Initialize conversation state
-if 'conversation_history' not in st.session_state:
-    st.session_state.conversation_history = []
-if 'pending_attributes' not in st.session_state:
-    st.session_state.pending_attributes = {}
-if 'missing_attributes' not in st.session_state:
-    st.session_state.missing_attributes = []
-if 'conversation_active' not in st.session_state:
-    st.session_state.conversation_active = False
-
-def main():
-    """Main Streamlit application."""
-    
-    # Header
-    st.markdown('<h1 class="main-header">�� Vibe Fashion Recommender</h1>', unsafe_allow_html=True)
-    st.markdown('<p class="subtitle">Transform your style ideas into perfect outfit recommendations using AI</p>', unsafe_allow_html=True)
-    
-    # Check if system is initialized
-    if not st.session_state.get('system_initialized', False):
-        st.error("❌ System failed to initialize. Please refresh the page.")
-        return
-    
-    # Sidebar - System Status Only
-    with st.sidebar:
-        st.header("📊 System Status")
-        if st.button("Check Status"):
-            status = st.session_state.recommendation_system.get_system_status()
-            for component, status_msg in status.items():
-                if "Ready" in status_msg or "Loaded" in status_msg:
-                    st.success(f"✅ {component}: {status_msg}")
-                else:
-                    st.warning(f"⚠️ {component}: {status_msg}")
-        
-        st.markdown("---")
-        st.markdown("**💡 Tip:** Tell me your size and budget in the conversation!")
-        st.markdown("*Example: 'I need a size M dress under $100 for a party'*")
-    
-
-    
-    # Chat interface for conversation
-    st.header("💬 Fashion Chat")
-    
-    # Display conversation history
-    if st.session_state.conversation_history:
-        st.markdown("**Conversation History:**")
-        chat_container = st.container()
-        with chat_container:
-            for i, exchange in enumerate(st.session_state.conversation_history):
-                # User message
-                st.markdown(f"**You:** {exchange['user']}")
-                # Assistant response
-                if exchange.get('assistant'):
-                    st.markdown(f"**Assistant:** {exchange['assistant']}")
-                if i < len(st.session_state.conversation_history) - 1:
-                    st.markdown("---")
-    
-    # Current pending context
-    if st.session_state.pending_attributes:
-        st.info(f"💭 I remember: {', '.join([f'{k}: {v}' for k, v in st.session_state.pending_attributes.items()])}")
-    
-    # User input with form to handle clearing better
-    with st.form(key="user_input_form", clear_on_submit=True):
-        user_input = st.text_input(
-            "Continue the conversation:" if st.session_state.conversation_active else "What are you looking for?",
-            placeholder="Tell me more details..." if st.session_state.missing_attributes else "e.g., I want something elegant for a dinner date...",
-            key="user_input_field"
-        )
-        send_button = st.form_submit_button("💬 Send", type="primary")
-    
-    # Buttons
-    col1, col2 = st.columns([1, 1])
-    
-    with col1:
-        if st.button("🔄 New Request"):
-            # Reset conversation
-            st.session_state.conversation_history = []
-            st.session_state.pending_attributes = {}
-            st.session_state.missing_attributes = []
-            st.session_state.conversation_active = False
-            st.rerun()
-    
-    with col2:
-        if st.button("✨ Get Final Recommendations"):
-            if st.session_state.pending_attributes:
-                get_final_recommendations(st.session_state.pending_attributes, {})
-            else:
-                st.warning("Please start a conversation first!")
-    
-    # Process user input (now triggered by form submit)
-    if send_button and user_input.strip():
-        process_user_input(user_input, {})
-
-def process_user_input(user_input: str, user_prefs: Dict[str, Any]):
-    """Process user input in conversational context."""
-    
-    # Combine current input with pending attributes to form complete query
-    if st.session_state.pending_attributes:
-        # Build context from previous conversation
-        context_parts = []
-        for key, value in st.session_state.pending_attributes.items():
-            if isinstance(value, list):
-                context_parts.append(f"{key}: {', '.join(value)}")
-            else:
-                context_parts.append(f"{key}: {value}")
-        
-        # Combine context with new input
-        combined_query = f"Previous context: {'; '.join(context_parts)}. New information: {user_input}"
-    else:
-        combined_query = user_input
-    
-    with st.spinner("🤖 Processing your message..."):
-        try:
-            # Get recommendations with combined context and pending attributes
-            # Pass pending attributes as user preferences (highest priority)
-            merged_prefs = user_prefs.copy()
-            merged_prefs.update(st.session_state.pending_attributes)
-            
-            result = st.session_state.recommendation_system.get_recommendations(
-                user_query=combined_query,
-                user_preferences=merged_prefs
-            )
-            
-            # Add to conversation history
-            exchange = {"user": user_input}
-            
-            if result['success']:
-                # Got successful recommendations
-                exchange["assistant"] = result['recommendation']
-                st.session_state.conversation_history.append(exchange)
-                st.session_state.conversation_active = False
-                st.session_state.pending_attributes = {}
-                st.session_state.missing_attributes = []
-                
-                # Display recommendations
-                display_recommendations(result)
-                
-            else:
-                # Need more information - maintain conversation state
-                exchange["assistant"] = result['message']
-                st.session_state.conversation_history.append(exchange)
-                st.session_state.conversation_active = True
-                st.session_state.missing_attributes = result.get('missing_attributes', [])
-                
-                # Update pending attributes with what we know so far
-                if 'final_attributes' in result:
-                    st.session_state.pending_attributes.update(result['final_attributes'])
-                
-                # Extract new attributes from current input only (not combined query)
-                try:
-                    # Analyze just the current user input to extract new attributes
-                    nlp_result = st.session_state.recommendation_system.nlp_analyzer.analyze_query(user_input)
-                    if nlp_result and 'extracted_attributes' in nlp_result:
-                        extracted = nlp_result['extracted_attributes']
-                        for key, value in extracted.items():
-                            if value and value not in [None, "", []]:
-                                st.session_state.pending_attributes[key] = value
-                                print(f"✓ Updated pending attributes from current input: {key} = {value}")
-                                # Show debug info for size and budget specifically
-                                if key in ['size', 'budget']:
-                                    print(f"  {key.title()} type: {type(value)}, value: {repr(value)}")
-                except Exception as e:
-                    print(f"Error extracting attributes from current input: {e}")
-                    pass
-                
-                # Show the assistant's response
-                st.info(f"💬 **Assistant:** {exchange['assistant']}")
-                
-                # Show follow-up questions
-                if 'suggested_questions' in result:
-                    st.markdown("**To help me better, please answer:**")
-                    for question in result['suggested_questions']:
-                        st.write(f"• {question}")
-                
-                st.rerun()
-                
-        except Exception as e:
-            st.error(f"❌ An error occurred: {str(e)}")
-
-def get_final_recommendations(pending_attributes: Dict[str, Any], user_prefs: Dict[str, Any]):
-    """Get final recommendations with accumulated attributes."""
-    
-    # Build a query from accumulated attributes
-    query_parts = []
-    for key, value in pending_attributes.items():
-        if isinstance(value, list):
-            query_parts.append(f"{key}: {', '.join(value)}")
-        else:
-            query_parts.append(f"{key}: {value}")
-    
-    combined_query = f"Find clothing with: {'; '.join(query_parts)}"
-    
-    with st.spinner("🤖 Getting your final recommendations..."):
-        try:
-            result = st.session_state.recommendation_system.get_recommendations(
-                user_query=combined_query,
-                user_preferences=user_prefs
-            )
-            
-            if result['success']:
-                # Reset conversation state
-                st.session_state.conversation_active = False
-                st.session_state.pending_attributes = {}
-                st.session_state.missing_attributes = []
-                
-                # Display recommendations
-                display_recommendations(result)
-            else:
-                st.error(f"Still missing information: {result.get('message', 'Unknown error')}")
-                
-        except Exception as e:
-            st.error(f"❌ An error occurred: {str(e)}")
-
-def get_recommendations(user_query: str, user_prefs: Dict[str, Any]):
-    """Get and display recommendations (legacy function for compatibility)."""
-    
-    with st.spinner("🤖 Analyzing your request and finding perfect matches..."):
-        try:
-            result = st.session_state.recommendation_system.get_recommendations(
-                user_query=user_query,
-                user_preferences=user_prefs
-            )
-            
-            display_recommendations(result)
-            
-        except Exception as e:
-            st.error(f"❌ An error occurred: {str(e)}")
-
-def display_recommendations(result: Dict[str, Any]):
-    """Display the recommendation results."""
-    
-    if result['success']:
-        # Main recommendation
-        st.markdown('<div class="recommendation-box">', unsafe_allow_html=True)
-        st.markdown("### 🎉 Your Perfect Match!")
-        st.markdown(result['recommendation'])
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-        # Product details
-        if result['products']:
-            st.header("👕 Product Details")
-            
-            for i, product in enumerate(result['products']):
-                with st.expander(f"🛍️ {product['name']} - ${product['price']}", expanded=(i==0)):
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        st.write(f"**Category:** {product['category']}")
-                        st.write(f"**Price:** ${product['price']}")
-                        if product.get('fit'):
-                            st.write(f"**Fit:** {product['fit']}")
-                        if product.get('fabric'):
-                            st.write(f"**Fabric:** {product['fabric']}")
-                    
-                    with col2:
-                        if product.get('color_or_print'):
-                            st.write(f"**Color/Print:** {product['color_or_print']}")
-                        st.write(f"**Available Sizes:** {product['available_sizes']}")
-                        if product.get('sleeve_length'):
-                            st.write(f"**Sleeve Length:** {product['sleeve_length']}")
-                        if product.get('neckline'):
-                            st.write(f"**Neckline:** {product['neckline']}")
-                        if product.get('length'):
-                            st.write(f"**Length:** {product['length']}")
-                        if product.get('pant_type'):
-                            st.write(f"**Pant Type:** {product['pant_type']}")
-                        if product.get('occasion'):
-                            st.write(f"**Occasion:** {product['occasion']}")
-                    
-                    if product.get('description'):
-                        st.write(f"**Description:** {product['description']}")
-    
-    else:
-        st.error(result['message'])
-        if 'suggested_questions' in result:
-            st.markdown("**Please help me by answering:**")
-            for question in result['suggested_questions']:
-                st.write(f"• {question}")
-
-if __name__ == "__main__":
-    main()

test_system.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick test script to verify the Vibe-to-Attribute Clothing Recommendation System
-is working correctly without requiring all dependencies.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-def test_file_structure():
-    """Test that all required files exist."""
-    print("🔍 Testing file structure...")
-    
-    required_files = [
-        'requirements.txt',
-        'env.example',
-        'streamlit_app.py',
-        'create_catalog.py',
-        'data/Apparels_shared.xlsx',
-        'data/vibes/fit_mapping.json',
-        'data/vibes/color_mapping.json',
-        'data/vibes/occasion_mapping.json',
-        'src/recommendation_system.py',
-        'modules/nlp_analyzer.py',
-        'modules/similarity_matcher.py',
-        'modules/gpt_inference.py',
-        'modules/catalog_filter.py',
-        'modules/nlg_generator.py'
-    ]
-    
-    missing_files = []
-    for file_path in required_files:
-        if not Path(file_path).exists():
-            missing_files.append(file_path)
-        else:
-            print(f"  ✅ {file_path}")
-    
-    if missing_files:
-        print(f"\n❌ Missing files:")
-        for file_path in missing_files:
-            print(f"  - {file_path}")
-        return False
-    
-    print("✅ All required files present!")
-    return True
-
-def test_basic_imports():
-    """Test that basic imports work."""
-    print("\n🔍 Testing basic imports...")
-    
-    try:
-        # Test data loading
-        import json
-        
-        # Test vibe mappings
-        with open('data/vibes/fit_mapping.json', 'r') as f:
-            fit_data = json.load(f)
-        print(f"  ✅ Fit mappings loaded: {len(fit_data)} entries")
-        
-        with open('data/vibes/color_mapping.json', 'r') as f:
-            color_data = json.load(f)
-        print(f"  ✅ Color mappings loaded: {len(color_data)} entries")
-        
-        with open('data/vibes/occasion_mapping.json', 'r') as f:
-            occasion_data = json.load(f)
-        print(f"  ✅ Occasion mappings loaded: {len(occasion_data)} entries")
-        
-        return True
-    
-    except Exception as e:
-        print(f"❌ Import test failed: {e}")
-        return False
-
-def test_catalog_loading():
-    """Test that the catalog can be loaded."""
-    print("\n🔍 Testing catalog loading...")
-    
-    try:
-        import pandas as pd
-        
-        catalog_df = pd.read_excel('data/Apparels_shared.xlsx')
-        print(f"  ✅ Catalog loaded: {len(catalog_df)} products")
-        
-        # Check required columns
-        required_columns = ['Name', 'Category', 'Price', 'Available_Sizes']
-        missing_columns = [col for col in required_columns if col not in catalog_df.columns]
-        
-        if missing_columns:
-            print(f"  ⚠️ Missing columns: {missing_columns}")
-        else:
-            print("  ✅ All required columns present")
-        
-        return True
-    
-    except Exception as e:
-        print(f"❌ Catalog test failed: {e}")
-        return False
-
-def test_system_initialization():
-    """Test basic system initialization."""
-    print("\n🔍 Testing system initialization...")
-    
-    try:
-        # Add paths
-        sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
-        sys.path.append(os.path.join(os.path.dirname(__file__), 'modules'))
-        
-        # Test basic module imports (without dependencies that might fail)
-        from catalog_filter import CatalogFilter
-        
-        # Test catalog filter
-        catalog_filter = CatalogFilter()
-        print("  ✅ Catalog filter initialized")
-        
-        # Test basic filtering
-        summary = catalog_filter.get_catalog_summary()
-        print(f"  ✅ Catalog summary: {summary.get('total_products', 0)} products")
-        
-        return True
-    
-    except Exception as e:
-        print(f"❌ System initialization test failed: {e}")
-        print(f"    This might be due to missing dependencies - install with: pip install -r requirements.txt")
-        return False
-
-def main():
-    """Run all tests."""
-    print("🌟 Vibe-to-Attribute Clothing Recommendation System - Test Suite")
-    print("=" * 70)
-    
-    tests = [
-        test_file_structure,
-        test_basic_imports,
-        test_catalog_loading,
-        test_system_initialization
-    ]
-    
-    passed = 0
-    total = len(tests)
-    
-    for test_func in tests:
-        try:
-            if test_func():
-                passed += 1
-        except Exception as e:
-            print(f"❌ Test {test_func.__name__} failed with exception: {e}")
-    
-    print("\n" + "=" * 70)
-    print(f"🏁 Test Results: {passed}/{total} tests passed")
-    
-    if passed == total:
-        print("🎉 All tests passed! System is ready to run.")
-        print("\n🚀 To start the application, run:")
-        print("   python3 run.py")
-    else:
-        print("⚠️  Some tests failed. Please check the issues above.")
-        print("\n🔧 Try installing dependencies:")
-        print("   pip install -r requirements.txt")
-    
-    return passed == total
-
-if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1) 

vercel.json

@@ -1,10 +0,0 @@
-{
-    "version": 2,
-    "builds": [
-      { "src": "Dockerfile", "use": "@vercel/docker" }
-    ],
-    "routes": [
-      { "src": "/(.*)", "dest": "/" }
-    ]
-  }
-