Upload 8 files

src/config.py

@@ -0,0 +1,43 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    # API Keys
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    OLLAMA_BASE_URL = "http://localhost:11434/api/generate"
+    GRANITE_MODEL = "granite3.3:8b"
+    # Watson Configuration
+    WATSON_API_KEY = "fPuHCEVgnNbPf5A2fSDXA9kDwppGdrUye7Fmq3DTe9vv"
+    WATSON_URL = "https://eu-de.ml.cloud.ibm.com"
+    WATSON_PROJECT_ID = "71f0101e-62d9-4532-bab8-d784ce8fb5c3"
+    
+    # AI Models - Updated to use Watson Granite model
+    GROQ_MODEL = "qwen/qwen3-32b"
+    GRANITE_MODEL = "ibm/granite-3-3-8b-instruct"
+    
+    # MongoDB Configuration
+    MONGODB_URI = "mongodb://localhost:27017/"
+    DATABASE_NAME = "wellness_platform"
+    
+    # Collections
+    USERS_COLLECTION = "users"
+    CONVERSATIONS_COLLECTION = "conversations"
+    TASKS_COLLECTION = "tasks"
+    REWARDS_COLLECTION = "rewards"
+    
+    # Task Reward Values
+    TASK_REWARDS = {
+        "meditation": 15,
+        "exercise": 20,
+        "sleep_schedule": 10,
+        "social_connection": 12,
+        "journaling": 8,
+        "breathing_exercise": 10,
+        "nature_walk": 15,
+        "healthy_meal": 12,
+        "screen_break": 5,
+        "gratitude_practice": 8,
+        "professional_help": 25
+    }

src/data_simulator.py

@@ -0,0 +1,123 @@
+import json
+import time
+import random
+import threading
+from datetime import datetime
+from typing import Dict, Optional
+import numpy as np
+
+class FitnessDataSimulator:
+    def __init__(self, config):
+        self.config = config
+        self.running = False
+        self.thread = None
+        
+        # Base patterns for realistic simulation
+        self.sleep_pattern = {"base": 7.5, "variance": 1.5}
+        self.steps_pattern = {"base": 8000, "variance": 3000}
+        self.mood_pattern = {"base": 7, "variance": 2}
+        self.calories_pattern = {"base": 400, "variance": 200}
+        self.water_pattern = {"base": 6, "variance": 2}
+        
+        # Daily progression
+        self.daily_progression = 0
+    
+    def generate_realistic_data(self) -> Dict:
+        """Generate realistic fitness data with daily patterns"""
+        hour = datetime.now().hour
+        
+        # Adjust patterns based on time of day
+        steps_multiplier = self._get_activity_multiplier(hour)
+        mood_adjustment = self._get_mood_adjustment(hour)
+        
+        data = {
+            "timestamp": datetime.now().isoformat(),
+            "sleep_hours": max(4, min(12, 
+                np.random.normal(self.sleep_pattern["base"], self.sleep_pattern["variance"])
+            )),
+            "steps": max(0, int(
+                np.random.normal(self.steps_pattern["base"] * steps_multiplier, self.steps_pattern["variance"])
+            )),
+            "mood_score": max(1, min(10, 
+                np.random.normal(self.mood_pattern["base"] + mood_adjustment, self.mood_pattern["variance"])
+            )),
+            "calories_burned": max(0, int(
+                np.random.normal(self.calories_pattern["base"] * steps_multiplier, self.calories_pattern["variance"])
+            )),
+            "water_intake": max(0, 
+                np.random.normal(self.water_pattern["base"], self.water_pattern["variance"])
+            ),
+            "heart_rate": random.randint(60, 100),
+            "active_minutes": random.randint(20, 120)
+        }
+        
+        return data
+    
+    def _get_activity_multiplier(self, hour: int) -> float:
+        """Get activity multiplier based on hour of day"""
+        if 6 <= hour <= 9:  # Morning
+            return 1.2
+        elif 12 <= hour <= 14:  # Lunch
+            return 1.1
+        elif 17 <= hour <= 19:  # Evening
+            return 1.3
+        elif 22 <= hour or hour <= 5:  # Night
+            return 0.3
+        else:
+            return 1.0
+    
+    def _get_mood_adjustment(self, hour: int) -> float:
+        """Get mood adjustment based on hour of day"""
+        if 7 <= hour <= 11:  # Morning
+            return 0.5
+        elif 14 <= hour <= 16:  # Afternoon dip
+            return -0.3
+        elif 18 <= hour <= 21:  # Evening
+            return 0.3
+        else:
+            return 0
+    
+    def save_data(self, data: Dict):
+        """Save data to JSON file"""
+        try:
+            with open(self.config.FIT_STREAM_FILE, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"Error saving data: {e}")
+    
+    def _simulate_loop(self):
+        """Main simulation loop"""
+        while self.running:
+            try:
+                data = self.generate_realistic_data()
+                self.save_data(data)
+                time.sleep(5)  # Update every 5 seconds
+            except Exception as e:
+                print(f"Simulation error: {e}")
+                time.sleep(5)
+    
+    def start_simulation(self):
+        """Start the data simulation"""
+        if not self.running:
+            self.running = True
+            self.thread = threading.Thread(target=self._simulate_loop, daemon=True)
+            self.thread.start()
+            print("✅ Fitness data simulation started")
+    
+    def stop_simulation(self):
+        """Stop the data simulation"""
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        print("🛑 Fitness data simulation stopped")
+    
+    def get_latest_data(self) -> Optional[Dict]:
+        """Get the latest fitness data"""
+        try:
+            with open(self.config.FIT_STREAM_FILE, 'r') as f:
+                return json.load(f)
+        except FileNotFoundError:
+            return None
+        except Exception as e:
+            print(f"Error reading data: {e}")
+            return None

src/database_manager.py

