modularization

app.py

@@ -1,36 +1,10 @@
-from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-from typing import List, Optional, AsyncGenerator
-import re
-import os
-import base64
-from PIL import Image
-import requests
-from io import BytesIO
-from rag import initialize_rag, retrieve_relevant_context, format_rag_context
-import json
-import asyncio
-import threading
-from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
-from qwen_vl_utils import process_vision_info
-import torch
+from rag import initialize_rag
+from routes import setup_routes
 
 app = FastAPI(title="Style GPT API", version="1.0.0")
 
-style_model = None
-style_processor = None
-model_lock = threading.Lock()
-
-class WardrobeItem(BaseModel):
-    id: Optional[int] = None
-    category: str
-    style: str
-    color: Optional[str] = None
-    brand: Optional[str] = None
-    name: Optional[str] = None
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -39,969 +13,14 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-conversation_memory = {}
-
-COLOR_HARMONY = {
-    "green": ["beige", "white", "grey", "gray", "navy", "black", "brown"],
-    "blue": ["white", "beige", "khaki", "grey", "gray", "navy", "red"],
-    "navy": ["white", "beige", "khaki", "grey", "gray", "red", "yellow"],
-    "black": ["white", "beige", "grey", "gray", "navy", "red", "blue"],
-    "white": ["black", "navy", "grey", "gray", "beige", "any color"],
-    "grey": ["black", "white", "navy", "beige", "blue"],
-    "gray": ["black", "white", "navy", "beige", "blue"],
-    "beige": ["green", "navy", "brown", "black", "white", "blue"],
-    "red": ["white", "black", "navy", "blue", "beige"],
-    "brown": ["beige", "white", "navy", "green", "blue"],
-    "yellow": ["navy", "black", "white", "grey", "gray"],
-    "pink": ["white", "navy", "grey", "gray", "black"],
-    "purple": ["white", "grey", "gray", "black", "navy"],
-    "orange": ["navy", "white", "black", "beige"],
-}
-
-CLOTHING_TYPES = [
-    "hoodie", "sweatshirt", "t-shirt", "shirt", "blazer", "jacket",
-    "jeans", "pants", "chinos", "trousers", "shorts",
-    "sneakers", "boots", "shoes", "sandal", "heels",
-    "dress", "skirt", "top", "sweater", "cardigan",
-    "vest", "coat", "parka", "blouse", "polo"
-]
-
-class ChatRequest(BaseModel):
-    message: str
-    session_id: Optional[str] = "default"
-    wardrobe: Optional[List[WardrobeItem]] = None
-    images: Optional[List[str]] = None
-
-class ChatResponse(BaseModel):
-    response: str
-    session_id: str
-
-def extract_clothing_info(text: str) -> dict:
-    text_lower = text.lower()
-    
-    colors = list(COLOR_HARMONY.keys())
-    found_color = None
-    for color in colors:
-        if color in text_lower:
-            found_color = color
-            break
-    
-    found_types = []
-    for clothing_type in CLOTHING_TYPES:
-        if clothing_type in text_lower:
-            found_types.append(clothing_type)
-    
-    existing_item = None
-    requested_item = None
-    
-    question_patterns = ["what kind of", "what", "which", "suggest", "recommend"]
-    is_question = any(pattern in text_lower for pattern in question_patterns)
-    
-    if is_question and len(found_types) > 0:
-        if "my" in text_lower or "i have" in text_lower or "i'm wearing" in text_lower:
-            for i, word in enumerate(text_lower.split()):
-                if word == "my" and i + 1 < len(text_lower.split()):
-                    next_words = " ".join(text_lower.split()[i+1:i+4])
-                    for ct in found_types:
-                        if ct in next_words:
-                            existing_item = ct
-                            break
-                if existing_item:
-                    break
-        
-        for ct in found_types:
-            if "match" in text_lower or "go with" in text_lower or "pair" in text_lower:
-                ct_pos = text_lower.find(ct)
-                match_pos = text_lower.find("match")
-                if ct_pos > match_pos or "what kind of" in text_lower[:ct_pos]:
-                    requested_item = ct
-                    break
-    
-    if not existing_item and not requested_item and found_types:
-        if is_question:
-            requested_item = found_types[0]
-        else:
-            existing_item = found_types[0]
-    
-    return {
-        "color": found_color,
-        "type": existing_item or requested_item,
-        "existing_item": existing_item,
-        "requested_item": requested_item,
-        "is_question": is_question,
-        "raw_text": text
-    }
-
-def get_color_matches(color: str) -> List[str]:
-    color_lower = color.lower()
-    return COLOR_HARMONY.get(color_lower, ["white", "black", "grey", "beige"])
-
-def ensure_model_loaded():
-    """Load model if not already loaded"""
-    global style_model, style_processor
-    
-    if style_model is not None:
-        return
-    
-    print("Loading model (lazy load on first request)...")
-    model_id = "Qwen/Qwen2.5-VL-7B-Instruct"
-    hf_token = os.getenv("HF_TOKEN")
-    
-    try:
-        if hf_token:
-            style_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
-                model_id,
-                token=hf_token,
-                torch_dtype=torch.float32,
-                device_map="auto",
-                low_cpu_mem_usage=True
-            )
-            style_processor = AutoProcessor.from_pretrained(model_id, token=hf_token)
-        else:
-            style_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
-                model_id,
-                torch_dtype=torch.float32,
-                device_map="auto",
-                low_cpu_mem_usage=True
-            )
-            style_processor = AutoProcessor.from_pretrained(model_id)
-        
-        print(f"Loaded {model_id}")
-    except Exception as e:
-        print(f"Error loading model: {e}")
-        raise
-
-def generate_chat_response(prompt: str, max_length: int = 512, temperature: float = 0.7, rag_context: Optional[str] = None, system_override: Optional[str] = None, images: Optional[List[str]] = None) -> str:
-    """Generate response using the model"""
-    ensure_model_loaded()
-    
-    system_message = system_override if system_override else "You are StyleGPT, a friendly and helpful fashion stylist assistant. You give natural, conversational advice about clothing, colors, and outfit combinations. Always be warm, friendly, and advisory in your responses. When asked your name, say you're StyleGPT. When greeted, respond warmly and offer to help with fashion advice."
-    
-    if rag_context:
-        system_message += f"\n\n{rag_context}\n\nUse this fashion knowledge to provide accurate and helpful advice. Reference this knowledge naturally in your responses."
-    
-    # Build user content list for Qwen2.5-VL format
-    user_content = []
-    if images and len(images) > 0:
-        for img in images:
-            user_content.append({"type": "image", "image": img})
-    user_content.append({"type": "text", "text": prompt})
-    
-    messages = [
-        {"role": "system", "content": system_message},
-        {"role": "user", "content": user_content}
-    ]
-    
-    try:
-        # Prepare text for processing
-        text = style_processor.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-        
-        # Process vision info (images/videos)
-        image_inputs, video_inputs = process_vision_info(messages)
-        
-        # Process inputs
-        inputs = style_processor(
-            text=[text],
-            images=image_inputs,
-            videos=video_inputs,
-            padding=True,
-            return_tensors="pt",
-        )
-        
-        inputs = {k: v.to(style_model.device) for k, v in inputs.items()}
-        
-        temperature = max(0.1, min(1.5, temperature))
-        
-        with model_lock:
-            with torch.no_grad():
-                try:
-                    outputs = style_model.generate(
-                        **inputs,
-                        max_new_tokens=max_length,
-                        temperature=temperature,
-                        top_p=0.95,
-                        top_k=50,
-                        do_sample=True,
-                        eos_token_id=style_processor.tokenizer.eos_token_id,
-                        pad_token_id=style_processor.tokenizer.pad_token_id,
-                        repetition_penalty=1.1,
-                    )
-                except RuntimeError as e:
-                    if "probability tensor" in str(e) or "inf" in str(e) or "nan" in str(e):
-                        print(f"[GENERATE] Probability error, retrying with greedy decoding")
-                        outputs = style_model.generate(
-                            **inputs,
-                            max_new_tokens=max_length,
-                            do_sample=False,
-                            eos_token_id=style_processor.tokenizer.eos_token_id,
-                            pad_token_id=style_processor.tokenizer.pad_token_id,
-                            repetition_penalty=1.1,
-                        )
-                    else:
-                        raise
-        
-        # Decode only the generated part
-        generated_ids_trimmed = [
-            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, outputs)
-        ]
-        generated_text = style_processor.batch_decode(
-            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
-        )[0]
-        
-        generated_text = generated_text.strip()
-        return generated_text
-        
-    except Exception as e:
-        print(f"[GENERATE] Error: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Generation error: {str(e)}")
-
-async def generate_chat_response_streaming(prompt: str, max_length: int = 512, temperature: float = 0.7, rag_context: Optional[str] = None, system_override: Optional[str] = None, images: Optional[List[str]] = None) -> AsyncGenerator[str, None]:
-    """Generate streaming response using the model"""
-    ensure_model_loaded()
-    
-    system_message = system_override if system_override else "You are StyleGPT, a friendly and helpful fashion stylist assistant. You give natural, conversational advice about clothing, colors, and outfit combinations. Always be warm, friendly, and advisory in your responses. When asked your name, say you're StyleGPT. When greeted, respond warmly and offer to help with fashion advice."
-    
-    if rag_context:
-        system_message += f"\n\n{rag_context}\n\nUse this fashion knowledge to provide accurate and helpful advice. Reference this knowledge naturally in your responses."
-    
-    # Build user content list for Qwen2.5-VL format
-    user_content = []
-    if images and len(images) > 0:
-        for img in images:
-            user_content.append({"type": "image", "image": img})
-    user_content.append({"type": "text", "text": prompt})
-    
-    messages = [
-        {"role": "system", "content": system_message},
-        {"role": "user", "content": user_content}
-    ]
-    
-    try:
-        # Prepare text for processing
-        text = style_processor.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-        
-        # Process vision info (images/videos)
-        image_inputs, video_inputs = process_vision_info(messages)
-        
-        # Process inputs
-        inputs = style_processor(
-            text=[text],
-            images=image_inputs,
-            videos=video_inputs,
-            padding=True,
-            return_tensors="pt",
-        )
-        
-        inputs = {k: v.to(style_model.device) for k, v in inputs.items()}
-        
-        temperature = max(0.1, min(1.5, temperature))
-        
-        with model_lock:
-            with torch.no_grad():
-                try:
-                    outputs = style_model.generate(
-                        **inputs,
-                        max_new_tokens=max_length,
-                        temperature=temperature,
-                        top_p=0.95,
-                        top_k=50,
-                        do_sample=True,
-                        eos_token_id=style_processor.tokenizer.eos_token_id,
-                        pad_token_id=style_processor.tokenizer.pad_token_id,
-                        repetition_penalty=1.1,
-                    )
-                except RuntimeError as e:
-                    if "probability tensor" in str(e) or "inf" in str(e) or "nan" in str(e):
-                        print(f"[GENERATE STREAM] Probability error, retrying with greedy decoding")
-                        outputs = style_model.generate(
-                            **inputs,
-                            max_new_tokens=max_length,
-                            do_sample=False,
-                            eos_token_id=style_processor.tokenizer.eos_token_id,
-                            pad_token_id=style_processor.tokenizer.pad_token_id,
-                            repetition_penalty=1.1,
-                        )
-                    else:
-                        raise
-        
-        # Decode only the generated part
-        generated_ids_trimmed = [
-            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, outputs)
-        ]
-        generated_text = style_processor.batch_decode(
-            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
-        )[0]
-        
-        generated_text = generated_text.strip()
-        
-        for char in generated_text:
-            yield char
-            await asyncio.sleep(0.01)
-    except Exception as e:
-        print(f"[GENERATE STREAM] Error: {e}")
-        import traceback
-        traceback.print_exc()
-        error_msg = f"I apologize, but I encountered an error generating a response. Please try again."
-        for char in error_msg:
-            yield char
-            await asyncio.sleep(0.01)
-
-def generate_outfit_suggestion(description: str, color: Optional[str], clothing_type: Optional[str], existing_item: Optional[str] = None, requested_item: Optional[str] = None, is_question: bool = False) -> dict:
-    if is_question and requested_item:
-        item_focus = requested_item
-        base_item = existing_item or clothing_type or 'outfit'
-        prompt = f"I have a {base_item}"
-        if color:
-            prompt += f" in {color} color"
-        prompt += f". What {requested_item} would match well? Suggest 2-3 specific items with brief explanations."
-    elif existing_item:
-        item_focus = None
-        prompt = f"I have a {existing_item}"
-        if color:
-            prompt += f" in {color} color"
-        prompt += ". What other clothing items would match well? Suggest 2-3 specific items."
-    else:
-        item_focus = requested_item or clothing_type
-        prompt = f"{description}. Suggest 2-3 specific clothing items that would match well and give a brief explanation."
-
-    generated_text = generate_chat_response(prompt, max_length=200, temperature=0.8)
-    
-    items = []
-    explanation = ""
-    
-    template_markers = ["[specific item name]", "[brief, friendly explanation]", "specific item name", "[item"]
-    
-    lines = generated_text.split("\n")
-    for line in lines:
-        line = line.strip()
-        if re.match(r"^Item\s+\d+:", line, re.IGNORECASE) or re.match(r"^-?\s*Item\s+\d+:", line, re.IGNORECASE):
-            line_clean = re.sub(r"^-?\s*Item\s+\d+:\s*", "", line, flags=re.IGNORECASE).strip()
-            
-            parts = re.split(r"\s+Item\s+\d+:\s*", line_clean, flags=re.IGNORECASE)
-            for part in parts:
-                item = part.strip()
-                if item and len(item) > 2 and not item.lower().endswith(":") and not any(marker in item.lower() for marker in template_markers):
-                    if not re.match(r"^\[.*\]$", item) and not item.lower().startswith("item"):
-                        items.append(item)
-        elif line.startswith("Explanation:"):
-            explanation = re.sub(r"^Explanation:\s*", "", line, flags=re.IGNORECASE).strip()
-            if any(marker in explanation.lower() for marker in template_markers):
-                explanation = ""
-    
-    if "Explanation:" in generated_text and not explanation:
-        parts = generated_text.split("Explanation:")
-        if len(parts) > 1:
-            explanation = parts[-1].strip().split("\n")[0].strip()
-            if any(marker in explanation.lower() for marker in template_markers):
-                explanation = ""
-    
-    if not items:
-        item_lines = re.findall(r"Item\s+\d+:\s*([^\n]+?)(?:\s+Item\s+\d+:|Explanation:|\s*$)", generated_text, re.IGNORECASE | re.DOTALL)
-        for item_match in item_lines:
-            item = item_match.strip()
-            if "Item " in item:
-                item = re.split(r"\s+Item\s+\d+:", item, flags=re.IGNORECASE)[0].strip()
-            if item and len(item) > 2 and not any(marker in item.lower() for marker in template_markers):
-                if not re.match(r"^\[.*\]$", item):
-                    items.append(item)
-    
-    items = [item for item in items if not any(item2 in item for item2 in items if item2 != item and len(item2) > 5)]
-    
-    items = [item for item in items if not any(marker in item.lower() for marker in template_markers) and len(item) > 3]
-    
-    items = [item for item in items if not item.lower().startswith("item")]
-    
-    if not items:
-        if item_focus:
-            if color:
-                matching_colors = get_color_matches(color)[:3]
-                items = [f"{c.title()} {item_focus}" for c in matching_colors if c != color]
-            else:
-                neutrals = ["beige", "white", "navy", "black"]
-                items = [f"{n.title()} {item_focus}" for n in neutrals[:3]]
-        elif color:
-            matching_colors = get_color_matches(color)[:3]
-            item_type = requested_item or clothing_type or "trousers" if "trousers" in description.lower() else "item"
-            items = [f"{c.title()} {item_type}" for c in matching_colors if c != color]
-        else:
-            if "trousers" in description.lower() or "pants" in description.lower():
-                items = ["Beige chinos", "Navy trousers", "Black jeans"]
-            elif "hoodie" in description.lower():
-                items = ["Beige chinos", "White sneakers", "Navy jacket"]
-            else:
-                items = ["White sneakers", "Beige chinos", "Black jacket"]
-    
-    items = [item for item in items if len(item) > 3 and not item.lower().endswith(":") and not any(marker in item.lower() for marker in template_markers)]
-    
-    items = list(dict.fromkeys(items))
-    
-    while len(items) < 2:
-        if item_focus:
-            neutrals = ["beige", "white", "navy", "black", "grey"]
-            for n in neutrals:
-                new_item = f"{n.title()} {item_focus}"
-                if new_item not in items and (not color or n != color):
-                    items.append(new_item)
-                    break
-        elif color:
-            matching_colors = get_color_matches(color)
-            for mc in matching_colors:
-                if mc != color:
-                    item_type = requested_item or clothing_type or "item"
-                    new_item = f"{mc.title()} {item_type}"
-                    if new_item not in items:
-                        items.append(new_item)
-                        break
-        else:
-            items.append("Classic white sneakers")
-    
-    items = items[:3]
-    
-    if not explanation or len(explanation) < 10:
-        if color and item_focus:
-            explanation = f"These {item_focus} options complement your {color} {existing_item or 'outfit'} beautifully, creating a balanced and stylish look."
-        elif color:
-            explanation = f"These items pair well with {color}, offering a versatile and fashionable combination."
-        elif item_focus:
-            explanation = f"These {item_focus} options will create a stylish and cohesive outfit."
-        else:
-            explanation = "These items pair well together for a stylish, balanced look."
-    
-    return {
-        "items": items,
-        "explanation": explanation
-    }
-
-def load_image_from_url(url_or_base64: str) -> Image.Image:
-    try:
-        if url_or_base64.startswith("data:image"):
-            header, encoded = url_or_base64.split(",", 1)
-            image_data = base64.b64decode(encoded)
-            return Image.open(BytesIO(image_data)).convert("RGB")
-        else:
-            response = requests.get(url_or_base64, timeout=10)
-            response.raise_for_status()
-            return Image.open(BytesIO(response.content)).convert("RGB")
-    except Exception as e:
-        raise ValueError(f"Failed to load image: {str(e)}")
-
 @app.on_event("startup")
 async def startup_event():
     print("Initializing RAG system...")
     initialize_rag()
     print("RAG ready for requests! Model will load on first request.")
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Style GPT API - Milestone 1",
-        "version": "1.0.0",
-        "endpoint": "/chat - POST - Conversational fashion assistant"
-    }
-
-@app.get("/health")
-async def health_check():
-    return {
-        "status": "healthy" if style_model is not None else "loading",
-        "model_loaded": style_model is not None,
-        "model_name": "Qwen/Qwen2.5-VL-7B-Instruct"
-    }
-
-def extract_colors_from_query(query: str) -> tuple:
-    query_lower = query.lower()
-    colors = list(COLOR_HARMONY.keys())
-    
-    extended_colors = ["navy blue", "wine", "burgundy", "maroon", "crimson", "scarlet", "mauve", "taupe", "olive", "teal", "turquoise", "indigo", "cobalt"]
-    all_colors = extended_colors + colors
-    
-    color_mapping = {
-        "wine": "red", "burgundy": "red", "maroon": "red",
-        "mauve": "purple", "taupe": "beige", "olive": "green",
-        "teal": "blue", "turquoise": "blue", "indigo": "navy", "cobalt": "blue",
-        "navy blue": "navy"
-    }
-    
-    found_colors = []
-    seen_mapped = set()
-    for color in all_colors:
-        if color in query_lower:
-            mapped = color_mapping.get(color, color)
-            if mapped not in seen_mapped:
-                found_colors.append((color, mapped))
-                seen_mapped.add(mapped)
-    
-    return found_colors
-
-def detect_query_type(message: str) -> str:
-    message_lower = message.lower()
-    
-    color_comparison_patterns = ["does", "do", "will", "can"]
-    comparison_keywords = ["go with", "match", "work with", "pair with", "combine with"]
-    color_suggestion_patterns = ["what color", "which color", "colors go with", "colors match", "better color", "color to match"]
-    
-    has_two_colors = len(extract_colors_from_query(message)) >= 2
-    
-    if any(pattern in message_lower for pattern in color_comparison_patterns) and any(kw in message_lower for kw in comparison_keywords) and has_two_colors:
-        return "color_compatibility"
-    
-    outfit_request_patterns = ["suggest", "recommend", "outfit", "wear", "dress", "thinking of", "what should i wear", "what can i wear", "what to wear"]
-    what_matches_patterns = ["what will go", "what goes with", "what matches", "what will match", "what can go"]
-    
-    if any(pattern in message_lower for pattern in what_matches_patterns) and any(item in message_lower for item in CLOTHING_TYPES):
-        return "outfit_suggestion"
-    
-    if any(pattern in message_lower for pattern in outfit_request_patterns):
-        return "outfit_suggestion"
-    
-    if any(pattern in message_lower for pattern in color_suggestion_patterns):
-        return "color_suggestion"
-    
-    if any(ct in message_lower for ct in CLOTHING_TYPES) and any(c in message_lower for c in ["with", "match", "go", "pair", "style", "stylish", "look"]):
-        return "outfit_suggestion"
-    
-    if len(extract_colors_from_query(message)) > 0 and any(word in message_lower for word in ["match", "with", "go", "pair"]):
-        return "color_suggestion"
-    
-    if any(ct in message_lower for ct in CLOTHING_TYPES):
-        return "outfit_suggestion"
-    
-    return "outfit_suggestion"
-
-def get_conversation_context(session_id: str) -> dict:
-    if session_id not in conversation_memory:
-        conversation_memory[session_id] = {
-            "messages": [],
-            "context": {}
-        }
-    return conversation_memory[session_id]
-
-def update_context(session_id: str, message: str, response_data: dict):
-    conv = conversation_memory[session_id]
-    conv["messages"].append({"user": message, "assistant": response_data.get("response", "")})
-    
-    if len(conv["messages"]) > 10:
-        conv["messages"] = conv["messages"][-10:]
-    
-    if "color" in response_data:
-        conv["context"]["last_color"] = response_data["color"]
-    if "item" in response_data:
-        conv["context"]["last_item"] = response_data["item"]
-    if "colors" in response_data:
-        conv["context"]["last_colors"] = response_data["colors"]
-    if "items" in response_data:
-        conv["context"]["last_items"] = response_data["items"]
-
-def enhance_message_with_context(message: str, context: dict) -> str:
-    message_lower = message.lower()
-    
-    if "what about" in message_lower or "how about" in message_lower or "and" in message_lower:
-        if context.get("last_color"):
-            if not any(c in message_lower for c in ["color", "red", "blue", "green", "black", "white", "brown"]):
-                message = message + f" with {context['last_color']}"
-        if context.get("last_item"):
-            if not any(item in message_lower for item in CLOTHING_TYPES):
-                message = message + f" {context['last_item']}"
-    
-    return message
-
-def is_greeting(message: str) -> bool:
-    message_lower = message.lower().strip()
-    greetings = [
-        "hello", "hi", "hey", "good morning", "good afternoon", "good evening",
-        "greetings", "howdy", "what's up", "whats up", "sup", "yo"
-    ]
-    return any(message_lower.startswith(g) or message_lower == g for g in greetings)
-
-def is_name_question(message: str) -> bool:
-    message_lower = message.lower().strip()
-    name_patterns = [
-        "what is your name", "what's your name", "whats your name",
-        "who are you", "what are you", "tell me your name", "your name"
-    ]
-    return any(pattern in message_lower for pattern in name_patterns)
-
-def clean_wardrobe_response(text: str) -> str:
-    import re
-    
-    text = re.sub(r'\b(\w+)\s+\1\b', r'\1', text)
-    
-    text = re.sub(r'\b(navy|grey|gray|black|white|brown|blue|red|green|beige|tan|charcoal|rolex|fossil|hermes|zara|nike)\s+\1\b', r'\1', text, flags=re.IGNORECASE)
-    
-    if "protein" in text.lower():
-        text = re.sub(r'[Pp]rotein\s*', '', text)
-    
-    lines = text.split('\n')
-    cleaned_lines = []
-    
-    for line in lines:
-        line = line.strip()
-        if not line or len(line) < 3:
-            continue
-        
-        if "protein" in line.lower():
-            continue
-        
-        cleaned_lines.append(line)
-    
-    result = '\n'.join(cleaned_lines).strip()
-    
-    if len(result) > 1000:
-        sentences = result.split('. ')
-        result = '. '.join(sentences[:8]) + '.'
-    
-    return result
-
-def format_wardrobe_for_prompt(wardrobe: List[WardrobeItem]) -> str:
-    wardrobe_by_category = {}
-    for item in wardrobe:
-        category = item.category.lower()
-        if category not in wardrobe_by_category:
-            wardrobe_by_category[category] = []
-        wardrobe_by_category[category].append(item)
-    
-    wardrobe_details = []
-    for idx, item in enumerate(wardrobe, 1):
-        parts = []
-        if item.brand:
-            parts.append(item.brand)
-        if item.color:
-            parts.append(item.color)
-        if item.name:
-            parts.append(item.name)
-        elif item.category:
-            parts.append(item.category)
-        
-        item_name = " ".join(parts) if parts else item.category
-        wardrobe_details.append(f'{idx}. {item_name} ({item.category}, {item.style})')
-    
-    categories_list = ", ".join(wardrobe_by_category.keys())
-    
-    return f"""Available items ({len(wardrobe)} total):
-{chr(10).join(wardrobe_details)}
-
-Categories: {categories_list}"""
-
-async def handle_wardrobe_chat(message: str, wardrobe: List[WardrobeItem], session_id: str, images: Optional[List[str]] = None) -> ChatResponse:
-    conv_context = get_conversation_context(session_id)
-    enhanced_message = enhance_message_with_context(message, conv_context["context"])
-    
-    wardrobe_context = format_wardrobe_for_prompt(wardrobe)
-    
-    wardrobe_by_category = {}
-    for item in wardrobe:
-        category = item.category.lower()
-        if category not in wardrobe_by_category:
-            wardrobe_by_category[category] = []
-        wardrobe_by_category[category].append(item)
-    
-    rag_chunks = retrieve_relevant_context(enhanced_message, top_k=3)
-    rag_context = format_rag_context(rag_chunks)
-    
-    occasion_keywords = ["defense", "project", "presentation", "meeting", "interview", "formal", "casual", "party", "wedding", "dinner", "date", "work", "office"]
-    occasion = next((word for word in occasion_keywords if word in enhanced_message.lower()), None)
-    
-    context_info = f"Available wardrobe categories: {', '.join(wardrobe_by_category.keys())}. "
-    if occasion:
-        context_info += f"Occasion: {occasion}. "
-    
-    system_override = "You are a friendly and helpful fashion stylist. Suggest complete outfits conversationally and warmly. Include accessories when available. Be natural and friendly in your responses."
-    
-    prompt = f"""{wardrobe_context}
-
-User request: {enhanced_message}
-
-Suggest a complete outfit using ONLY the items listed above. Reference items by their exact names as shown (e.g., if item is "zara black pants", say "zara black pants", not "black zara pants"). Include accessories (watches, bags, jewelry, belts, glasses) if available. Be friendly and conversational. Suggest: one top/shirt, one bottom (pants/shorts), shoes, and accessories. Explain briefly why it works."""
-    
-    if context_info.strip():
-        prompt += f"\n\nContext: {context_info.strip()}"
-    
-    response_text = generate_chat_response(prompt, max_length=512, temperature=0.8, rag_context=rag_context, system_override=system_override, images=images)
-    
-    response_text = clean_wardrobe_response(response_text)
-    
-    update_context(session_id, message, {
-        "response": response_text,
-        "wardrobe_count": len(wardrobe),
-        "categories": list(wardrobe_by_category.keys())
-    })
-    
-    return ChatResponse(
-        response=response_text,
-        session_id=session_id
-    )
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat(request: ChatRequest):
-    try:
-        message = request.message.strip()
-        session_id = request.session_id
-        
-        if not message:
-            raise HTTPException(status_code=400, detail="Message cannot be empty")
-        
-        if request.wardrobe and len(request.wardrobe) > 0:
-            print(f"[WARDROBE CHAT] ===== WARDROBE REQUEST DETECTED =====")
-            return await handle_wardrobe_chat(message, request.wardrobe, session_id, images=request.images)
-        
-        conv_context = get_conversation_context(session_id)
-        
-        if is_name_question(message):
-            prompt = "What is your name? Respond naturally and friendly."
-            rag_chunks = retrieve_relevant_context(message, top_k=2)
-            rag_context = format_rag_context(rag_chunks)
-            response_text = generate_chat_response(prompt, max_length=100, temperature=0.8, rag_context=rag_context, images=request.images)
-            update_context(session_id, message, {"response": response_text})
-            return ChatResponse(response=response_text, session_id=session_id)
-        
-        if is_greeting(message):
-            prompt = f"{message} Respond warmly and offer to help with fashion advice."
-            rag_chunks = retrieve_relevant_context(message, top_k=2)
-            rag_context = format_rag_context(rag_chunks)
-            response_text = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=request.images)
-            update_context(session_id, message, {"response": response_text})
-            return ChatResponse(response=response_text, session_id=session_id)
-        
-        enhanced_message = enhance_message_with_context(message, conv_context["context"])
-        query_type = detect_query_type(enhanced_message)
-        rag_chunks = retrieve_relevant_context(enhanced_message, top_k=3)
-        rag_context = format_rag_context(rag_chunks)
-        
-        if query_type == "color_compatibility":
-            found_colors = extract_colors_from_query(enhanced_message)
-            
-            if len(found_colors) >= 2:
-                color1_mapped = found_colors[0][1]
-                color2_mapped = found_colors[1][1]
-                color1_original = found_colors[0][0]
-                color2_original = found_colors[1][0]
-                
-                compatible = False
-                if color1_mapped in COLOR_HARMONY:
-                    compatible = color2_mapped in COLOR_HARMONY[color1_mapped]
-                elif color2_mapped in COLOR_HARMONY:
-                    compatible = color1_mapped in COLOR_HARMONY[color2_mapped]
-                
-                neutrals = ["white", "black", "grey", "gray", "beige", "navy"]
-                if color1_mapped in neutrals or color2_mapped in neutrals:
-                    compatible = True
-                
-                if compatible:
-                    response_text = f"Yes, {color1_original.title()} will go well with {color2_original.title()}. They create a balanced and stylish combination that works great together!"
-                else:
-                    response_text = f"{color1_original.title()} and {color2_original.title()} can work together, though you might want to add some neutral pieces to balance the look."
-                
-                prompt = f"Does {color1_original} go well with {color2_original}? Answer naturally and conversationally."
-                ai_response = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=request.images)
-                if len(ai_response) > 15:
-                    response_text = ai_response
-                
-                update_context(session_id, message, {
-                    "response": response_text,
-                    "color": color1_original,
-                    "colors": [color1_original, color2_original]
-                })
-                
-                return ChatResponse(
-                    response=response_text,
-                    session_id=session_id
-                )
-        
-        elif query_type == "color_suggestion":
-            clothing_info = extract_clothing_info(enhanced_message)
-            base_color = clothing_info.get("color")
-            
-            if not base_color:
-                found_colors = extract_colors_from_query(enhanced_message)
-                if found_colors:
-                    base_color = found_colors[0][1]
-                elif conv_context["context"].get("last_color"):
-                    base_color = conv_context["context"]["last_color"]
-            
-            if not base_color:
-                return ChatResponse(
-                    response="I'd love to help you with colors! Could you tell me which color you're working with? For example, 'what colors go with red?'",
-                    session_id=session_id
-                )
-            
-            matching_colors = get_color_matches(base_color)
-            clothing_item = clothing_info.get("existing_item") or clothing_info.get("type") or conv_context["context"].get("last_item", "outfit")
-            
-            suggested_colors = [c.title() for c in matching_colors[:4]]
-            
-            message_lower_for_style = message.lower()
-            style_keywords = []
-            if "stylish" in message_lower_for_style or "standout" in message_lower_for_style or "stand out" in message_lower_for_style:
-                style_keywords.append("stylish and eye-catching")
-            if "professional" in message_lower_for_style or "formal" in message_lower_for_style:
-                style_keywords.append("professional")
-            if "casual" in message_lower_for_style:
-                style_keywords.append("casual")
-            
-            style_note = ""
-            if style_keywords:
-                style_note = f" The user wants something {', '.join(style_keywords)}."
-            
-            prompt = f"What colors go well with {base_color} {clothing_item}?{style_note} Give me a natural, conversational answer with specific color suggestions."
-            ai_response = generate_chat_response(prompt, max_length=300, temperature=0.8, rag_context=rag_context, images=request.images)
-            if len(ai_response) > 30:
-                response_text = ai_response
-            else:
-                response_text = f"For your {base_color} {clothing_item}, I'd suggest pairing it with {', '.join(suggested_colors[:3])}, or {suggested_colors[3] if len(suggested_colors) > 3 else 'other neutrals'}. These colors complement each other beautifully!"
-            
-            update_context(session_id, message, {
-                "response": response_text,
-                "color": base_color,
-                "item": clothing_item,
-                "colors": suggested_colors
-            })
-            
-            return ChatResponse(
-                response=response_text,
-                session_id=session_id
-            )
-        
-        else:
-            clothing_info = extract_clothing_info(enhanced_message)
-            
-            if not clothing_info.get("color") and conv_context["context"].get("last_color"):
-                enhanced_message = f"{enhanced_message} {conv_context['context']['last_color']}"
-                clothing_info = extract_clothing_info(enhanced_message)
-            
-            context_info = ""
-            if clothing_info.get("color"):
-                context_info += f"Color preference: {clothing_info.get('color')}. "
-            if clothing_info.get("type"):
-                context_info += f"Item type: {clothing_info.get('type')}. "
-            if clothing_info.get("existing_item"):
-                context_info += f"User has: {clothing_info.get('existing_item')}. "
-            
-            occasion_keywords = ["defense", "project", "presentation", "meeting", "interview", "formal", "casual", "party", "wedding"]
-            occasion = next((word for word in occasion_keywords if word in enhanced_message.lower()), None)
-            if occasion:
-                context_info += f"Occasion: {occasion}. "
-            
-            prompt = f"{enhanced_message}"
-            if context_info:
-                prompt += f"\n\nContext: {context_info.strip()}"
-            prompt += "\n\nGive helpful, detailed outfit suggestions that are practical and stylish. Be specific about item combinations and explain why they work well."
-            
-            response_text = generate_chat_response(prompt, max_length=1024, temperature=0.8, rag_context=rag_context, images=request.images)
-            
-            update_context(session_id, message, {
-                "response": response_text,
-                "color": clothing_info.get("color"),
-                "item": clothing_info.get("type") or clothing_info.get("requested_item"),
-                "items": clothing_info.get("items", [])
-            })
-            
-            return ChatResponse(
-                response=response_text,
-                session_id=session_id
-            )
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error processing chat message: {str(e)}")
-
-@app.post("/chat/upload", response_model=ChatResponse)
-async def chat_with_upload(
-    message: str = Form(...),
-    session_id: str = Form(default="default"),
-    wardrobe: Optional[str] = Form(default=None),
-    images: List[UploadFile] = File(default=[])
-):
-    try:
-        wardrobe_items = []
-        if wardrobe and wardrobe.strip() and wardrobe.strip() not in ["[]", "", "string"]:
-            try:
-                wardrobe_data = json.loads(wardrobe)
-                if isinstance(wardrobe_data, list):
-                    wardrobe_items = [WardrobeItem(**item) for item in wardrobe_data]
-            except json.JSONDecodeError:
-                print(f"[UPLOAD] Ignoring invalid wardrobe value: {wardrobe[:50]}")
-        
-        image_data_urls = []
-        for img_file in images:
-            if img_file.filename:
-                content = await img_file.read()
-                content_type = img_file.content_type or "image/jpeg"
-                base64_data = base64.b64encode(content).decode("utf-8")
-                data_url = f"data:{content_type};base64,{base64_data}"
-                image_data_urls.append(data_url)
-                print(f"[UPLOAD] Processed image: {img_file.filename} ({len(content)} bytes)")
-        
-        request = ChatRequest(
-            message=message,
-            session_id=session_id,
-            wardrobe=wardrobe_items if wardrobe_items else None,
-            images=image_data_urls if image_data_urls else None
-        )
-        
-        print(f"[UPLOAD] Processing chat request: message='{message[:50]}...', images={len(image_data_urls)}, wardrobe={len(wardrobe_items)}")
-        result = await chat(request)
-        print(f"[UPLOAD] Response generated: {len(result.response)} chars")
-        return result
-    
-    except Exception as e:
-        print(f"[UPLOAD] Error: {e}")
-        raise HTTPException(status_code=500, detail=f"Error processing upload: {str(e)}")
-
-@app.post("/chat/upload/stream")
-async def chat_with_upload_stream(
-    message: str = Form(...),
-    session_id: str = Form(default="default"),
-    wardrobe: Optional[str] = Form(default=None),
-    images: List[UploadFile] = File(default=[])
-):
-    image_data_urls = []
-    for img_file in images:
-        if img_file.filename:
-            content = await img_file.read()
-            content_type = img_file.content_type or "image/jpeg"
-            base64_data = base64.b64encode(content).decode("utf-8")
-            data_url = f"data:{content_type};base64,{base64_data}"
-            image_data_urls.append(data_url)
-            print(f"[STREAM UPLOAD] Processed image: {img_file.filename} ({len(content)} bytes)")
-    
-    rag_chunks = retrieve_relevant_context(message, top_k=3)
-    rag_context = format_rag_context(rag_chunks)
-    
-    print(f"[STREAM UPLOAD] Starting streaming response for: {message[:50]}...")
-    
-    async def generate():
-        yield f"data: {json.dumps({'type': 'start', 'session_id': session_id})}\n\n"
-        
-        full_response = ""
-        async for chunk in generate_chat_response_streaming(
-            prompt=message,
-            max_length=512,
-            temperature=0.7,
-            rag_context=rag_context,
-            images=image_data_urls if image_data_urls else None
-        ):
-            full_response += chunk
-            yield f"data: {json.dumps({'type': 'chunk', 'content': chunk})}\n\n"
-        
-        yield f"data: {json.dumps({'type': 'end', 'full_response': full_response, 'session_id': session_id})}\n\n"
-        print(f"[STREAM UPLOAD] Streaming complete: {len(full_response)} chars")
-        print(f"[STREAM RESPONSE] {full_response}")
-    
-    return StreamingResponse(
-        generate(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        }
-    )
+setup_routes(app)
 
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
-