@@ -0,0 +1,130 @@
+import pymongo
+from datetime import datetime
+import json
+import uuid
+from typing import Dict, List, Optional
+
+class DatabaseManager:
+    def __init__(self, config):
+        self.config = config
+        self.client = pymongo.MongoClient(config.MONGODB_URI)
+        self.db = self.client[config.DATABASE_NAME]
+        self._init_collections()
+    
+    def _init_collections(self):
+        """Initialize collections with indexes"""
+        self.db[self.config.USERS_COLLECTION].create_index("user_id", unique=True)
+        self.db[self.config.CONVERSATIONS_COLLECTION].create_index([("user_id", 1), ("timestamp", -1)])
+        self.db[self.config.TASKS_COLLECTION].create_index([("user_id", 1), ("created_at", -1)])
+        self.db[self.config.REWARDS_COLLECTION].create_index([("user_id", 1), ("timestamp", -1)])
+    
+    def save_user_profile(self, user_data: Dict) -> bool:
+        """Save or update user profile"""
+        try:
+            user_data["last_updated"] = datetime.now()
+            if "coins" not in user_data:
+                user_data["coins"] = 0
+            if "total_coins_earned" not in user_data:
+                user_data["total_coins_earned"] = 0
+                
+            result = self.db[self.config.USERS_COLLECTION].update_one(
+                {"user_id": user_data["user_id"]},
+                {"$set": user_data},
+                upsert=True
+            )
+            return True
+        except Exception as e:
+            print(f"Error saving user profile: {e}")
+            return False
+    
+    def get_user_profile(self, user_id: str) -> Optional[Dict]:
+        """Get user profile"""
+        return self.db[self.config.USERS_COLLECTION].find_one({"user_id": user_id})
+    
+    def save_conversation(self, user_id: str, conversation_data: Dict) -> bool:
+        """Save conversation data"""
+        try:
+            conversation_data.update({
+                "user_id": user_id,
+                "timestamp": datetime.now(),
+                "conversation_id": str(uuid.uuid4())
+            })
+            self.db[self.config.CONVERSATIONS_COLLECTION].insert_one(conversation_data)
+            return True
+        except Exception as e:
+            print(f"Error saving conversation: {e}")
+            return False
+    
+    def save_task(self, user_id: str, task_data: Dict) -> str:
+        """Save assigned task and return task ID"""
+        try:
+            task_id = str(uuid.uuid4())
+            task_data.update({
+                "user_id": user_id,
+                "task_id": task_id,
+                "created_at": datetime.now(),
+                "status": "pending",
+                "completed_at": None
+            })
+            self.db[self.config.TASKS_COLLECTION].insert_one(task_data)
+            return task_id
+        except Exception as e:
+            print(f"Error saving task: {e}")
+            return None
+    
+    def get_user_tasks(self, user_id: str, status: str = None) -> List[Dict]:
+        """Get user tasks, optionally filtered by status"""
+        query = {"user_id": user_id}
+        if status:
+            query["status"] = status
+        
+        cursor = self.db[self.config.TASKS_COLLECTION].find(query).sort("created_at", -1)
+        return list(cursor)
+    
+    def complete_task(self, task_id: str, completion_data: Dict = None) -> bool:
+        """Mark task as completed"""
+        try:
+            update_data = {
+                "status": "completed",
+                "completed_at": datetime.now()
+            }
+            if completion_data:
+                update_data["completion_data"] = completion_data
+                
+            result = self.db[self.config.TASKS_COLLECTION].update_one(
+                {"task_id": task_id},
+                {"$set": update_data}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            print(f"Error completing task: {e}")
+            return False
+    
+    def update_user_coins(self, user_id: str, coins_to_add: int, reward_type: str) -> bool:
+        """Update user coins and log reward"""
+        try:
+            # Update user coins
+            user_result = self.db[self.config.USERS_COLLECTION].update_one(
+                {"user_id": user_id},
+                {
+                    "$inc": {
+                        "coins": coins_to_add,
+                        "total_coins_earned": coins_to_add
+                    }
+                }
+            )
+            
+            if user_result.modified_count > 0:
+                # Log reward
+                reward_data = {
+                    "user_id": user_id,
+                    "reward_type": reward_type,
+                    "coins": coins_to_add,
+                    "timestamp": datetime.now()
+                }
+                self.db[self.config.REWARDS_COLLECTION].insert_one(reward_data)
+                return True
+            return False
+        except Exception as e:
+            print(f"Error updating coins: {e}")
+            return False

src/granite_agent.py

@@ -0,0 +1,535 @@
+import requests
+import json
+import time
+from typing import Dict, List, Optional, Tuple
+
+class GraniteAgent:
+    def __init__(self, config):
+        self.config = config
+        self.base_url = config.OLLAMA_BASE_URL
+        self.model = config.GRANITE_MODEL
+        self.max_retries = 3
+        self.retry_delay = 2  # seconds
+        
+    def assign_wellness_tasks(self, user_profile: Dict, mental_health_assessment: str, risk_level: int) -> List[Dict]:
+        """Assign wellness tasks based on mental health assessment using Granite AI"""
+        
+        # First attempt: Comprehensive AI generation
+        tasks = self._generate_ai_tasks(user_profile, mental_health_assessment, risk_level)
+        
+        if tasks:
+            return tasks
+            
+        # Second attempt: Simplified AI generation with retry
+        tasks = self._generate_simplified_tasks(user_profile, risk_level)
+        
+        if tasks:
+            return tasks
+            
+        # Final fallback: Basic AI generation with minimal context
+        tasks = self._generate_basic_tasks(risk_level)
+        
+        if tasks:
+            return tasks
+            
+        # Emergency fallback: Only if AI is completely unavailable
+        print("WARNING: Granite AI completely unavailable, using emergency preset tasks")
+        return self._get_emergency_preset_tasks(risk_level)
+    
+    def _generate_ai_tasks(self, user_profile: Dict, mental_health_assessment: str, risk_level: int) -> Optional[List[Dict]]:
+        """Primary method: Generate comprehensive personalized tasks using Granite AI"""
+        
+        prompt = self._build_comprehensive_prompt(user_profile, mental_health_assessment, risk_level)
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.5)
+                
+                if response:
+                    tasks = self._extract_and_validate_tasks(response, risk_level)
+                    if tasks and len(tasks) >= 3:  # Ensure we have enough tasks
+                        print(f"✓ Generated {len(tasks)} comprehensive AI tasks")
+                        return tasks
+                        
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for comprehensive generation: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        
+        return None
+    
+    def _generate_simplified_tasks(self, user_profile: Dict, risk_level: int) -> Optional[List[Dict]]:
+        """Fallback method: Generate simplified tasks with reduced context"""
+        
+        prompt = self._build_simplified_prompt(user_profile, risk_level)
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.4)
+                
+                if response:
+                    tasks = self._extract_and_validate_tasks(response, risk_level)
+                    if tasks and len(tasks) >= 2:
+                        print(f"✓ Generated {len(tasks)} simplified AI tasks")
+                        return tasks
+                        
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for simplified generation: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        
+        return None
+    
+    def _generate_basic_tasks(self, risk_level: int) -> Optional[List[Dict]]:
+        """Secondary fallback: Generate basic tasks with minimal context"""
+        
+        prompt = self._build_basic_prompt(risk_level)
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.3)
+                
+                if response:
+                    tasks = self._extract_and_validate_tasks(response, risk_level, min_tasks=1)
+                    if tasks:
+                        print(f"✓ Generated {len(tasks)} basic AI tasks")
+                        return tasks
+                        
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for basic generation: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        
+        return None
+    
+    def _build_comprehensive_prompt(self, user_profile: Dict, mental_health_assessment: str, risk_level: int) -> str:
+        """Build detailed prompt for comprehensive task generation"""
+        
+        return f"""
+You are a professional wellness coach. Create personalized wellness tasks based on user data.
+
+GUIDELINES:
+- Use professional, clear language
+- Focus on evidence-based wellness practices
+- Ensure all recommendations are safe and appropriate
+- Use inclusive, respectful language
+
+USER CONTEXT:
+Risk Level: {risk_level}/10 (10 = highest risk)
+Assessment: {mental_health_assessment}
+
+USER PROFILE:
+- Stress Level: {user_profile.get('Stress_Level', 'Not specified')}
+- Sleep: {user_profile.get('Sleep_Hours', 'Not specified')} hours/night, quality: {user_profile.get('Sleep_Quality', 'Not specified')}
+- Work: {user_profile.get('Work_Hours', 'Not specified')} hours/week
+- Exercise: {user_profile.get('Physical_Activity_Hours', 'Not specified')} hours/week
+- Occupation: {user_profile.get('Occupation', 'Not specified')}
+- Age: {user_profile.get('Age', 'Not specified')}
+- Mood: {user_profile.get('Mood', 'Not specified')}
+- Anxiety: {user_profile.get('Anxiety_Frequency', 'Not specified')}
+- Energy: {user_profile.get('Energy_Level', 'Not specified')}
+
+TASK REQUIREMENTS:
+{self._get_risk_specific_requirements(risk_level)}
+
+Generate 4-6 personalized wellness tasks. Each task must be:
+1. Relevant to their specific situation
+2. Practical and achievable
+3. Evidence-based for mental health improvement
+4. Appropriate for their risk level
+5. Include clear, actionable instructions
+
+MANDATORY JSON FORMAT (return ONLY valid JSON):
+[
+    {{
+        "task_type": "select from: meditation, exercise, sleep_schedule, social_connection, journaling, breathing_exercise, nature_walk, healthy_meal, screen_break, gratitude_practice, professional_help, mindfulness, stress_management, routine_building, creative_activity, relaxation_technique",
+        "title": "Clear, engaging title",
+        "description": "Brief description explaining the benefits",
+        "duration_days": appropriate_number,
+        "difficulty": "easy/medium/hard",
+        "instructions": "Step-by-step instructions tailored to their profile",
+        "completion_criteria": "Clear, measurable success criteria",
+        "personalization_notes": "Why this task fits their specific situation"
+    }}
+]
+"""
+    
+    def _build_simplified_prompt(self, user_profile: Dict, risk_level: int) -> str:
+        """Build simplified prompt when comprehensive generation fails"""
+        
+        key_factors = []
+        if user_profile.get('Stress_Level'):
+            key_factors.append(f"Stress: {user_profile['Stress_Level']}")
+        if user_profile.get('Sleep_Hours'):
+            key_factors.append(f"Sleep: {user_profile['Sleep_Hours']}h")
+        if user_profile.get('Work_Hours'):
+            key_factors.append(f"Work: {user_profile['Work_Hours']}h/week")
+        
+        factors_str = ", ".join(key_factors) if key_factors else "Limited profile data"
+        
+        return f"""
+You are a wellness coach. Create practical wellness tasks.
+
+USER: {factors_str}
+Risk Level: {risk_level}/10
+
+{self._get_risk_specific_requirements(risk_level)}
+
+Generate 3-4 practical wellness tasks as JSON array:
+[
+    {{
+        "task_type": "meditation|exercise|sleep_schedule|journaling|breathing_exercise|professional_help|stress_management",
+        "title": "Clear task title",
+        "description": "Brief helpful description",
+        "duration_days": number,
+        "difficulty": "easy|medium|hard",
+        "instructions": "Step-by-step instructions",
+        "completion_criteria": "How to measure success"
+    }}
+]
+"""
+    
+    def _build_basic_prompt(self, risk_level: int) -> str:
+        """Build minimal prompt for basic task generation"""
+        
+        return f"""
+You are a wellness coach. Generate wellness tasks for risk level {risk_level}/10.
+
+{self._get_risk_specific_requirements(risk_level)}
+
+Return 2-3 tasks as JSON:
+[
+    {{
+        "task_type": "breathing_exercise|meditation|professional_help|journaling",
+        "title": "Task title",
+        "description": "What this helps with",
+        "duration_days": 1-7,
+        "difficulty": "easy|medium",
+        "instructions": "Clear instructions",
+        "completion_criteria": "Success measure"
+    }}
+]
+"""
+    
+    def _get_risk_specific_requirements(self, risk_level: int) -> str:
+        """Get specific requirements based on risk level"""
+        
+        if risk_level >= 8:
+            return """
+CRITICAL PRIORITY:
+- MUST include immediate professional help seeking
+- Focus on crisis intervention and safety
+- Include emergency resources and contacts
+- Tasks should provide immediate coping mechanisms
+- Maximum task duration: 1-2 days
+"""
+        elif risk_level >= 6:
+            return """
+HIGH PRIORITY:
+- Strongly recommend professional consultation within 1 week
+- Include daily anxiety/stress management techniques
+- Focus on stabilization and routine building
+- Provide structured, manageable activities
+- Task duration: 2-7 days
+"""
+        elif risk_level >= 4:
+            return """
+MODERATE PRIORITY:
+- Include both self-care and gradual improvement activities
+- Balance mental and physical wellness approaches
+- Encourage social connection and support
+- Build sustainable, healthy habits
+- Task duration: 5-14 days
+"""
+        else:
+            return """
+MAINTENANCE/PREVENTION:
+- Focus on wellness enhancement and prevention
+- Include enjoyable, engaging activities
+- Support long-term habit building
+- Promote overall life satisfaction
+- Task duration: 7-21 days
+"""
+    
+    def _extract_and_validate_tasks(self, response: str, risk_level: int, min_tasks: int = 2) -> Optional[List[Dict]]:
+        """Extract and validate tasks from AI response"""
+        
+        try:
+            # Clean the response
+            cleaned_response = self._clean_json_string(response)
+            if not cleaned_response:
+                return None
+            
+            # Try to parse JSON
+            try:
+                tasks = json.loads(cleaned_response)
+            except json.JSONDecodeError:
+                # Try to extract individual task objects
+                tasks = self._extract_individual_tasks(response)
+                if not tasks:
+                    return None
+            
+            # Validate task structure
+            validated_tasks = self._validate_task_structure(tasks, risk_level)
+            
+            if validated_tasks and len(validated_tasks) >= min_tasks:
+                return validated_tasks
+            
+        except Exception as e:
+            print(f"Error extracting tasks: {e}")
+        
+        return None
+    
+    def _clean_json_string(self, json_str: str) -> Optional[str]:
+        """Clean malformed JSON string"""
+        try:
+            # Remove common issues
+            cleaned = json_str.strip()
+            
+            # Find JSON array boundaries
+            start_idx = cleaned.find('[')
+            end_idx = cleaned.rfind(']')
+            
+            if start_idx == -1 or end_idx == -1:
+                return None
+            
+            cleaned = cleaned[start_idx:end_idx + 1]
+            
+            # Remove newlines and extra whitespace
+            cleaned = cleaned.replace('\n', ' ').replace('\r', '')
+            cleaned = ' '.join(cleaned.split())
+            
+            # Fix common JSON issues
+            cleaned = cleaned.replace(',}', '}')  # Remove trailing commas
+            cleaned = cleaned.replace(',]', ']')
+            
+            return cleaned
+            
+        except Exception:
+            return None
+    
+    def _extract_individual_tasks(self, response: str) -> Optional[List[Dict]]:
+        """Extract individual task objects when array parsing fails"""
+        tasks = []
+        
+        # Find individual task objects
+        import re
+        task_pattern = r'\{[^{}]*"task_type"[^{}]*\}'
+        matches = re.findall(task_pattern, response, re.DOTALL)
+        
+        for match in matches:
+            try:
+                # Clean the match
+                clean_match = match.replace('\n', ' ').replace('\r', '')
+                clean_match = ' '.join(clean_match.split())
+                clean_match = clean_match.replace(',}', '}')
+                
+                task = json.loads(clean_match)
+                tasks.append(task)
+            except:
+                continue
+                
+        return tasks if tasks else None
+    
+    def _validate_task_structure(self, tasks: List[Dict], risk_level: int) -> Optional[List[Dict]]:
+        """Validate and sanitize task structure"""
+        
+        if not isinstance(tasks, list):
+            return None
+            
+        valid_tasks = []
+        required_fields = ['task_type', 'title', 'description', 'duration_days', 'difficulty', 'instructions', 'completion_criteria']
+        
+        valid_task_types = {
+            'meditation', 'exercise', 'sleep_schedule', 'social_connection', 
+            'journaling', 'breathing_exercise', 'nature_walk', 'healthy_meal', 
+            'screen_break', 'gratitude_practice', 'professional_help', 
+            'mindfulness', 'stress_management', 'routine_building', 
+            'creative_activity', 'relaxation_technique'
+        }
+        
+        # Ensure high-risk users get professional help
+        has_professional_help = False
+        
+        for task in tasks:
+            if not isinstance(task, dict):
+                continue
+                
+            # Check required fields
+            if not all(field in task and str(task[field]).strip() for field in required_fields):
+                continue
+                
+            # Validate and clean task
+            validated_task = self._clean_and_validate_task(task, valid_task_types)
+            if validated_task:
+                valid_tasks.append(validated_task)
+                
+                if validated_task['task_type'] == 'professional_help':
+                    has_professional_help = True
+        
+        # Ensure high-risk users have professional help task
+        if risk_level >= 7 and not has_professional_help and len(valid_tasks) > 0:
+            professional_task = self._generate_professional_help_task(risk_level)
+            valid_tasks.insert(0, professional_task)
+        
+        return valid_tasks if len(valid_tasks) >= 1 else None
+    
+    def _clean_and_validate_task(self, task: Dict, valid_task_types: set) -> Optional[Dict]:
+        """Clean and validate individual task"""
+        
+        try:
+            # Validate task_type
+            if task.get('task_type') not in valid_task_types:
+                return None
+                
+            # Clean and validate duration
+            try:
+                duration = int(task.get('duration_days', 7))
+                duration = max(1, min(30, duration))  # Clamp between 1-30 days
+            except (ValueError, TypeError):
+                duration = 7
+                
+            # Validate difficulty
+            difficulty = task.get('difficulty', 'medium').lower()
+            if difficulty not in ['easy', 'medium', 'hard']:
+                difficulty = 'medium'
+                
+            # Clean text fields
+            cleaned_task = {
+                'task_type': task['task_type'],
+                'title': str(task['title']).strip()[:100],
+                'description': str(task['description']).strip()[:300],
+                'duration_days': duration,
+                'difficulty': difficulty,
+                'instructions': str(task['instructions']).strip()[:1000],
+                'completion_criteria': str(task['completion_criteria']).strip()[:200]
+            }
+            
+            # Add optional fields if present
+            if 'personalization_notes' in task:
+                cleaned_task['personalization_notes'] = str(task['personalization_notes']).strip()[:200]
+                
+            return cleaned_task
+            
+        except Exception as e:
+            print(f"Error cleaning task: {e}")
+            return None
+    
+    def _generate_professional_help_task(self, risk_level: int) -> Dict:
+        """Generate professional help task for high-risk users"""
+        
+        urgency = "immediately" if risk_level >= 8 else "within 1-2 days"
+        
+        return {
+            "task_type": "professional_help",
+            "title": "Seek Professional Mental Health Support",
+            "description": f"Contact a mental health professional {urgency} for assessment and support",
+            "duration_days": 2,
+            "difficulty": "medium",
+            "instructions": f"Contact your healthcare provider, call a mental health helpline, or visit a mental health clinic {urgency}. If in immediate crisis, call emergency services (911) or go to the nearest emergency room.",
+            "completion_criteria": "Make contact with a mental health professional or crisis support service"
+        }
+    
+    def _get_emergency_preset_tasks(self, risk_level: int) -> List[Dict]:
+        """ONLY used when Granite AI is completely unavailable - minimal preset tasks"""
+        
+        print("EMERGENCY: Using preset tasks - Granite AI unavailable")
+        
+        if risk_level >= 7:
+            return [
+                {
+                    "task_type": "professional_help",
+                    "title": "Emergency Professional Help",
+                    "description": "Seek immediate professional mental health support",
+                    "duration_days": 1,
+                    "difficulty": "medium",
+                    "instructions": "Contact emergency mental health services, your doctor, or call a crisis helpline immediately.",
+                    "completion_criteria": "Make contact with professional help"
+                }
+            ]
+        elif risk_level >= 4:
+            return [
+                {
+                    "task_type": "breathing_exercise",
+                    "title": "Daily Breathing Practice",
+                    "description": "Use breathing exercises to manage stress and anxiety",
+                    "duration_days": 7,
+                    "difficulty": "easy",
+                    "instructions": "Practice 4-7-8 breathing: Inhale for 4 counts, hold for 7 counts, exhale for 8 counts. Repeat 4 times, twice daily.",
+                    "completion_criteria": "Complete breathing exercise twice daily for one week"
+                },
+                {
+                    "task_type": "sleep_schedule",
+                    "title": "Improve Sleep Routine",
+                    "description": "Establish a consistent sleep schedule for better rest",
+                    "duration_days": 14,
+                    "difficulty": "medium",
+                    "instructions": "Go to bed and wake up at the same time daily. Create a 30-minute wind-down routine before bed.",
+                    "completion_criteria": "Maintain consistent sleep schedule for 2 weeks"
+                }
+            ]
+        else:
+            return [
+                {
+                    "task_type": "gratitude_practice",
+                    "title": "Daily Gratitude Journal",
+                    "description": "Practice gratitude to boost mood and well-being",
+                    "duration_days": 14,
+                    "difficulty": "easy",
+                    "instructions": "Write down 3 things you're grateful for each morning. Be specific and reflect on why you appreciate them.",
+                    "completion_criteria": "Complete gratitude entries for 14 consecutive days"
+                },
+                {
+                    "task_type": "nature_walk",
+                    "title": "Weekly Nature Walks",
+                    "description": "Connect with nature to reduce stress and improve mood",
+                    "duration_days": 21,
+                    "difficulty": "easy",
+                    "instructions": "Take a 20-30 minute walk in a park, garden, or natural area twice per week. Focus on your surroundings.",
+                    "completion_criteria": "Complete 6 nature walks over 3 weeks"
+                }
+            ]
+    
+    def _call_granite_api(self, prompt: str, temperature: float = 0.3) -> Optional[str]:
+        """Enhanced API call with better error handling and logging"""
+        
+        data = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "top_p": 0.9,
+                "num_predict": 2000,  # Increased for better task generation
+                "repeat_penalty": 1.1,
+                "stop": ["Human:", "Assistant:", "\n\n---"]
+            }
+        }
+        
+        try:
+            print(f"🤖 Calling Granite API (temp={temperature})...")
+            response = requests.post(self.base_url, json=data, timeout=90)
+            
+            if response.status_code == 200:
+                result = response.json()
+                ai_response = result.get('response', '').strip()
+                
+                if ai_response:
+                    print(f"✓ Granite API responded ({len(ai_response)} chars)")
+                    return ai_response
+                else:
+                    print("⚠ Granite API returned empty response")
+                    return None
+            else:
+                print(f"❌ Granite API error: {response.status_code}")
+                return None
+                
+        except requests.exceptions.ConnectionError:
+            print("❌ Cannot connect to Granite (Ollama not running?)")
+            return None
+        except requests.exceptions.Timeout:
+            print("❌ Granite API timeout")
+            return None
+        except Exception as e:
+            print(f"❌ Granite API error: {e}")
+            return None