config.py

@@ -0,0 +1,25 @@
+COLOR_HARMONY = {
+    "green": ["beige", "white", "grey", "gray", "navy", "black", "brown"],
+    "blue": ["white", "beige", "khaki", "grey", "gray", "navy", "red"],
+    "navy": ["white", "beige", "khaki", "grey", "gray", "red", "yellow"],
+    "black": ["white", "beige", "grey", "gray", "navy", "red", "blue"],
+    "white": ["black", "navy", "grey", "gray", "beige", "any color"],
+    "grey": ["black", "white", "navy", "beige", "blue"],
+    "gray": ["black", "white", "navy", "beige", "blue"],
+    "beige": ["green", "navy", "brown", "black", "white", "blue"],
+    "red": ["white", "black", "navy", "blue", "beige"],
+    "brown": ["beige", "white", "navy", "green", "blue"],
+    "yellow": ["navy", "black", "white", "grey", "gray"],
+    "pink": ["white", "navy", "grey", "gray", "black"],
+    "purple": ["white", "grey", "gray", "black", "navy"],
+    "orange": ["navy", "white", "black", "beige"],
+}
+
+CLOTHING_TYPES = [
+    "hoodie", "sweatshirt", "t-shirt", "shirt", "blazer", "jacket",
+    "jeans", "pants", "chinos", "trousers", "shorts",
+    "sneakers", "boots", "shoes", "sandal", "heels",
+    "dress", "skirt", "top", "sweater", "cardigan",
+    "vest", "coat", "parka", "blouse", "polo"
+]
+

conversation.py

@@ -0,0 +1,41 @@
+from config import CLOTHING_TYPES
+
+conversation_memory = {}
+
+def get_conversation_context(session_id: str) -> dict:
+    if session_id not in conversation_memory:
+        conversation_memory[session_id] = {
+            "messages": [],
+            "context": {}
+        }
+    return conversation_memory[session_id]
+
+def update_context(session_id: str, message: str, response_data: dict):
+    conv = conversation_memory[session_id]
+    conv["messages"].append({"user": message, "assistant": response_data.get("response", "")})
+    
+    if len(conv["messages"]) > 10:
+        conv["messages"] = conv["messages"][-10:]
+    
+    if "color" in response_data:
+        conv["context"]["last_color"] = response_data["color"]
+    if "item" in response_data:
+        conv["context"]["last_item"] = response_data["item"]
+    if "colors" in response_data:
+        conv["context"]["last_colors"] = response_data["colors"]
+    if "items" in response_data:
+        conv["context"]["last_items"] = response_data["items"]
+
+def enhance_message_with_context(message: str, context: dict) -> str:
+    message_lower = message.lower()
+    
+    if "what about" in message_lower or "how about" in message_lower or "and" in message_lower:
+        if context.get("last_color"):
+            if not any(c in message_lower for c in ["color", "red", "blue", "green", "black", "white", "brown"]):
+                message = message + f" with {context['last_color']}"
+        if context.get("last_item"):
+            if not any(item in message_lower for item in CLOTHING_TYPES):
+                message = message + f" {context['last_item']}"
+    
+    return message
+