src/granite_chat.py

@@ -0,0 +1,390 @@
+import json
+import time
+import re
+from typing import Dict, List, Optional, Tuple, Any
+from ibm_watsonx_ai.foundation_models import Model
+from ibm_watsonx_ai.foundation_models.utils.enums import ModelTypes
+from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
+from langchain_ibm import WatsonxLLM
+
+class GraniteChatAgent:
+    def __init__(self, config):
+        self.config = config
+        self.max_retries = 3
+        self.retry_delay = 2
+        self.conversation_history = []
+        self.llm = WatsonxLLM(
+            model_id=config.GRANITE_MODEL,
+            url=config.WATSON_URL,
+            apikey=config.WATSON_API_KEY,
+            project_id=config.WATSON_PROJECT_ID,
+            params={
+                GenParams.DECODING_METHOD: "greedy",
+                GenParams.TEMPERATURE: 0.7,
+                GenParams.MIN_NEW_TOKENS: 20,
+                GenParams.MAX_NEW_TOKENS: 500,
+                GenParams.STOP_SEQUENCES: ["Human:", "User:", "\n\nHuman:", "\n\nUser:"],
+            },
+        )
+
+    def get_chat_response(self, user_message: str, user_profile: Optional[Dict] = None, context: Optional[str] = None) -> str:
+        self.conversation_history.append({"role": "user", "content": user_message})
+        response = self._generate_direct_response(user_message, user_profile, context)
+        if not response:
+            response = self._generate_fallback_response(user_message, user_profile)
+        if not response:
+            response = self._generate_basic_response(user_message)
+        if not response:
+            response = "I apologize, but I'm having trouble processing your request right now. Could you please rephrase your question or try again?"
+        self.conversation_history.append({"role": "assistant", "content": response})
+        if len(self.conversation_history) > 20:
+            self.conversation_history = self.conversation_history[-20:]
+        return response
+
+    def get_wellness_advice(self, topic: str, user_profile: Optional[Dict] = None) -> str:
+        advice_prompt = f"Please provide wellness advice about {topic}"
+        if user_profile:
+            advice_prompt += f" for someone with these characteristics: {self._format_user_profile(user_profile)}"
+        return self.get_chat_response(advice_prompt, user_profile)
+
+    def answer_question(self, question: str, user_profile: Optional[Dict] = None) -> str:
+        return self.get_chat_response(question, user_profile)
+
+    def provide_support(self, concern: str, user_profile: Optional[Dict] = None) -> str:
+        support_message = f"I'm concerned about {concern} and could use some support and guidance."
+        return self.get_chat_response(support_message, user_profile)
+
+    def _generate_direct_response(self, user_message: str, user_profile: Optional[Dict], context: Optional[str]) -> Optional[str]:
+        prompt = self._build_chat_prompt(user_message, user_profile, context)
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.7)
+                if response and len(response.strip()) > 10:
+                    cleaned_response = self._clean_chat_response(response)
+                    if cleaned_response:
+                        print(f"✓ Generated direct chat response ({len(cleaned_response)} chars)")
+                        return cleaned_response
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for direct response: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        return None
+
+    def _generate_fallback_response(self, user_message: str, user_profile: Optional[Dict]) -> Optional[str]:
+        prompt = self._build_simple_chat_prompt(user_message, user_profile)
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.6)
+                if response and len(response.strip()) > 5:
+                    cleaned_response = self._clean_chat_response(response)
+                    if cleaned_response:
+                        print(f"✓ Generated fallback chat response")
+                        return cleaned_response
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for fallback response: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        return None
+
+    def _generate_basic_response(self, user_message: str) -> Optional[str]:
+        prompt = self._build_basic_chat_prompt(user_message)
+        for attempt in range(self.max_retries):
+            try:
+                response = self._call_granite_api(prompt, temperature=0.5)
+                if response and len(response.strip()) > 3:
+                    cleaned_response = self._clean_chat_response(response)
+                    if cleaned_response:
+                        print(f"✓ Generated basic chat response")
+                        return cleaned_response
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed for basic response: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+        return None
+
+    def _build_chat_prompt(self, user_message: str, user_profile: Optional[Dict], context: Optional[str]) -> str:
+        conversation_context = self._build_conversation_context()
+        user_context = ""
+        if user_profile:
+            user_context = f"""
+USER CONTEXT:
+- Stress Level: {user_profile.get('Stress_Level', 'Unknown')}
+- Sleep: {user_profile.get('Sleep_Hours', 'Unknown')} hours/night
+- Work: {user_profile.get('Work_Hours', 'Unknown')} hours/week
+- Mood: {user_profile.get('Mood', 'Unknown')}
+- Age: {user_profile.get('Age', 'Unknown')}
+- Occupation: {user_profile.get('Occupation', 'Unknown')}
+"""
+        additional_context = f"\nADDITIONAL CONTEXT:\n{context}\n" if context else ""
+        return f"""You are a helpful, empathetic, and knowledgeable AI assistant specializing in wellness and mental health support. Respond directly in first person as if you are speaking to the user face-to-face.
+
+IMPORTANT: Start your response immediately with your direct answer. Do not think aloud, analyze, or explain your reasoning process. Give a direct, conversational response from the first word.
+
+Guidelines:
+1. SPEAK DIRECTLY: Use "I", "you", "your" - respond as if in conversation
+2. NO ANALYSIS: Don't show your thinking process or reasoning
+3. BE IMMEDIATE: Start with your actual response, not explanations
+4. STAY SUPPORTIVE: Be empathetic and helpful
+5. BE CONCISE: Give practical, actionable advice
+
+{user_context}{additional_context}
+
+CONVERSATION HISTORY:
+{conversation_context}
+
+USER MESSAGE: {user_message}
+
+Your direct response (start immediately, no analysis):"""
+
+    def _build_simple_chat_prompt(self, user_message: str, user_profile: Optional[Dict]) -> str:
+        user_info = ""
+        if user_profile:
+            key_info = []
+            if user_profile.get('Stress_Level'):
+                key_info.append(f"Stress: {user_profile['Stress_Level']}")
+            if user_profile.get('Mood'):
+                key_info.append(f"Mood: {user_profile['Mood']}")
+            if key_info:
+                user_info = f"User info: {', '.join(key_info)}\n"
+        recent_context = ""
+        if len(self.conversation_history) > 0:
+            recent_context = f"Previous message: {self.conversation_history[-1]['content'][:100]}...\n"
+        return f"""You are a helpful wellness AI assistant. Give a direct, first-person response. Start immediately with your answer - no thinking aloud or analysis.
+
+{user_info}{recent_context}
+User: {user_message}
+
+Direct response:"""
+
+    def _build_basic_chat_prompt(self, user_message: str) -> str:
+        return f"""You are a helpful AI assistant. Respond directly in first person. Start immediately with your response - no analysis or thinking aloud.
+
+User: {user_message}
+
+Direct response:"""
+
+    def _build_conversation_context(self) -> str:
+        if not self.conversation_history:
+            return "No previous conversation."
+        context_lines = []
+        recent_history = self.conversation_history[-6:]
+        for entry in recent_history:
+            role = "User" if entry["role"] == "user" else "Assistant"
+            content = entry["content"][:150] + "..." if len(entry["content"]) > 150 else entry["content"]
+            context_lines.append(f"{role}: {content}")
+        return "\n".join(context_lines)
+
+    def _format_user_profile(self, user_profile: Dict) -> str:
+        profile_parts = []
+        for key, value in user_profile.items():
+            if value and str(value).strip().lower() not in ['unknown', 'not specified', '']:
+                readable_key = key.replace('_', ' ').title()
+                profile_parts.append(f"{readable_key}: {value}")
+        return ", ".join(profile_parts) if profile_parts else "Limited profile information"
+
+    def _clean_chat_response(self, response: str) -> Optional[str]:
+        if not response:
+            return None
+        
+        cleaned = response.strip()
+        
+        # Remove common system/thinking indicators
+        system_indicators = [
+            "You are a helpful", "RESPONSE:", "Assistant:", "AI:", "Human:", "User:",
+            "Direct response:", "Your direct response:", "Based on", "Looking at",
+            "Let me", "I need to", "First,", "The user is", "From what", "Since",
+            "Given that", "Considering", "In this case", "It seems", "This appears"
+        ]
+        
+        # Remove thinking patterns - lines that start with analysis
+        thinking_patterns = [
+            r"^(Okay|So|Well|Now|Let me|I see|Looking at|Based on|From what|Given that|Since|Considering).*",
+            r"^The user (is|has|wants|needs|seems).*",
+            r"^This (is|seems|appears|looks|sounds).*",
+            r"^It (seems|appears|looks|sounds).*",
+            r"^They (are|have|want|need|seem).*"
+        ]
+        
+        lines = cleaned.split('\n')
+        cleaned_lines = []
+        skip_mode = True  # Start in skip mode to remove initial thinking
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Check if this line is thinking/analysis
+            is_thinking = False
+            
+            # Check system indicators
+            if any(line.startswith(indicator) for indicator in system_indicators):
+                is_thinking = True
+            
+            # Check thinking patterns
+            if any(re.match(pattern, line, re.IGNORECASE) for pattern in thinking_patterns):
+                is_thinking = True
+            
+            # Check for analysis keywords at start of line
+            analysis_starts = ['okay', 'so', 'well', 'now', 'let me', 'i see', 'looking', 'based on', 
+                             'from what', 'given that', 'since', 'considering', 'the user', 'this is',
+                             'it seems', 'they are', 'i think', 'i believe', 'i should', 'i need to']
+            
+            line_lower = line.lower()
+            if any(line_lower.startswith(start) for start in analysis_starts):
+                is_thinking = True
+            
+            # If we're in skip mode and this isn't thinking, switch to collect mode
+            if skip_mode and not is_thinking:
+                skip_mode = False
+            
+            # Collect non-thinking lines after we've found the first real response
+            if not skip_mode and not is_thinking:
+                cleaned_lines.append(line)
+        
+        # If no good lines found, try to salvage something
+        if not cleaned_lines:
+            # Look for lines that start with "I" or common first-person responses
+            for line in lines:
+                line = line.strip()
+                if line and (line.startswith('I ') or line.startswith('You ') or 
+                           line.startswith('Your ') or line.startswith('Based on your')):
+                    cleaned_lines.append(line)
+                    break
+        
+        # Join the cleaned lines
+        final_response = '\n'.join(cleaned_lines).strip()
+        
+        # Additional cleanup
+        if final_response.startswith('"') and final_response.endswith('"'):
+            final_response = final_response[1:-1].strip()
+        
+        # Ensure minimum length
+        if len(final_response) < 10:
+            return None
+        
+        # Limit length
+        if len(final_response) > 1000:
+            final_response = final_response[:1000] + "..."
+        
+        return final_response if final_response else None
+
+    def _call_granite_api(self, prompt: str, temperature: float = 0.7) -> Optional[str]:
+        try:
+            print(f"🤖 Calling Watson Granite API (temp={temperature})...")
+            self.llm.params[GenParams.TEMPERATURE] = temperature
+            response = self.llm.invoke(prompt)
+            if response and response.strip():
+                print(f"✓ Watson Granite API responded ({len(response)} chars)")
+                return response.strip()
+            else:
+                print("⚠ Watson Granite API returned empty response")
+                return None
+        except Exception as e:
+            print(f"❌ Watson Granite API error: {e}")
+            return None
+
+    def clear_conversation_history(self):
+        self.conversation_history = []
+        print("✓ Conversation history cleared")
+
+    def get_conversation_summary(self) -> str:
+        if not self.conversation_history:
+            return "No conversation history available."
+        total_messages = len(self.conversation_history)
+        user_messages = len([msg for msg in self.conversation_history if msg["role"] == "user"])
+        assistant_messages = len([msg for msg in self.conversation_history if msg["role"] == "assistant"])
+        recent_topics = []
+        for msg in self.conversation_history[-4:]:
+            if msg["role"] == "user":
+                content = msg["content"][:100]
+                recent_topics.append(content)
+        summary = f"""Conversation Summary:
+- Total messages: {total_messages}
+- User messages: {user_messages}
+- Assistant messages: {assistant_messages}
+- Recent topics discussed: {'; '.join(recent_topics) if recent_topics else 'General conversation'}"""
+        return summary.strip()
+
+    def set_chat_personality(self, personality_type: str = "supportive"):
+        personality_configs = {
+            "supportive": {
+                "temperature": 0.7,
+                "max_tokens": 500,
+                "style": "empathetic and encouraging"
+            },
+            "professional": {
+                "temperature": 0.5,
+                "max_tokens": 400,
+                "style": "clinical and informative"
+            },
+            "casual": {
+                "temperature": 0.8,
+                "max_tokens": 300,
+                "style": "friendly and conversational"
+            },
+            "direct": {
+                "temperature": 0.4,
+                "max_tokens": 250,
+                "style": "concise and straightforward"
+            }
+        }
+        if personality_type in personality_configs:
+            config = personality_configs[personality_type]
+            self.llm.params[GenParams.TEMPERATURE] = config["temperature"]
+            self.llm.params[GenParams.MAX_NEW_TOKENS] = config["max_tokens"]
+            print(f"✓ Chat personality set to: {personality_type} ({config['style']})")
+        else:
+            print(f"⚠ Unknown personality type: {personality_type}. Available: {list(personality_configs.keys())}")
+
+class ChatIntegration:
+    def __init__(self, granite_agent: GraniteChatAgent):
+        self.agent = granite_agent
+
+    async def handle_chat_message(self, message: str, user_id: str, user_profile: Optional[Dict] = None) -> Dict:
+        try:
+            response = self.agent.get_chat_response(message, user_profile)
+            return {
+                "success": True,
+                "response": response,
+                "user_id": user_id,
+                "timestamp": time.time(),
+                "response_type": "direct_answer",
+                "confidence": "high" if len(response) > 50 else "medium"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "response": "I apologize, but I'm having technical difficulties. Please try again.",
+                "user_id": user_id,
+                "timestamp": time.time(),
+                "response_type": "error"
+            }
+
+    def get_quick_responses(self, user_message: str) -> List[str]:
+        message_lower = user_message.lower()
+        if any(word in message_lower for word in ['stressed', 'anxiety', 'worried']):
+            return [
+                "Tell me more about what's causing your stress",
+                "Would you like some immediate stress relief techniques?",
+                "How long have you been feeling this way?"
+            ]
+        elif any(word in message_lower for word in ['sleep', 'tired', 'insomnia']):
+            return [
+                "What's your current sleep schedule like?",
+                "Would you like tips for better sleep hygiene?",
+                "How many hours of sleep do you typically get?"
+            ]
+        elif any(word in message_lower for word in ['sad', 'depressed', 'down']):
+            return [
+                "I'm here to support you through this",
+                "Would you like to talk about what's making you feel this way?",
+                "Have you considered speaking with a counselor?"
+            ]
+        else:
+            return [
+                "Can you tell me more about that?",
+                "How can I best support you with this?",
+                "What would be most helpful for you right now?"
+            ]