image_utils.py

@@ -0,0 +1,82 @@
+import base64
+from PIL import Image
+import requests
+from io import BytesIO
+import numpy as np
+
+def is_placeholder_image(image: Image.Image) -> bool:
+    img_array = np.array(image)
+    
+    if len(img_array.shape) != 3:
+        return True
+    
+    height, width = img_array.shape[:2]
+    
+    gray = np.mean(img_array, axis=2)
+    
+    unique_colors = len(np.unique(gray))
+    
+    if unique_colors < 10:
+        return True
+    
+    black_white_ratio = np.sum((gray < 20) | (gray > 235)) / (height * width)
+    
+    if black_white_ratio > 0.8:
+        return True
+    
+    std_dev = np.std(gray)
+    if std_dev < 15:
+        return True
+    
+    sample_size = min(100, height // 10, width // 10)
+    if sample_size < 2:
+        return False
+    
+    step_h = height // sample_size
+    step_w = width // sample_size
+    
+    grid_pattern = True
+    for i in range(0, height - step_h, step_h):
+        for j in range(0, width - step_w, step_w):
+            block = gray[i:i+step_h, j:j+step_w]
+            block_std = np.std(block)
+            if block_std > 30:
+                grid_pattern = False
+                break
+        if not grid_pattern:
+            break
+    
+    if grid_pattern and black_white_ratio > 0.5:
+        return True
+    
+    return False
+
+def load_image_from_url(url_or_base64: str) -> Image.Image:
+    try:
+        if url_or_base64.startswith("data:image"):
+            header, encoded = url_or_base64.split(",", 1)
+            image_data = base64.b64decode(encoded)
+            return Image.open(BytesIO(image_data)).convert("RGB")
+        else:
+            response = requests.get(url_or_base64, timeout=10)
+            response.raise_for_status()
+            return Image.open(BytesIO(response.content)).convert("RGB")
+    except Exception as e:
+        raise ValueError(f"Failed to load image: {str(e)}")
+
+def filter_valid_images(images: list) -> list:
+    valid_images = []
+    for img in images:
+        if not img or not isinstance(img, str) or img.strip() in ["", "string", "null", "undefined"]:
+            continue
+        try:
+            pil_image = load_image_from_url(img)
+            if not is_placeholder_image(pil_image):
+                valid_images.append(pil_image)
+            else:
+                print(f"[IMAGE FILTER] Ignoring placeholder/empty image")
+        except Exception as e:
+            print(f"[IMAGE FILTER] Warning: Failed to load image: {e}, skipping")
+            continue
+    return valid_images
+

model_manager.py

@@ -0,0 +1,220 @@
+import os
+import threading
+import torch
+from typing import List, Optional, AsyncGenerator
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
+from fastapi import HTTPException
+from image_utils import filter_valid_images
+
+style_model = None
+style_processor = None
+model_lock = threading.Lock()
+
+def ensure_model_loaded():
+    global style_model, style_processor
+    
+    if style_model is not None:
+        return
+    
+    print("Loading model (lazy load on first request)...")
+    model_id = "Qwen/Qwen2.5-VL-7B-Instruct"
+    hf_token = os.getenv("HF_TOKEN")
+    
+    try:
+        if hf_token:
+            style_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                model_id,
+                token=hf_token,
+                torch_dtype=torch.float32,
+                device_map="auto",
+                low_cpu_mem_usage=True
+            )
+            style_processor = AutoProcessor.from_pretrained(model_id, token=hf_token)
+        else:
+            style_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                model_id,
+                torch_dtype=torch.float32,
+                device_map="auto",
+                low_cpu_mem_usage=True
+            )
+            style_processor = AutoProcessor.from_pretrained(model_id)
+        
+        print(f"Loaded {model_id}")
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        raise
+
+def generate_chat_response(prompt: str, max_length: int = 512, temperature: float = 0.7, rag_context: Optional[str] = None, system_override: Optional[str] = None, images: Optional[List[str]] = None) -> str:
+    ensure_model_loaded()
+    
+    system_message = system_override if system_override else "You are StyleGPT, a friendly and helpful fashion stylist assistant. You give natural, conversational advice about clothing, colors, and outfit combinations. Always be warm, friendly, and advisory in your responses. When asked your name, say you're StyleGPT. When greeted, respond warmly and offer to help with fashion advice."
+    
+    if rag_context:
+        system_message += f"\n\n{rag_context}\n\nUse this fashion knowledge to provide accurate and helpful advice. Reference this knowledge naturally in your responses."
+    
+    user_content = []
+    if images:
+        valid_images = filter_valid_images(images)
+        for pil_image in valid_images:
+            user_content.append({"type": "image", "image": pil_image})
+    user_content.append({"type": "text", "text": prompt})
+    
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_content}
+    ]
+    
+    try:
+        text = style_processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        
+        image_inputs, video_inputs = process_vision_info(messages)
+        
+        inputs = style_processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
+        )
+        
+        inputs = {k: v.to(style_model.device) for k, v in inputs.items()}
+        
+        temperature = max(0.1, min(1.5, temperature))
+        
+        with model_lock:
+            with torch.no_grad():
+                try:
+                    outputs = style_model.generate(
+                        **inputs,
+                        max_new_tokens=max_length,
+                        temperature=temperature,
+                        top_p=0.95,
+                        top_k=50,
+                        do_sample=True,
+                        eos_token_id=style_processor.tokenizer.eos_token_id,
+                        pad_token_id=style_processor.tokenizer.pad_token_id,
+                        repetition_penalty=1.1,
+                    )
+                except RuntimeError as e:
+                    if "probability tensor" in str(e) or "inf" in str(e) or "nan" in str(e):
+                        print(f"[GENERATE] Probability error, retrying with greedy decoding")
+                        outputs = style_model.generate(
+                            **inputs,
+                            max_new_tokens=max_length,
+                            do_sample=False,
+                            eos_token_id=style_processor.tokenizer.eos_token_id,
+                            pad_token_id=style_processor.tokenizer.pad_token_id,
+                            repetition_penalty=1.1,
+                        )
+                    else:
+                        raise
+        
+        generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, outputs)
+        ]
+        generated_text = style_processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )[0]
+        
+        generated_text = generated_text.strip()
+        return generated_text
+        
+    except Exception as e:
+        print(f"[GENERATE] Error: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Generation error: {str(e)}")
+
+async def generate_chat_response_streaming(prompt: str, max_length: int = 512, temperature: float = 0.7, rag_context: Optional[str] = None, system_override: Optional[str] = None, images: Optional[List[str]] = None) -> AsyncGenerator[str, None]:
+    ensure_model_loaded()
+    
+    system_message = system_override if system_override else "You are StyleGPT, a friendly and helpful fashion stylist assistant. You give natural, conversational advice about clothing, colors, and outfit combinations. Always be warm, friendly, and advisory in your responses. When asked your name, say you're StyleGPT. When greeted, respond warmly and offer to help with fashion advice."
+    
+    if rag_context:
+        system_message += f"\n\n{rag_context}\n\nUse this fashion knowledge to provide accurate and helpful advice. Reference this knowledge naturally in your responses."
+    
+    user_content = []
+    if images:
+        valid_images = filter_valid_images(images)
+        for pil_image in valid_images:
+            user_content.append({"type": "image", "image": pil_image})
+    user_content.append({"type": "text", "text": prompt})
+    
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_content}
+    ]
+    
+    try:
+        text = style_processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        
+        image_inputs, video_inputs = process_vision_info(messages)
+        
+        inputs = style_processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
+        )
+        
+        inputs = {k: v.to(style_model.device) for k, v in inputs.items()}
+        
+        temperature = max(0.1, min(1.5, temperature))
+        
+        with model_lock:
+            with torch.no_grad():
+                try:
+                    outputs = style_model.generate(
+                        **inputs,
+                        max_new_tokens=max_length,
+                        temperature=temperature,
+                        top_p=0.95,
+                        top_k=50,
+                        do_sample=True,
+                        eos_token_id=style_processor.tokenizer.eos_token_id,
+                        pad_token_id=style_processor.tokenizer.pad_token_id,
+                        repetition_penalty=1.1,
+                    )
+                except RuntimeError as e:
+                    if "probability tensor" in str(e) or "inf" in str(e) or "nan" in str(e):
+                        print(f"[GENERATE STREAM] Probability error, retrying with greedy decoding")
+                        outputs = style_model.generate(
+                            **inputs,
+                            max_new_tokens=max_length,
+                            do_sample=False,
+                            eos_token_id=style_processor.tokenizer.eos_token_id,
+                            pad_token_id=style_processor.tokenizer.pad_token_id,
+                            repetition_penalty=1.1,
+                        )
+                    else:
+                        raise
+        
+        generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, outputs)
+        ]
+        generated_text = style_processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )[0]
+        
+        generated_text = generated_text.strip()
+        
+        import asyncio
+        for char in generated_text:
+            yield char
+            await asyncio.sleep(0.01)
+    except Exception as e:
+        print(f"[GENERATE STREAM] Error: {e}")
+        import traceback
+        traceback.print_exc()
+        error_msg = f"I apologize, but I encountered an error generating a response. Please try again."
+        import asyncio
+        for char in error_msg:
+            yield char
+            await asyncio.sleep(0.01)
+