src/groq_agent.py

@@ -0,0 +1,458 @@
+from groq import Groq
+import json
+import os
+import re
+from typing import Dict, Optional, Tuple
+
+class GroqAgent:
+    def __init__(self, config):
+        self.config = config
+        # Set API key as environment variable for Groq client
+        os.environ['GROQ_API_KEY'] = config.GROQ_API_KEY
+        self.client = Groq()
+        self.model = "qwen/qwen3-32b"
+        
+    def analyze_mental_health(self, user_profile: Dict) -> Tuple[str, int]:
+        """Analyze user's mental health status and return short bullet assessment with risk level"""
+        
+        # Calculate dynamic risk level based on profile factors
+        risk_level = self._calculate_dynamic_risk_level(user_profile)
+        
+        prompt = f"""
+Analyze this user profile and provide ONLY bullet-point assessment. Start immediately with bullet points.
+
+USER PROFILE:
+- Age: {user_profile.get('Age', 'N/A')}
+- Occupation: {user_profile.get('Occupation', 'N/A')}
+- Stress Level: {user_profile.get('Stress_Level', 'N/A')}
+- Sleep: {user_profile.get('Sleep_Hours', 'N/A')} hours, quality: {user_profile.get('Sleep_Quality', 'N/A')}
+- Work: {user_profile.get('Work_Hours', 'N/A')} hours/week
+- Exercise: {user_profile.get('Physical_Activity_Hours', 'N/A')} hours/week
+- Mood: {user_profile.get('Mood', 'N/A')}
+- Anxiety: {user_profile.get('Anxiety_Frequency', 'N/A')}
+- Energy: {user_profile.get('Energy_Level', 'N/A')}
+
+Give exactly 4 bullet points:
+
+• [Key strength/positive factor]
+• [Main concern/area needing attention]
+• [Specific recommendation]
+• [Overall wellness status]
+"""
+
+        response = self._call_groq_api(prompt, temperature=0.3)
+        
+        if response:
+            # Clean and format the response
+            assessment = self._format_bullet_response(response)
+            return assessment, risk_level
+        
+        return "• Unable to complete assessment at this time\n• Please try again later", 5
+    
+    def get_health_tips(self, user_profile: Dict, user_question: str = None) -> str:
+        """Generate short, practical health tips in bullet format"""
+        
+        if user_question:
+            prompt = f"""
+Answer this health question with SHORT, practical advice for this user:
+
+QUESTION: {user_question}
+
+USER: {user_profile.get('Age')}yo, {user_profile.get('Occupation')}, {user_profile.get('Stress_Level')} stress, {user_profile.get('Sleep_Hours')}h sleep, {user_profile.get('Physical_Activity_Hours')}h exercise/week
+
+Give exactly 4 bullet points with direct actionable advice:
+
+• [Direct tip 1]
+• [Direct tip 2] 
+• [Direct tip 3]
+• [Direct tip 4]
+"""
+        else:
+            prompt = f"""
+Create 4 wellness tips for this user:
+
+USER: {user_profile.get('Age')}yo, {user_profile.get('Occupation')}, stress: {user_profile.get('Stress_Level')}, sleep: {user_profile.get('Sleep_Hours')}h, exercise: {user_profile.get('Physical_Activity_Hours')}h/week
+
+Give exactly 4 bullet points:
+
+• [tip 1]
+• [tip 2] 
+• [tip 3]
+• [tip 4]
+"""
+        
+        response = self._call_groq_api(prompt, temperature=0.5)
+        if response:
+            return self._format_bullet_response(response)
+        return "• Stay hydrated throughout the day\n• Take short breaks every hour\n• Practice deep breathing exercises\n• Get 7-8 hours of sleep"
+    
+    def get_chat_response(self, user_profile, question):
+        """Get a natural, conversational response to user questions"""
+        
+        if not user_profile:
+            return "I need more information about you to provide personalized advice. Could you share some details about your lifestyle?"
+        
+        if not question or len(question) < 5:
+            return "Could you please ask a more specific question so I can help you better?"
+            
+        try:
+            # Build basic user context for personalization
+            user_context = f"User is {user_profile.get('Age', 'unknown')} years old"
+            if user_profile.get('Stress_Level'):
+                user_context += f", stress level: {user_profile.get('Stress_Level')}"
+            if user_profile.get('Sleep_Hours'):
+                user_context += f", sleeps {user_profile.get('Sleep_Hours')} hours"
+            if user_profile.get('Physical_Activity_Hours'):
+                user_context += f", exercises {user_profile.get('Physical_Activity_Hours')} hours/week"
+            if user_profile.get('Diet'):
+                user_context += f", diet quality: {user_profile.get('Diet')}"
+            if user_profile.get('Mood'):
+                user_context += f", mood: {user_profile.get('Mood')}"
+            if user_profile.get('Anxiety_Frequency'):
+                user_context += f", anxiety frequency: {user_profile.get('Anxiety_Frequency')}"
+            if user_profile.get('Energy_Level'):
+                user_context += f", energy level: {user_profile.get('Energy_Level')}"
+            if user_profile.get('Occupation'):
+                user_context += f", occupation: {user_profile.get('Occupation')}"
+        except Exception as e:
+            print(f"Error building user context: {e}")
+            user_context = "User profile information is incomplete"
+        
+        # Enhanced conversation prompt for direct responses
+        response = self.client.chat.completions.create(
+            model="qwen/qwen3-32b",
+            messages=[
+                {
+                    "role": "system",
+                    "content": f"""You are a friendly AI health coach. Respond directly and conversationally from the first word - no analysis, no thinking aloud.
+
+User context: {user_context}
+
+IMPORTANT: Start immediately with your direct response. Use "I", "you", "your" naturally. Give practical advice in 2-3 sentences. Be supportive and encouraging."""
+                },
+                {
+                    "role": "user", 
+                    "content": question
+                }
+            ],
+            max_tokens=150,
+            temperature=0.7
+        )
+        
+        # Clean the response to remove any thinking patterns
+        raw_response = response.choices[0].message.content.strip()
+        cleaned_response = self._clean_chat_response(raw_response)
+        
+        return cleaned_response if cleaned_response else raw_response
+    
+    def _clean_chat_response(self, response: str) -> Optional[str]:
+        """Clean response to remove thinking patterns and ensure direct answers"""
+        if not response:
+            return None
+        
+        # Split into lines for analysis
+        lines = response.split('\n')
+        cleaned_lines = []
+        skip_mode = True  # Start in skip mode to remove initial thinking
+        
+        # Patterns that indicate thinking/analysis rather than direct response
+        thinking_patterns = [
+            r"^(Let me|Looking at|Based on|Given that|Considering|The user|This user|From what).*",
+            r"^(I see|I notice|I understand|It seems|It appears|This seems).*",
+            r"^(Analyzing|Analysis|Assessment|Evaluation).*",
+            r"^(First|Firstly|To start|Initially).*",
+            r"^(So|Well|Now|Okay).*"
+        ]
+        
+        # Words that indicate analysis vs direct response
+        analysis_starters = [
+            'analyzing', 'looking at', 'based on', 'given that', 'considering',
+            'the user', 'this user', 'from what', 'let me', 'i see', 'i notice',
+            'it seems', 'it appears', 'this seems', 'first', 'firstly', 'so',
+            'well', 'now', 'okay', 'assessment shows', 'profile indicates'
+        ]
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check if this line is thinking/analysis
+            is_thinking = False
+            line_lower = line.lower()
+            
+            # Check against thinking patterns
+            if any(re.match(pattern, line, re.IGNORECASE) for pattern in thinking_patterns):
+                is_thinking = True
+            
+            # Check against analysis starters
+            if any(line_lower.startswith(starter) for starter in analysis_starters):
+                is_thinking = True
+            
+            # If we're in skip mode and this isn't thinking, switch to collect mode
+            if skip_mode and not is_thinking:
+                # Look for lines that start with direct conversational responses
+                if (line_lower.startswith('i ') or line_lower.startswith('you ') or 
+                    line_lower.startswith('your ') or line_lower.startswith('based on your') or
+                    any(line_lower.startswith(start) for start in ['great', 'good', 'excellent', 'wonderful', 'that\'s', 'this is', 'absolutely'])):
+                    skip_mode = False
+            
+            # Collect non-thinking lines after we've found the first real response
+            if not skip_mode and not is_thinking:
+                cleaned_lines.append(line)
+        
+        # If no good lines found, try to find the first conversational line
+        if not cleaned_lines:
+            for line in lines:
+                line = line.strip()
+                if line and len(line) > 10:
+                    line_lower = line.lower()
+                    # Look for direct responses
+                    if (line_lower.startswith('i ') or line_lower.startswith('you ') or 
+                        line_lower.startswith('your ') or line_lower.startswith('that\'s ') or
+                        line_lower.startswith('this is ') or line_lower.startswith('great ') or
+                        line_lower.startswith('good ') or line_lower.startswith('excellent ')):
+                        cleaned_lines.append(line)
+                        break
+        
+        # Join the cleaned lines
+        final_response = '\n'.join(cleaned_lines).strip()
+        
+        # Remove quotes if present
+        if final_response.startswith('"') and final_response.endswith('"'):
+            final_response = final_response[1:-1].strip()
+        
+        # Ensure minimum length
+        if len(final_response) < 10:
+            return None
+        
+        return final_response
+    
+    def _format_bullet_response(self, response: str) -> str:
+        """Format response into clean bullet points"""
+        if not response:
+            return "• No response available"
+        
+        # Remove any thinking process or analysis first
+        cleaned_response = self._clean_analysis_from_bullets(response)
+        
+        # Extract bullet points
+        lines = cleaned_response.split('\n')
+        bullets = []
+        
+        for line in lines:
+            line = line.strip()
+            
+            # Skip empty lines
+            if not line:
+                continue
+            
+            # Extract bullet points
+            if line.startswith('•'):
+                bullet_text = line[1:].strip()
+                if len(bullet_text) > 5:  # Only meaningful content
+                    # Limit length and clean up
+                    if len(bullet_text) > 80:
+                        bullet_text = bullet_text[:77] + "..."
+                    bullets.append(f"• {bullet_text}")
+            elif line.startswith('-'):
+                bullet_text = line[1:].strip()
+                if len(bullet_text) > 5:
+                    if len(bullet_text) > 80:
+                        bullet_text = bullet_text[:77] + "..."
+                    bullets.append(f"• {bullet_text}")
+            elif line and len(line) > 10 and len(bullets) < 4:
+                # Convert non-bullet content to bullet if it looks like useful content
+                if not any(word in line.lower() for word in ['analyzing', 'looking at', 'based on', 'assessment', 'profile']):
+                    if len(line) > 80:
+                        line = line[:77] + "..."
+                    bullets.append(f"• {line}")
+        
+        # Ensure we have 3-4 bullets
+        if len(bullets) == 0:
+            return "• Assessment temporarily unavailable\n• Please try again in a moment"
+        elif len(bullets) == 1:
+            bullets.append("• Continue monitoring your wellness patterns")
+        elif len(bullets) == 2:
+            bullets.append("• Consider consulting a healthcare professional if concerns persist")
+        
+        return '\n'.join(bullets[:4])  # Limit to 4 bullets max
+    
+    def _clean_analysis_from_bullets(self, response: str) -> str:
+        """Remove analysis/thinking patterns from bullet responses"""
+        lines = response.split('\n')
+        cleaned_lines = []
+        
+        # Skip lines that contain analysis patterns
+        analysis_phrases = [
+            'analyzing', 'looking at', 'based on', 'given that', 'considering',
+            'assessment shows', 'profile indicates', 'examination reveals',
+            'let me', 'first', 'okay', 'so', 'well', 'now'
+        ]
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check if line contains analysis patterns
+            line_lower = line.lower()
+            is_analysis = any(phrase in line_lower for phrase in analysis_phrases)
+            
+            # Keep lines that are bullet points or direct statements
+            if not is_analysis or line.startswith('•') or line.startswith('-'):
+                cleaned_lines.append(line)
+        
+        return '\n'.join(cleaned_lines)
+    
+    def _calculate_dynamic_risk_level(self, user_profile: Dict) -> int:
+        """Calculate dynamic risk level based on user profile factors"""
+        risk_score = 0
+        
+        # Sleep factors (0-4 points)
+        sleep_hours = user_profile.get('Sleep_Hours', 7)
+        sleep_quality = user_profile.get('Sleep_Quality', 'Fair')
+        
+        if sleep_hours < 5:
+            risk_score += 3
+        elif sleep_hours < 6:
+            risk_score += 2
+        elif sleep_hours < 7:
+            risk_score += 1
+        elif sleep_hours > 9:
+            risk_score += 1
+        
+        if sleep_quality == 'Poor':
+            risk_score += 2
+        elif sleep_quality == 'Fair':
+            risk_score += 1
+        
+        # Stress and anxiety factors (0-6 points)
+        stress_level = user_profile.get('Stress_Level', 'Medium')
+        anxiety_freq = user_profile.get('Anxiety_Frequency', 'Sometimes')
+        
+        if stress_level == 'High':
+            risk_score += 3
+        elif stress_level == 'Medium':
+            risk_score += 1
+        
+        if anxiety_freq in ['Often', 'Always']:
+            risk_score += 3
+        elif anxiety_freq == 'Sometimes':
+            risk_score += 1
+        
+        # Mood factors (0-3 points)
+        mood = user_profile.get('Mood', 'Neutral')
+        if mood in ['Very Sad', 'Sad']:
+            risk_score += 3
+        elif mood == 'Neutral':
+            risk_score += 1
+        
+        # Energy level (0-2 points)
+        energy = user_profile.get('Energy_Level', 'Medium')
+        if energy in ['Very Low', 'Low']:
+            risk_score += 2
+        elif energy == 'Medium' and stress_level == 'High':
+            risk_score += 1
+        
+        # Physical activity (0-2 points)
+        activity_hours = user_profile.get('Physical_Activity_Hours', 3)
+        if activity_hours < 1:
+            risk_score += 2
+        elif activity_hours < 2:
+            risk_score += 1
+        
+        # Work-life balance (0-2 points)
+        work_hours = user_profile.get('Work_Hours', 40)
+        if work_hours > 60:
+            risk_score += 2
+        elif work_hours > 50:
+            risk_score += 1
+        
+        # Social media and lifestyle factors (0-2 points)
+        social_media = user_profile.get('Social_Media_Hours', 3)
+        if social_media > 8:
+            risk_score += 2
+        elif social_media > 6:
+            risk_score += 1
+        
+        # Diet quality (0-1 points)
+        diet = user_profile.get('Diet', 'Average')
+        if diet == 'Unhealthy':
+            risk_score += 1
+        
+        # Substance use (0-2 points)
+        smoking = user_profile.get('Smoking', 'Non-Smoker')
+        alcohol = user_profile.get('Alcohol_Consumption', 'Rarely')
+        
+        if smoking in ['Regular Smoker', 'Heavy Smoker']:
+            risk_score += 2
+        elif smoking == 'Occasional Smoker':
+            risk_score += 1
+            
+        if alcohol in ['Regularly']:
+            risk_score += 1
+        
+        # Convert to 1-10 scale with proper distribution
+        if risk_score <= 2:
+            risk_level = 1  # Very low risk
+        elif risk_score <= 4:
+            risk_level = 2  # Low risk
+        elif risk_score <= 6:
+            risk_level = 3  # Low-moderate risk
+        elif risk_score <= 8:
+            risk_level = 4  # Moderate risk
+        elif risk_score <= 10:
+            risk_level = 5  # Moderate risk
+        elif risk_score <= 12:
+            risk_level = 6  # Moderate-high risk
+        elif risk_score <= 14:
+            risk_level = 7  # High risk
+        elif risk_score <= 16:
+            risk_level = 8  # High risk
+        elif risk_score <= 18:
+            risk_level = 9  # Very high risk
+        else:
+            risk_level = 10  # Critical risk
+        
+        return risk_level
+    
+    def _call_groq_api(self, prompt: str, temperature: float = 0.7) -> Optional[str]:
+        """Make API call to Groq using the new Python SDK"""
+        try:
+            completion = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a wellness coach. Provide ONLY final answers - no thinking process, no analysis steps, no reasoning explanation. Start immediately with your direct response. Be direct, concise, and helpful."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                temperature=temperature,
+                max_completion_tokens=150,  # Reduced for shorter responses
+                top_p=0.9,
+                stream=False,
+                stop=None
+            )
+            
+            return completion.choices[0].message.content
+            
+        except Exception as e:
+            print(f"Groq API error: {e}")
+            
+            # Return user-friendly error messages
+            error_msg = str(e).lower()
+            if "rate limit" in error_msg or "429" in error_msg:
+                return "• Service temporarily busy, please try again shortly"
+            elif "authentication" in error_msg or "401" in error_msg:
+                return "• Authentication issue, please contact support"
+            elif "timeout" in error_msg:
+                return "• Response taking longer than expected, please retry"
+            elif "connection" in error_msg:
+                return "• Connection issue, please check internet and retry"
+            else:
+                return "• Service temporarily unavailable, please try again"

src/reward_system.py

@@ -0,0 +1,68 @@
+from typing import Dict, List
+
+class RewardSystem:
+    def __init__(self, config, db_manager):
+        self.config = config
+        self.db = db_manager
+        self.task_rewards = config.TASK_REWARDS
+    
+    def calculate_task_reward(self, task_type: str, difficulty: str, completion_data: Dict = None) -> int:
+        """Calculate coins for completed task"""
+        base_reward = self.task_rewards.get(task_type, 10)
+        
+        # Difficulty multiplier
+        difficulty_multipliers = {
+            "easy": 1.0,
+            "medium": 1.3,
+            "hard": 1.6
+        }
+        
+        multiplier = difficulty_multipliers.get(difficulty, 1.0)
+        
+        # Quality bonus based on completion data
+        quality_bonus = 0
+        if completion_data:
+            if completion_data.get('quality_rating', 0) >= 4:
+                quality_bonus = 5
+            if completion_data.get('exceeded_expectations', False):
+                quality_bonus += 3
+        
+        total_reward = int(base_reward * multiplier) + quality_bonus
+        return total_reward
+    
+    def award_task_completion(self, user_id: str, task_id: str, completion_data: Dict = None) -> int:
+        """Award coins for completing a task"""
+        # Get task details
+        task = self.db.db[self.config.TASKS_COLLECTION].find_one({"task_id": task_id})
+        
+        if not task or task['status'] == 'completed':
+            return 0
+        
+        # Calculate reward
+        coins = self.calculate_task_reward(
+            task['task_type'], 
+            task.get('difficulty', 'medium'), 
+            completion_data
+        )
+        
+        # Update task as completed
+        self.db.complete_task(task_id, completion_data)
+        
+        # Award coins
+        reward_type = f"task_completion_{task['task_type']}"
+        if self.db.update_user_coins(user_id, coins, reward_type):
+            return coins
+        
+        return 0
+    
+    def get_reward_summary(self, user_id: str) -> Dict:
+        """Get user's reward summary"""
+        user = self.db.get_user_profile(user_id)
+        completed_tasks = self.db.get_user_tasks(user_id, "completed")
+        
+        return {
+            "total_coins": user.get('coins', 0) if user else 0,
+            "total_earned": user.get('total_coins_earned', 0) if user else 0,
+            "completed_tasks": len(completed_tasks),
+            "pending_tasks": len(self.db.get_user_tasks(user_id, "pending"))
+        }