models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class WardrobeItem(BaseModel):
+    id: Optional[int] = None
+    category: str
+    style: str
+    color: Optional[str] = None
+    brand: Optional[str] = None
+    name: Optional[str] = None
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = "default"
+    wardrobe: Optional[List[WardrobeItem]] = None
+    images: Optional[List[str]] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+
+class TextRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = "default"
+

query_processing.py

@@ -0,0 +1,140 @@
+import re
+from typing import List
+from config import COLOR_HARMONY, CLOTHING_TYPES
+
+def extract_clothing_info(text: str) -> dict:
+    text_lower = text.lower()
+    
+    colors = list(COLOR_HARMONY.keys())
+    found_color = None
+    for color in colors:
+        if color in text_lower:
+            found_color = color
+            break
+    
+    found_types = []
+    for clothing_type in CLOTHING_TYPES:
+        if clothing_type in text_lower:
+            found_types.append(clothing_type)
+    
+    existing_item = None
+    requested_item = None
+    
+    question_patterns = ["what kind of", "what", "which", "suggest", "recommend"]
+    is_question = any(pattern in text_lower for pattern in question_patterns)
+    
+    if is_question and len(found_types) > 0:
+        if "my" in text_lower or "i have" in text_lower or "i'm wearing" in text_lower:
+            for i, word in enumerate(text_lower.split()):
+                if word == "my" and i + 1 < len(text_lower.split()):
+                    next_words = " ".join(text_lower.split()[i+1:i+4])
+                    for ct in found_types:
+                        if ct in next_words:
+                            existing_item = ct
+                            break
+                if existing_item:
+                    break
+        
+        for ct in found_types:
+            if "match" in text_lower or "go with" in text_lower or "pair" in text_lower:
+                ct_pos = text_lower.find(ct)
+                match_pos = text_lower.find("match")
+                if ct_pos > match_pos or "what kind of" in text_lower[:ct_pos]:
+                    requested_item = ct
+                    break
+    
+    if not existing_item and not requested_item and found_types:
+        if is_question:
+            requested_item = found_types[0]
+        else:
+            existing_item = found_types[0]
+    
+    return {
+        "color": found_color,
+        "type": existing_item or requested_item,
+        "existing_item": existing_item,
+        "requested_item": requested_item,
+        "is_question": is_question,
+        "raw_text": text
+    }
+
+def get_color_matches(color: str) -> List[str]:
+    color_lower = color.lower()
+    return COLOR_HARMONY.get(color_lower, ["white", "black", "grey", "beige"])
+
+def extract_colors_from_query(query: str) -> tuple:
+    query_lower = query.lower()
+    colors = list(COLOR_HARMONY.keys())
+    
+    extended_colors = ["navy blue", "wine", "burgundy", "maroon", "crimson", "scarlet", "mauve", "taupe", "olive", "teal", "turquoise", "indigo", "cobalt"]
+    all_colors = extended_colors + colors
+    
+    color_mapping = {
+        "wine": "red", "burgundy": "red", "maroon": "red",
+        "mauve": "purple", "taupe": "beige", "olive": "green",
+        "teal": "blue", "turquoise": "blue", "indigo": "navy", "cobalt": "blue",
+        "navy blue": "navy"
+    }
+    
+    found_colors = []
+    seen_mapped = set()
+    for color in all_colors:
+        if color in query_lower:
+            mapped = color_mapping.get(color, color)
+            if mapped not in seen_mapped:
+                found_colors.append((color, mapped))
+                seen_mapped.add(mapped)
+    
+    return found_colors
+
+def detect_query_type(message: str) -> str:
+    message_lower = message.lower()
+    
+    color_comparison_patterns = ["does", "do", "will", "can"]
+    comparison_keywords = ["go with", "match", "work with", "pair with", "combine with"]
+    color_suggestion_patterns = ["what color", "which color", "colors go with", "colors match", "better color", "color to match"]
+    
+    has_two_colors = len(extract_colors_from_query(message)) >= 2
+    
+    if any(pattern in message_lower for pattern in color_comparison_patterns) and any(kw in message_lower for kw in comparison_keywords) and has_two_colors:
+        return "color_compatibility"
+    
+    outfit_request_patterns = ["suggest", "recommend", "outfit", "wear", "dress", "thinking of", "what should i wear", "what can i wear", "what to wear"]
+    what_matches_patterns = ["what will go", "what goes with", "what matches", "what will match", "what can go"]
+    
+    if any(pattern in message_lower for pattern in what_matches_patterns) and any(item in message_lower for item in CLOTHING_TYPES):
+        return "outfit_suggestion"
+    
+    if any(pattern in message_lower for pattern in outfit_request_patterns):
+        return "outfit_suggestion"
+    
+    if any(pattern in message_lower for pattern in color_suggestion_patterns):
+        return "color_suggestion"
+    
+    if any(ct in message_lower for ct in CLOTHING_TYPES) and any(c in message_lower for c in ["with", "match", "go", "pair", "style", "stylish", "look"]):
+        return "outfit_suggestion"
+    
+    if len(extract_colors_from_query(message)) > 0 and any(word in message_lower for word in ["match", "with", "go", "pair"]):
+        return "color_suggestion"
+    
+    if any(ct in message_lower for ct in CLOTHING_TYPES):
+        return "outfit_suggestion"
+    
+    return "outfit_suggestion"
+
+def is_greeting(message: str) -> bool:
+    message_lower = message.lower().strip()
+    greetings = [
+        "hello", "hi", "hey", "good morning", "good afternoon", "good evening",
+        "greetings", "howdy", "what's up", "whats up", "sup", "yo"
+    ]
+    return any(message_lower.startswith(g) or message_lower == g for g in greetings)
+
+def is_name_question(message: str) -> bool:
+    message_lower = message.lower().strip()
+    name_patterns = [
+        "what is your name", "what's your name", "whats your name",
+        "who are you", "what are you", "tell me your name", "your name"
+    ]
+    return any(pattern in message_lower for pattern in name_patterns)
+