src/setup.py

@@ -0,0 +1,155 @@
+"""
+Setup script for the Wellness Platform
+
+Run this script to initialize the system:
+1. Install dependencies
+2. Set up MongoDB
+3. Pull Ollama models
+4. Initialize database collections
+"""
+
+import subprocess
+import sys
+import os
+import json
+from pymongo import MongoClient
+
+def install_requirements():
+    """Install Python dependencies"""
+    print("📦 Installing Python dependencies...")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+    print("✅ Dependencies installed successfully!")
+
+def setup_mongodb():
+    """Set up MongoDB connection and collections"""
+    print("🍃 Setting up MongoDB...")
+    try:
+        client = MongoClient("mongodb://localhost:27017/")
+        db = client["wellness_platform"]
+        
+        # Create collections
+        collections = ["users", "activity_logs", "suggestions", "rewards"]
+        for collection in collections:
+            if collection not in db.list_collection_names():
+                db.create_collection(collection)
+                print(f"✅ Created collection: {collection}")
+        
+        print("✅ MongoDB setup complete!")
+        return True
+    except Exception as e:
+        print(f"❌ MongoDB setup failed: {e}")
+        return False
+
+def setup_ollama():
+    """Pull required Ollama models"""
+    print("🦙 Setting up Ollama models...")
+    try:
+        # Check if Ollama is running
+        result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
+        if result.returncode != 0:
+            print("❌ Ollama is not running. Please start Ollama first.")
+            return False
+        
+        # Pull granite model
+        print("📥 Pulling granite-code model...")
+        subprocess.run(["ollama", "pull", "granite-code"], check=True)
+        print("✅ Granite model ready!")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Ollama setup failed: {e}")
+        return False
+    except FileNotFoundError:
+        print("❌ Ollama not found. Please install Ollama first.")
+        return False
+
+def create_env_file():
+    """Create .env file with default configuration"""
+    print("📝 Creating environment configuration...")
+    env_content = """
+# MongoDB Configuration
+MONGODB_URI=mongodb://localhost:27017/
+
+# API Keys (update with your actual keys)
+GROQ_API_KEY=your_groq_api_key_here
+
+# Ollama Configuration
+OLLAMA_BASE_URL=http://localhost:11434/api/generate
+"""
+    
+    if not os.path.exists(".env"):
+        with open(".env", "w") as f:
+            f.write(env_content.strip())
+        print("✅ Created .env file")
+    else:
+        print("ℹ️ .env file already exists")
+
+def create_sample_user():
+    """Create a sample user profile"""
+    print("👤 Creating sample user profile...")
+    sample_profile = {
+        "user_id": "demo_user",
+        "Age": 30,
+        "Gender": "Male",
+        "Occupation": "Engineering",
+        "Country": "USA",
+        "Consultation_History": "No",
+        "Stress_Level": "Medium",
+        "Sleep_Hours": 7.5,
+        "Work_Hours": 40,
+        "Physical_Activity_Hours": 3.0,
+        "Social_Media_Usage": 2.0,
+        "Diet_Quality": "Average",
+        "Smoking_Habit": "Non-Smoker",
+        "Alcohol_Consumption": "Social Drinker",
+        "Medication_Usage": "No",
+        "coins": 50,
+        "total_coins_earned": 50
+    }
+    
+    try:
+        client = MongoClient("mongodb://localhost:27017/")
+        db = client["wellness_platform"]
+        
+        # Insert sample user if doesn't exist
+        if not db.users.find_one({"user_id": "demo_user"}):
+            db.users.insert_one(sample_profile)
+            print("✅ Sample user created!")
+        else:
+            print("ℹ️ Sample user already exists")
+    except Exception as e:
+        print(f"❌ Failed to create sample user: {e}")
+
+def main():
+    """Main setup function"""
+    print("🌟 Welcome to Wellness Platform Setup!")
+    print("=" * 50)
+    
+    # Install dependencies
+    install_requirements()
+    print()
+    
+    # Create environment file
+    create_env_file()
+    print()
+    
+    # Setup MongoDB
+    if setup_mongodb():
+        create_sample_user()
+    print()
+    
+    # Setup Ollama
+    setup_ollama()
+    print()
+    
+    print("🎉 Setup Complete!")
+    print("=" * 50)
+    print("Next steps:")
+    print("1. Update your GROQ_API_KEY in the .env file")
+    print("2. Make sure MongoDB is running (mongod)")
+    print("3. Make sure Ollama is running (ollama serve)")
+    print("4. Run the application: streamlit run main_app.py")
+    print()
+    print("🚀 Happy wellness tracking!")
+
+if __name__ == "__main__":
+    main()