routes.py

@@ -0,0 +1,475 @@
+import json
+import base64
+from typing import List, Optional
+from fastapi import HTTPException, UploadFile, File, Form
+from fastapi.responses import StreamingResponse
+from models import ChatRequest, ChatResponse, WardrobeItem, TextRequest
+from query_processing import (
+    extract_clothing_info, extract_colors_from_query, detect_query_type,
+    get_color_matches, is_greeting, is_name_question
+)
+from conversation import (
+    get_conversation_context, enhance_message_with_context, update_context
+)
+from model_manager import generate_chat_response, generate_chat_response_streaming
+from wardrobe import handle_wardrobe_chat
+from rag import retrieve_relevant_context, format_rag_context
+from config import COLOR_HARMONY
+from model_manager import style_model
+
+def setup_routes(app):
+    @app.get("/")
+    async def root():
+        return {
+            "message": "Style GPT API - Milestone 1",
+            "version": "1.0.0",
+            "endpoints": {
+                "/text": "POST - Text-only chat",
+                "/chat": "POST - Chat with optional images",
+                "/chat/upload": "POST - Chat with file upload",
+                "/chat/upload/stream": "POST - Streaming chat with file upload",
+                "/health": "GET - Health check"
+            }
+        }
+
+    @app.get("/health")
+    async def health_check():
+        return {
+            "status": "healthy" if style_model is not None else "loading",
+            "model_loaded": style_model is not None,
+            "model_name": "Qwen/Qwen2.5-VL-7B-Instruct"
+        }
+
+    @app.post("/text", response_model=ChatResponse)
+    async def text_only(request: TextRequest):
+        try:
+            message = request.message.strip()
+            session_id = request.session_id
+            
+            if not message:
+                raise HTTPException(status_code=400, detail="Message cannot be empty")
+            
+            conv_context = get_conversation_context(session_id)
+            
+            if is_name_question(message):
+                prompt = "What is your name? Respond naturally and friendly."
+                rag_chunks = retrieve_relevant_context(message, top_k=2)
+                rag_context = format_rag_context(rag_chunks)
+                response_text = generate_chat_response(prompt, max_length=100, temperature=0.8, rag_context=rag_context, images=None)
+                update_context(session_id, message, {"response": response_text})
+                return ChatResponse(response=response_text, session_id=session_id)
+            
+            if is_greeting(message):
+                prompt = f"{message} Respond warmly and offer to help with fashion advice."
+                rag_chunks = retrieve_relevant_context(message, top_k=2)
+                rag_context = format_rag_context(rag_chunks)
+                response_text = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=None)
+                update_context(session_id, message, {"response": response_text})
+                return ChatResponse(response=response_text, session_id=session_id)
+            
+            enhanced_message = enhance_message_with_context(message, conv_context["context"])
+            query_type = detect_query_type(enhanced_message)
+            rag_chunks = retrieve_relevant_context(enhanced_message, top_k=3)
+            rag_context = format_rag_context(rag_chunks)
+            
+            if query_type == "color_compatibility":
+                found_colors = extract_colors_from_query(enhanced_message)
+                
+                if len(found_colors) >= 2:
+                    color1_mapped = found_colors[0][1]
+                    color2_mapped = found_colors[1][1]
+                    color1_original = found_colors[0][0]
+                    color2_original = found_colors[1][0]
+                    
+                    compatible = False
+                    if color1_mapped in COLOR_HARMONY:
+                        compatible = color2_mapped in COLOR_HARMONY[color1_mapped]
+                    elif color2_mapped in COLOR_HARMONY:
+                        compatible = color1_mapped in COLOR_HARMONY[color2_mapped]
+                    
+                    neutrals = ["white", "black", "grey", "gray", "beige", "navy"]
+                    if color1_mapped in neutrals or color2_mapped in neutrals:
+                        compatible = True
+                    
+                    if compatible:
+                        response_text = f"Yes, {color1_original.title()} will go well with {color2_original.title()}. They create a balanced and stylish combination that works great together!"
+                    else:
+                        response_text = f"{color1_original.title()} and {color2_original.title()} can work together, though you might want to add some neutral pieces to balance the look."
+                    
+                    prompt = f"Does {color1_original} go well with {color2_original}? Answer naturally and conversationally."
+                    ai_response = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=None)
+                    if len(ai_response) > 15:
+                        response_text = ai_response
+                    
+                    update_context(session_id, message, {
+                        "response": response_text,
+                        "color": color1_original,
+                        "colors": [color1_original, color2_original]
+                    })
+                    
+                    return ChatResponse(
+                        response=response_text,
+                        session_id=session_id
+                    )
+            
+            elif query_type == "color_suggestion":
+                clothing_info = extract_clothing_info(enhanced_message)
+                base_color = clothing_info.get("color")
+                
+                if not base_color:
+                    found_colors = extract_colors_from_query(enhanced_message)
+                    if found_colors:
+                        base_color = found_colors[0][1]
+                    elif conv_context["context"].get("last_color"):
+                        base_color = conv_context["context"]["last_color"]
+                
+                if not base_color:
+                    return ChatResponse(
+                        response="I'd love to help you with colors! Could you tell me which color you're working with? For example, 'what colors go with red?'",
+                        session_id=session_id
+                    )
+                
+                matching_colors = get_color_matches(base_color)
+                clothing_item = clothing_info.get("existing_item") or clothing_info.get("type") or conv_context["context"].get("last_item", "outfit")
+                
+                suggested_colors = [c.title() for c in matching_colors[:4]]
+                
+                message_lower_for_style = message.lower()
+                style_keywords = []
+                if "stylish" in message_lower_for_style or "standout" in message_lower_for_style or "stand out" in message_lower_for_style:
+                    style_keywords.append("stylish and eye-catching")
+                if "professional" in message_lower_for_style or "formal" in message_lower_for_style:
+                    style_keywords.append("professional")
+                if "casual" in message_lower_for_style:
+                    style_keywords.append("casual")
+                
+                style_note = ""
+                if style_keywords:
+                    style_note = f" The user wants something {', '.join(style_keywords)}."
+                
+                prompt = f"What colors go well with {base_color} {clothing_item}?{style_note} Give me a natural, conversational answer with specific color suggestions."
+                ai_response = generate_chat_response(prompt, max_length=300, temperature=0.8, rag_context=rag_context, images=None)
+                if len(ai_response) > 30:
+                    response_text = ai_response
+                else:
+                    response_text = f"For your {base_color} {clothing_item}, I'd suggest pairing it with {', '.join(suggested_colors[:3])}, or {suggested_colors[3] if len(suggested_colors) > 3 else 'other neutrals'}. These colors complement each other beautifully!"
+                
+                update_context(session_id, message, {
+                    "response": response_text,
+                    "color": base_color,
+                    "item": clothing_item,
+                    "colors": suggested_colors
+                })
+                
+                return ChatResponse(
+                    response=response_text,
+                    session_id=session_id
+                )
+            
+            else:
+                clothing_info = extract_clothing_info(enhanced_message)
+                
+                if not clothing_info.get("color") and conv_context["context"].get("last_color"):
+                    enhanced_message = f"{enhanced_message} {conv_context['context']['last_color']}"
+                    clothing_info = extract_clothing_info(enhanced_message)
+                
+                context_info = ""
+                if clothing_info.get("color"):
+                    context_info += f"Color preference: {clothing_info.get('color')}. "
+                if clothing_info.get("type"):
+                    context_info += f"Item type: {clothing_info.get('type')}. "
+                if clothing_info.get("existing_item"):
+                    context_info += f"User has: {clothing_info.get('existing_item')}. "
+                
+                occasion_keywords = ["defense", "project", "presentation", "meeting", "interview", "formal", "casual", "party", "wedding"]
+                occasion = next((word for word in occasion_keywords if word in enhanced_message.lower()), None)
+                if occasion:
+                    context_info += f"Occasion: {occasion}. "
+                
+                prompt = f"{enhanced_message}"
+                if context_info:
+                    prompt += f"\n\nContext: {context_info.strip()}"
+                prompt += "\n\nGive helpful, detailed outfit suggestions that are practical and stylish. Be specific about item combinations and explain why they work well."
+                
+                response_text = generate_chat_response(prompt, max_length=1024, temperature=0.8, rag_context=rag_context, images=None)
+                
+                update_context(session_id, message, {
+                    "response": response_text,
+                    "color": clothing_info.get("color"),
+                    "item": clothing_info.get("type") or clothing_info.get("requested_item"),
+                    "items": clothing_info.get("items", [])
+                })
+                
+                return ChatResponse(
+                    response=response_text,
+                    session_id=session_id
+                )
+        
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error processing text message: {str(e)}")
+
+    @app.post("/chat", response_model=ChatResponse)
+    async def chat(request: ChatRequest):
+        try:
+            message = request.message.strip()
+            session_id = request.session_id
+            
+            if not message:
+                raise HTTPException(status_code=400, detail="Message cannot be empty")
+            
+            if request.wardrobe and len(request.wardrobe) > 0:
+                print(f"[WARDROBE CHAT] ===== WARDROBE REQUEST DETECTED =====")
+                return await handle_wardrobe_chat(message, request.wardrobe, session_id, images=request.images)
+            
+            conv_context = get_conversation_context(session_id)
+            
+            if is_name_question(message):
+                prompt = "What is your name? Respond naturally and friendly."
+                rag_chunks = retrieve_relevant_context(message, top_k=2)
+                rag_context = format_rag_context(rag_chunks)
+                response_text = generate_chat_response(prompt, max_length=100, temperature=0.8, rag_context=rag_context, images=request.images)
+                update_context(session_id, message, {"response": response_text})
+                return ChatResponse(response=response_text, session_id=session_id)
+            
+            if is_greeting(message):
+                prompt = f"{message} Respond warmly and offer to help with fashion advice."
+                rag_chunks = retrieve_relevant_context(message, top_k=2)
+                rag_context = format_rag_context(rag_chunks)
+                response_text = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=request.images)
+                update_context(session_id, message, {"response": response_text})
+                return ChatResponse(response=response_text, session_id=session_id)
+            
+            enhanced_message = enhance_message_with_context(message, conv_context["context"])
+            query_type = detect_query_type(enhanced_message)
+            rag_chunks = retrieve_relevant_context(enhanced_message, top_k=3)
+            rag_context = format_rag_context(rag_chunks)
+            
+            if query_type == "color_compatibility":
+                found_colors = extract_colors_from_query(enhanced_message)
+                
+                if len(found_colors) >= 2:
+                    color1_mapped = found_colors[0][1]
+                    color2_mapped = found_colors[1][1]
+                    color1_original = found_colors[0][0]
+                    color2_original = found_colors[1][0]
+                    
+                    compatible = False
+                    if color1_mapped in COLOR_HARMONY:
+                        compatible = color2_mapped in COLOR_HARMONY[color1_mapped]
+                    elif color2_mapped in COLOR_HARMONY:
+                        compatible = color1_mapped in COLOR_HARMONY[color2_mapped]
+                    
+                    neutrals = ["white", "black", "grey", "gray", "beige", "navy"]
+                    if color1_mapped in neutrals or color2_mapped in neutrals:
+                        compatible = True
+                    
+                    if compatible:
+                        response_text = f"Yes, {color1_original.title()} will go well with {color2_original.title()}. They create a balanced and stylish combination that works great together!"
+                    else:
+                        response_text = f"{color1_original.title()} and {color2_original.title()} can work together, though you might want to add some neutral pieces to balance the look."
+                    
+                    prompt = f"Does {color1_original} go well with {color2_original}? Answer naturally and conversationally."
+                    ai_response = generate_chat_response(prompt, max_length=150, temperature=0.8, rag_context=rag_context, images=request.images)
+                    if len(ai_response) > 15:
+                        response_text = ai_response
+                    
+                    update_context(session_id, message, {
+                        "response": response_text,
+                        "color": color1_original,
+                        "colors": [color1_original, color2_original]
+                    })
+                    
+                    return ChatResponse(
+                        response=response_text,
+                        session_id=session_id
+                    )
+            
+            elif query_type == "color_suggestion":
+                clothing_info = extract_clothing_info(enhanced_message)
+                base_color = clothing_info.get("color")
+                
+                if not base_color:
+                    found_colors = extract_colors_from_query(enhanced_message)
+                    if found_colors:
+                        base_color = found_colors[0][1]
+                    elif conv_context["context"].get("last_color"):
+                        base_color = conv_context["context"]["last_color"]
+                
+                if not base_color:
+                    return ChatResponse(
+                        response="I'd love to help you with colors! Could you tell me which color you're working with? For example, 'what colors go with red?'",
+                        session_id=session_id
+                    )
+                
+                matching_colors = get_color_matches(base_color)
+                clothing_item = clothing_info.get("existing_item") or clothing_info.get("type") or conv_context["context"].get("last_item", "outfit")
+                
+                suggested_colors = [c.title() for c in matching_colors[:4]]
+                
+                message_lower_for_style = message.lower()
+                style_keywords = []
+                if "stylish" in message_lower_for_style or "standout" in message_lower_for_style or "stand out" in message_lower_for_style:
+                    style_keywords.append("stylish and eye-catching")
+                if "professional" in message_lower_for_style or "formal" in message_lower_for_style:
+                    style_keywords.append("professional")
+                if "casual" in message_lower_for_style:
+                    style_keywords.append("casual")
+                
+                style_note = ""
+                if style_keywords:
+                    style_note = f" The user wants something {', '.join(style_keywords)}."
+                
+                prompt = f"What colors go well with {base_color} {clothing_item}?{style_note} Give me a natural, conversational answer with specific color suggestions."
+                ai_response = generate_chat_response(prompt, max_length=300, temperature=0.8, rag_context=rag_context, images=request.images)
+                if len(ai_response) > 30:
+                    response_text = ai_response
+                else:
+                    response_text = f"For your {base_color} {clothing_item}, I'd suggest pairing it with {', '.join(suggested_colors[:3])}, or {suggested_colors[3] if len(suggested_colors) > 3 else 'other neutrals'}. These colors complement each other beautifully!"
+                
+                update_context(session_id, message, {
+                    "response": response_text,
+                    "color": base_color,
+                    "item": clothing_item,
+                    "colors": suggested_colors
+                })
+                
+                return ChatResponse(
+                    response=response_text,
+                    session_id=session_id
+                )
+            
+            else:
+                clothing_info = extract_clothing_info(enhanced_message)
+                
+                if not clothing_info.get("color") and conv_context["context"].get("last_color"):
+                    enhanced_message = f"{enhanced_message} {conv_context['context']['last_color']}"
+                    clothing_info = extract_clothing_info(enhanced_message)
+                
+                context_info = ""
+                if clothing_info.get("color"):
+                    context_info += f"Color preference: {clothing_info.get('color')}. "
+                if clothing_info.get("type"):
+                    context_info += f"Item type: {clothing_info.get('type')}. "
+                if clothing_info.get("existing_item"):
+                    context_info += f"User has: {clothing_info.get('existing_item')}. "
+                
+                occasion_keywords = ["defense", "project", "presentation", "meeting", "interview", "formal", "casual", "party", "wedding"]
+                occasion = next((word for word in occasion_keywords if word in enhanced_message.lower()), None)
+                if occasion:
+                    context_info += f"Occasion: {occasion}. "
+                
+                prompt = f"{enhanced_message}"
+                if context_info:
+                    prompt += f"\n\nContext: {context_info.strip()}"
+                prompt += "\n\nGive helpful, detailed outfit suggestions that are practical and stylish. Be specific about item combinations and explain why they work well."
+                
+                response_text = generate_chat_response(prompt, max_length=1024, temperature=0.8, rag_context=rag_context, images=request.images)
+                
+                update_context(session_id, message, {
+                    "response": response_text,
+                    "color": clothing_info.get("color"),
+                    "item": clothing_info.get("type") or clothing_info.get("requested_item"),
+                    "items": clothing_info.get("items", [])
+                })
+                
+                return ChatResponse(
+                    response=response_text,
+                    session_id=session_id
+                )
+        
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error processing chat message: {str(e)}")
+
+    @app.post("/chat/upload", response_model=ChatResponse)
+    async def chat_with_upload(
+        message: str = Form(...),
+        session_id: str = Form(default="default"),
+        wardrobe: Optional[str] = Form(default=None),
+        images: List[UploadFile] = File(default=[])
+    ):
+        try:
+            wardrobe_items = []
+            if wardrobe and wardrobe.strip() and wardrobe.strip() not in ["[]", "", "string"]:
+                try:
+                    wardrobe_data = json.loads(wardrobe)
+                    if isinstance(wardrobe_data, list):
+                        wardrobe_items = [WardrobeItem(**item) for item in wardrobe_data]
+                except json.JSONDecodeError:
+                    print(f"[UPLOAD] Ignoring invalid wardrobe value: {wardrobe[:50]}")
+            
+            image_data_urls = []
+            for img_file in images:
+                if img_file.filename:
+                    content = await img_file.read()
+                    content_type = img_file.content_type or "image/jpeg"
+                    base64_data = base64.b64encode(content).decode("utf-8")
+                    data_url = f"data:{content_type};base64,{base64_data}"
+                    image_data_urls.append(data_url)
+                    print(f"[UPLOAD] Processed image: {img_file.filename} ({len(content)} bytes)")
+            
+            request = ChatRequest(
+                message=message,
+                session_id=session_id,
+                wardrobe=wardrobe_items if wardrobe_items else None,
+                images=image_data_urls if image_data_urls else None
+            )
+            
+            print(f"[UPLOAD] Processing chat request: message='{message[:50]}...', images={len(image_data_urls)}, wardrobe={len(wardrobe_items)}")
+            result = await chat(request)
+            print(f"[UPLOAD] Response generated: {len(result.response)} chars")
+            return result
+        
+        except Exception as e:
+            print(f"[UPLOAD] Error: {e}")
+            raise HTTPException(status_code=500, detail=f"Error processing upload: {str(e)}")
+
+    @app.post("/chat/upload/stream")
+    async def chat_with_upload_stream(
+        message: str = Form(...),
+        session_id: str = Form(default="default"),
+        wardrobe: Optional[str] = Form(default=None),
+        images: List[UploadFile] = File(default=[])
+    ):
+        image_data_urls = []
+        for img_file in images:
+            if img_file.filename:
+                content = await img_file.read()
+                content_type = img_file.content_type or "image/jpeg"
+                base64_data = base64.b64encode(content).decode("utf-8")
+                data_url = f"data:{content_type};base64,{base64_data}"
+                image_data_urls.append(data_url)
+                print(f"[STREAM UPLOAD] Processed image: {img_file.filename} ({len(content)} bytes)")
+        
+        rag_chunks = retrieve_relevant_context(message, top_k=3)
+        rag_context = format_rag_context(rag_chunks)
+        
+        print(f"[STREAM UPLOAD] Starting streaming response for: {message[:50]}...")
+        
+        async def generate():
+            yield f"data: {json.dumps({'type': 'start', 'session_id': session_id})}\n\n"
+            
+            full_response = ""
+            async for chunk in generate_chat_response_streaming(
+                prompt=message,
+                max_length=512,
+                temperature=0.7,
+                rag_context=rag_context,
+                images=image_data_urls if image_data_urls else None
+            ):
+                full_response += chunk
+                yield f"data: {json.dumps({'type': 'chunk', 'content': chunk})}\n\n"
+            
+            yield f"data: {json.dumps({'type': 'end', 'full_response': full_response, 'session_id': session_id})}\n\n"
+            print(f"[STREAM UPLOAD] Streaming complete: {len(full_response)} chars")
+            print(f"[STREAM RESPONSE] {full_response}")
+        
+        return StreamingResponse(
+            generate(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            }
+        )
+

wardrobe.py

@@ -0,0 +1,113 @@
+import re
+from typing import List, Optional
+from models import WardrobeItem, ChatResponse
+from query_processing import get_color_matches
+from model_manager import generate_chat_response
+from conversation import get_conversation_context, enhance_message_with_context, update_context
+from rag import retrieve_relevant_context, format_rag_context
+
+def clean_wardrobe_response(text: str) -> str:
+    text = re.sub(r'\b(\w+)\s+\1\b', r'\1', text)
+    text = re.sub(r'\b(navy|grey|gray|black|white|brown|blue|red|green|beige|tan|charcoal|rolex|fossil|hermes|zara|nike)\s+\1\b', r'\1', text, flags=re.IGNORECASE)
+    
+    if "protein" in text.lower():
+        text = re.sub(r'[Pp]rotein\s*', '', text)
+    
+    lines = text.split('\n')
+    cleaned_lines = []
+    
+    for line in lines:
+        line = line.strip()
+        if not line or len(line) < 3:
+            continue
+        if "protein" in line.lower():
+            continue
+        cleaned_lines.append(line)
+    
+    result = '\n'.join(cleaned_lines).strip()
+    
+    if len(result) > 1000:
+        sentences = result.split('. ')
+        result = '. '.join(sentences[:8]) + '.'
+    
+    return result
+
+def format_wardrobe_for_prompt(wardrobe: List[WardrobeItem]) -> str:
+    wardrobe_by_category = {}
+    for item in wardrobe:
+        category = item.category.lower()
+        if category not in wardrobe_by_category:
+            wardrobe_by_category[category] = []
+        wardrobe_by_category[category].append(item)
+    
+    wardrobe_details = []
+    for idx, item in enumerate(wardrobe, 1):
+        parts = []
+        if item.brand:
+            parts.append(item.brand)
+        if item.color:
+            parts.append(item.color)
+        if item.name:
+            parts.append(item.name)
+        elif item.category:
+            parts.append(item.category)
+        
+        item_name = " ".join(parts) if parts else item.category
+        wardrobe_details.append(f'{idx}. {item_name} ({item.category}, {item.style})')
+    
+    categories_list = ", ".join(wardrobe_by_category.keys())
+    
+    return f"""Available items ({len(wardrobe)} total):
+{chr(10).join(wardrobe_details)}
+
+Categories: {categories_list}"""
+
+async def handle_wardrobe_chat(message: str, wardrobe: List[WardrobeItem], session_id: str, images: Optional[List[str]] = None) -> ChatResponse:
+    conv_context = get_conversation_context(session_id)
+    enhanced_message = enhance_message_with_context(message, conv_context["context"])
+    
+    wardrobe_context = format_wardrobe_for_prompt(wardrobe)
+    
+    wardrobe_by_category = {}
+    for item in wardrobe:
+        category = item.category.lower()
+        if category not in wardrobe_by_category:
+            wardrobe_by_category[category] = []
+        wardrobe_by_category[category].append(item)
+    
+    rag_chunks = retrieve_relevant_context(enhanced_message, top_k=3)
+    rag_context = format_rag_context(rag_chunks)
+    
+    occasion_keywords = ["defense", "project", "presentation", "meeting", "interview", "formal", "casual", "party", "wedding", "dinner", "date", "work", "office"]
+    occasion = next((word for word in occasion_keywords if word in enhanced_message.lower()), None)
+    
+    context_info = f"Available wardrobe categories: {', '.join(wardrobe_by_category.keys())}. "
+    if occasion:
+        context_info += f"Occasion: {occasion}. "
+    
+    system_override = "You are a friendly and helpful fashion stylist. Suggest complete outfits conversationally and warmly. Include accessories when available. Be natural and friendly in your responses."
+    
+    prompt = f"""{wardrobe_context}
+
+User request: {enhanced_message}
+
+Suggest a complete outfit using ONLY the items listed above. Reference items by their exact names as shown (e.g., if item is "zara black pants", say "zara black pants", not "black zara pants"). Include accessories (watches, bags, jewelry, belts, glasses) if available. Be friendly and conversational. Suggest: one top/shirt, one bottom (pants/shorts), shoes, and accessories. Explain briefly why it works."""
+    
+    if context_info.strip():
+        prompt += f"\n\nContext: {context_info.strip()}"
+    
+    response_text = generate_chat_response(prompt, max_length=512, temperature=0.8, rag_context=rag_context, system_override=system_override, images=images)
+    
+    response_text = clean_wardrobe_response(response_text)
+    
+    update_context(session_id, message, {
+        "response": response_text,
+        "wardrobe_count": len(wardrobe),
+        "categories": list(wardrobe_by_category.keys())
+    })
+    
+    return ChatResponse(
+        response=response_text,
+        session_id=session_id
+    )
+