Upload 5 files

careloop_main.py

@@ -0,0 +1,1143 @@
+# CareLoop Hackathon Submission - Main Application
+# AI-Powered Family Caregiving Assistant
+
+import asyncio
+import json
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, TypedDict, Optional
+from dataclasses import dataclass, asdict
+from enum import Enum
+import random
+import uuid
+
+# LangGraph and LangChain imports
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+
+# FastAPI for web interface
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+import uvicorn
+
+# ============== MOCK DATA MODELS ==============
+
+class AlertLevel(Enum):
+    LOW = "low"
+    MEDIUM = "medium" 
+    HIGH = "high"
+    URGENT = "urgent"
+
+@dataclass
+class Parent:
+    id: str
+    name: str
+    age: int
+    conditions: List[str]
+    medications: List[Dict]
+    emergency_contacts: List[Dict]
+    preferences: Dict
+
+@dataclass
+class FamilyMember:
+    id: str
+    name: str
+    relationship: str
+    phone: str
+    email: str
+    role: str
+    notification_preferences: Dict
+
+@dataclass
+class HealthMetric:
+    timestamp: datetime
+    metric_type: str
+    value: float
+    unit: str
+    source: str
+    normal_range: tuple
+
+# ============== COMPREHENSIVE MOCK DATA ==============
+
+class MockDataGenerator:
+    def __init__(self):
+        self.parents = {}
+        self.families = {}
+        self.health_data = {}
+        self.medication_data = {}
+        self.setup_families()
+    
+    def setup_families(self):
+        # Family 1: Margaret Chen (active, multiple conditions)
+        margaret = Parent(
+            id="parent_001",
+            name="Margaret Chen",
+            age=78,
+            conditions=["Type 2 Diabetes", "Hypertension", "Mild Cognitive Impairment"],
+            medications=[
+                {"name": "Metformin", "dosage": "500mg", "frequency": "2x daily", "times": ["08:00", "20:00"]},
+                {"name": "Lisinopril", "dosage": "10mg", "frequency": "1x daily", "times": ["08:00"]},
+                {"name": "Donepezil", "dosage": "5mg", "frequency": "1x daily", "times": ["20:00"]}
+            ],
+            emergency_contacts=[
+                {"name": "Dr. Sarah Kim", "phone": "555-MED-1234", "type": "primary_care"},
+                {"name": "Mercy General Hospital", "phone": "555-911-HELP", "type": "emergency"}
+            ],
+            preferences={
+                "preferred_contact_time": "morning",
+                "communication_style": "gentle",
+                "daily_check_in_time": "19:00"
+            }
+        )
+        
+        margaret_family = [
+            FamilyMember(
+                id="family_001",
+                name="David Chen",
+                relationship="son",
+                phone="555-123-4567",
+                email="david.chen@email.com",
+                role="primary_caregiver",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": True,
+                    "medication_reminders": True,
+                    "health_trends": True
+                }
+            ),
+            FamilyMember(
+                id="family_002", 
+                name="Lisa Chen-Rodriguez",
+                relationship="daughter",
+                phone="555-987-6543",
+                email="lisa.rodriguez@email.com",
+                role="backup_caregiver",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": False,
+                    "medication_reminders": False,
+                    "health_trends": True
+                }
+            ),
+            FamilyMember(
+                id="family_003",
+                name="Jennifer Chen",
+                relationship="daughter-in-law",
+                phone="555-456-7890", 
+                email="jen.chen@email.com",
+                role="support",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": False,
+                    "medication_reminders": False,
+                    "health_trends": False
+                }
+            )
+        ]
+        
+        # Family 2: Robert Johnson (recent stroke recovery)
+        robert = Parent(
+            id="parent_002",
+            name="Robert Johnson",
+            age=72,
+            conditions=["Stroke Recovery", "Atrial Fibrillation", "Arthritis"],
+            medications=[
+                {"name": "Warfarin", "dosage": "5mg", "frequency": "1x daily", "times": ["18:00"]},
+                {"name": "Atorvastatin", "dosage": "20mg", "frequency": "1x daily", "times": ["20:00"]},
+                {"name": "Aspirin", "dosage": "81mg", "frequency": "1x daily", "times": ["08:00"]}
+            ],
+            emergency_contacts=[
+                {"name": "Dr. James Miller", "phone": "555-MED-8765", "type": "primary_care"},
+                {"name": "Central Hospital", "phone": "555-911-9999", "type": "emergency"}
+            ],
+            preferences={
+                "preferred_contact_time": "afternoon",
+                "communication_style": "direct",
+                "daily_check_in_time": "17:00"
+            }
+        )
+        
+        robert_family = [
+            FamilyMember(
+                id="family_101",
+                name="Michael Johnson",
+                relationship="son",
+                phone="555-333-4444",
+                email="michael.johnson@email.com",
+                role="primary_caregiver",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": True,
+                    "medication_reminders": True,
+                    "health_trends": True
+                }
+            ),
+            FamilyMember(
+                id="family_102", 
+                name="Susan Johnson",
+                relationship="daughter",
+                phone="555-555-6666",
+                email="susan.johnson@email.com",
+                role="backup_caregiver",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": True,
+                    "medication_reminders": True,
+                    "health_trends": True
+                }
+            )
+        ]
+        
+        # Family 3: Elena Gonzalez (early Alzheimer's)
+        elena = Parent(
+            id="parent_003",
+            name="Elena Gonzalez",
+            age=81,
+            conditions=["Early Alzheimer's", "Osteoporosis", "COPD"],
+            medications=[
+                {"name": "Aricept", "dosage": "10mg", "frequency": "1x daily", "times": ["20:00"]},
+                {"name": "Alendronate", "dosage": "70mg", "frequency": "1x weekly", "times": ["08:00"]},
+                {"name": "Albuterol", "dosage": "90mcg", "frequency": "as needed", "times": ["08:00", "20:00"]}
+            ],
+            emergency_contacts=[
+                {"name": "Dr. Maria Lopez", "phone": "555-MED-9876", "type": "primary_care"},
+                {"name": "Sunset Medical Center", "phone": "555-911-4321", "type": "emergency"}
+            ],
+            preferences={
+                "preferred_contact_time": "morning",
+                "communication_style": "simple",
+                "daily_check_in_time": "10:00"
+            }
+        )
+        
+        elena_family = [
+            FamilyMember(
+                id="family_201",
+                name="Carlos Gonzalez",
+                relationship="son",
+                phone="555-777-8888",
+                email="carlos.gonzalez@email.com",
+                role="primary_caregiver",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": True,
+                    "medication_reminders": True,
+                    "health_trends": True
+                }
+            ),
+            FamilyMember(
+                id="family_202", 
+                name="Isabella Martinez",
+                relationship="granddaughter",
+                phone="555-999-0000",
+                email="isabella.martinez@email.com",
+                role="support",
+                notification_preferences={
+                    "urgent_alerts": True,
+                    "daily_summary": False,
+                    "medication_reminders": False,
+                    "health_trends": True
+                }
+            )
+        ]
+        
+        # Store in parent dictionary
+        self.parents = {
+            "parent_001": margaret,
+            "parent_002": robert,
+            "parent_003": elena
+        }
+        
+        # Store in family dictionary
+        self.families = {
+            "parent_001": margaret_family,
+            "parent_002": robert_family,
+            "parent_003": elena_family
+        }
+        
+        # Generate health data for each parent
+        for parent_id in self.parents:
+            self.health_data[parent_id] = self.generate_health_timeline(parent_id)
+            self.medication_data[parent_id] = self.generate_medication_timeline(parent_id)
+        
+        # For backward compatibility
+        self.margaret = self.parents["parent_001"]
+        self.margaret_family = self.families["parent_001"]
+    
+    def get_parent_by_id(self, parent_id: str) -> Optional[Parent]:
+        """Get parent data by ID"""
+        return self.parents.get(parent_id)
+    
+    def get_family_by_parent_id(self, parent_id: str) -> List[FamilyMember]:
+        """Get family members for a specific parent"""
+        return self.families.get(parent_id, [])
+    
+    def get_health_data_by_parent_id(self, parent_id: str) -> List[HealthMetric]:
+        """Get health data for a specific parent"""
+        return self.health_data.get(parent_id, [])
+    
+    def get_medication_data_by_parent_id(self, parent_id: str) -> List[Dict]:
+        """Get medication data for a specific parent"""
+        return self.medication_data.get(parent_id, [])
+    
+    def generate_health_timeline(self, parent_id: str) -> List[HealthMetric]:
+        """Generate realistic health data for the past week"""
+        metrics = []
+        base_date = datetime.now() - timedelta(days=7)
+        parent = self.parents.get(parent_id)
+        
+        if not parent:
+            return []
+        
+        for day in range(7):
+            current_date = base_date + timedelta(days=day)
+            
+            # Morning metrics
+            morning = current_date.replace(hour=8, minute=0)
+            
+            # Customize metrics based on parent conditions
+            if parent_id == "parent_001":  # Margaret (diabetes, hypertension)
+                metrics.extend([
+                    HealthMetric(morning, "heart_rate", 72 + random.randint(-8, 8), "bpm", "apple_watch", (60, 90)),
+                    HealthMetric(morning, "blood_pressure_systolic", 135 + random.randint(-15, 15), "mmHg", "omron_cuff", (90, 140)),
+                    HealthMetric(morning, "blood_pressure_diastolic", 82 + random.randint(-10, 10), "mmHg", "omron_cuff", (60, 90)),
+                    HealthMetric(morning, "weight", 145.2 + random.uniform(-1, 1), "lbs", "smart_scale", (140, 150)),
+                ])
+                
+                # Blood glucose (Type 2 diabetes)
+                for hour in [8, 12, 18]:
+                    glucose_time = current_date.replace(hour=hour, minute=random.randint(0, 30))
+                    base_glucose = 140 if hour == 12 else 120  # Higher after lunch
+                    metrics.append(
+                        HealthMetric(glucose_time, "blood_glucose", base_glucose + random.randint(-20, 30), "mg/dL", "glucose_meter", (80, 130))
+                    )
+                    
+            elif parent_id == "parent_002":  # Robert (stroke recovery, AFib)
+                metrics.extend([
+                    HealthMetric(morning, "heart_rate", 78 + random.randint(-5, 12), "bpm", "apple_watch", (60, 90)),
+                    HealthMetric(morning, "blood_pressure_systolic", 142 + random.randint(-10, 20), "mmHg", "omron_cuff", (90, 140)),
+                    HealthMetric(morning, "blood_pressure_diastolic", 88 + random.randint(-5, 10), "mmHg", "omron_cuff", (60, 90)),
+                    HealthMetric(morning, "weight", 190.5 + random.uniform(-1, 1.5), "lbs", "smart_scale", (185, 195)),
+                    HealthMetric(morning, "heart_rhythm", 1 if random.random() < 0.2 else 0, "irregularity", "ecg_monitor", (0, 0)),
+                ])
+                
+            elif parent_id == "parent_003":  # Elena (Alzheimer's, osteoporosis, COPD)
+                metrics.extend([
+                    HealthMetric(morning, "heart_rate", 75 + random.randint(-8, 10), "bpm", "apple_watch", (60, 90)),
+                    HealthMetric(morning, "blood_pressure_systolic", 128 + random.randint(-10, 15), "mmHg", "omron_cuff", (90, 140)),
+                    HealthMetric(morning, "blood_pressure_diastolic", 78 + random.randint(-8, 8), "mmHg", "omron_cuff", (60, 90)),
+                    HealthMetric(morning, "weight", 118.7 + random.uniform(-0.5, 0.5), "lbs", "smart_scale", (115, 120)),
+                    HealthMetric(morning, "oxygen_saturation", 94 + random.randint(-3, 2), "%", "pulse_oximeter", (95, 100)),
+                ])
+                
+                # Cognitive function test (for Alzheimer's)
+                if day % 2 == 0:  # Every other day
+                    test_time = current_date.replace(hour=11, minute=random.randint(0, 30))
+                    metrics.append(
+                        HealthMetric(test_time, "cognitive_score", 78 + random.randint(-8, 5), "points", "cognitive_test", (85, 100))
+                    )
+            
+            # Daily activity metrics - common for all
+            metrics.extend([
+                HealthMetric(current_date.replace(hour=23, minute=59), "steps", 2800 + random.randint(-800, 1200), "steps", "apple_watch", (2000, 8000)),
+                HealthMetric(current_date.replace(hour=23, minute=59), "sleep_hours", 6.5 + random.uniform(-1, 1.5), "hours", "apple_watch", (6, 9)),
+            ])
+        
+        return sorted(metrics, key=lambda x: x.timestamp)
+    
+    def generate_medication_timeline(self, parent_id: str) -> List[Dict]:
+        """Generate medication compliance data"""
+        compliance_data = []
+        base_date = datetime.now() - timedelta(days=7)
+        parent = self.parents.get(parent_id)
+        
+        if not parent:
+            return []
+        
+        for day in range(7):
+            current_date = base_date + timedelta(days=day)
+            
+            for med in parent.medications:
+                for time_str in med["times"]:
+                    hour, minute = map(int, time_str.split(':'))
+                    scheduled_time = current_date.replace(hour=hour, minute=minute)
+                    
+                    # Simulate realistic compliance patterns
+                    compliance_rate = 0.9  # Default rate
+                    
+                    if parent_id == "parent_001":  # Margaret
+                        if med["name"] == "Metformin":
+                            compliance_rate = 0.95 if hour < 12 else 0.85
+                        elif med["name"] == "Lisinopril":
+                            compliance_rate = 0.92
+                        else:  # Donepezil
+                            compliance_rate = 0.88
+                    elif parent_id == "parent_002":  # Robert
+                        if med["name"] == "Warfarin":
+                            compliance_rate = 0.97  # Critical medication
+                        else:
+                            compliance_rate = 0.9
+                    elif parent_id == "parent_003":  # Elena (Alzheimer's)
+                        # More forgetful due to cognitive issues
+                        compliance_rate = 0.75 if hour >= 18 else 0.85
+                    
+                    was_taken = random.random() < compliance_rate
+                    actual_time = None
+                    
+                    if was_taken:
+                        # Add realistic delay (5-30 minutes)
+                        delay_minutes = random.randint(5, 30)
+                        actual_time = scheduled_time + timedelta(minutes=delay_minutes)
+                    
+                    compliance_data.append({
+                        "medication": med["name"],
+                        "scheduled_time": scheduled_time,
+                        "actual_time": actual_time,
+                        "was_taken": was_taken,
+                        "source": "pill_dispenser" if was_taken else "missed"
+                    })
+        
+        return compliance_data
+
+# ============== LANGGRAPH STATE DEFINITION ==============
+
+class CareState(TypedDict):
+    parent_id: str
+    date: str
+    health_metrics: List[Dict]
+    medication_status: List[Dict]
+    concerns: List[str]
+    alerts: List[Dict]
+    daily_summary: str
+    action_items: List[str]
+    family_notifications: List[Dict]
+    emergency_level: str
+
+# ============== SPECIALIZED CARE AGENTS ==============
+
+class HealthMonitorAgent:
+    def __init__(self, llm):
+        self.llm = llm
+        self.mock_data = MockDataGenerator()
+    
+    def analyze_health_patterns(self, state: CareState) -> CareState:
+        """Analyze health trends and identify concerns"""
+        recent_metrics = [m for m in self.mock_data.health_data[state["parent_id"]] 
+                         if m.timestamp >= datetime.now() - timedelta(days=3)]
+        
+        concerns = []
+        alerts = []
+        
+        # Analyze blood glucose trends (diabetes management)
+        glucose_readings = [m for m in recent_metrics if m.metric_type == "blood_glucose"]
+        if glucose_readings:
+            avg_glucose = sum(m.value for m in glucose_readings) / len(glucose_readings)
+            if avg_glucose > 160:
+                concerns.append("Blood glucose levels elevated - average 165 mg/dL over 3 days")
+                alerts.append({
+                    "type": "health_concern",
+                    "severity": AlertLevel.HIGH.value,
+                    "message": "Diabetes management needs attention - glucose levels trending high",
+                    "recommended_action": "Contact diabetes care team"
+                })
+        
+        # Analyze activity levels
+        step_data = [m for m in recent_metrics if m.metric_type == "steps"]
+        if step_data:
+            avg_steps = sum(m.value for m in step_data) / len(step_data)
+            if avg_steps < 2000:
+                concerns.append(f"Low activity level - averaging {int(avg_steps)} steps/day")
+                alerts.append({
+                    "type": "activity_concern",
+                    "severity": AlertLevel.MEDIUM.value,
+                    "message": "Activity levels below recommended for health maintenance",
+                    "recommended_action": "Encourage gentle walks or physical therapy"
+                })
+        
+        # Analyze sleep patterns
+        sleep_data = [m for m in recent_metrics if m.metric_type == "sleep_hours"]
+        if sleep_data:
+            avg_sleep = sum(m.value for m in sleep_data) / len(sleep_data)
+            if avg_sleep < 6:
+                concerns.append(f"Insufficient sleep - averaging {avg_sleep:.1f} hours/night")
+        
+        # Blood pressure monitoring
+        bp_systolic = [m for m in recent_metrics if m.metric_type == "blood_pressure_systolic"]
+        if bp_systolic:
+            recent_bp = bp_systolic[-1].value
+            if recent_bp > 150:
+                concerns.append(f"Blood pressure elevated - last reading {recent_bp} mmHg")
+                alerts.append({
+                    "type": "vital_concern",
+                    "severity": AlertLevel.HIGH.value,
+                    "message": "Blood pressure significantly elevated",
+                    "recommended_action": "Schedule urgent medical appointment"
+                })
+        
+        state["health_metrics"] = [asdict(m) for m in recent_metrics]
+        state["concerns"].extend(concerns)
+        state["alerts"].extend(alerts)
+        
+        return state
+
+class MedicationAgent:
+    def __init__(self, llm):
+        self.llm = llm
+        self.mock_data = MockDataGenerator()
+    
+    def check_medication_compliance(self, state: CareState) -> CareState:
+        """Monitor medication adherence and identify issues"""
+        recent_meds = [m for m in self.mock_data.medication_data[state["parent_id"]] 
+                      if m["scheduled_time"] >= datetime.now() - timedelta(days=3)]
+        
+        # Calculate compliance rates
+        compliance_summary = {}
+        for med_record in recent_meds:
+            med_name = med_record["medication"]
+            if med_name not in compliance_summary:
+                compliance_summary[med_name] = {"total": 0, "taken": 0, "missed_times": []}
+            
+            compliance_summary[med_name]["total"] += 1
+            if med_record["was_taken"]:
+                compliance_summary[med_name]["taken"] += 1
+            else:
+                compliance_summary[med_name]["missed_times"].append(med_record["scheduled_time"])
+        
+        # Generate alerts for poor compliance
+        alerts = []
+        concerns = []
+        
+        for med_name, data in compliance_summary.items():
+            compliance_rate = data["taken"] / data["total"]
+            
+            if compliance_rate < 0.8:
+                concerns.append(f"Poor medication compliance: {med_name} - {compliance_rate:.0%} over 3 days")
+                alerts.append({
+                    "type": "medication_compliance",
+                    "severity": AlertLevel.HIGH.value,
+                    "message": f"{med_name} missed multiple doses - compliance at {compliance_rate:.0%}",
+                    "recommended_action": "Review medication routine with family"
+                })
+            elif compliance_rate < 0.9:
+                concerns.append(f"Medication adherence concern: {med_name} - {compliance_rate:.0%}")
+        
+        # Check for recent missed doses
+        recent_missed = [m for m in recent_meds 
+                        if not m["was_taken"] and 
+                        m["scheduled_time"] >= datetime.now() - timedelta(hours=24)]
+        
+        if recent_missed:
+            for missed in recent_missed:
+                alerts.append({
+                    "type": "missed_medication",
+                    "severity": AlertLevel.MEDIUM.value,
+                    "message": f"Missed {missed['medication']} at {missed['scheduled_time'].strftime('%I:%M %p')}",
+                    "recommended_action": "Remind about missed dose"
+                })
+        
+        state["medication_status"] = recent_meds
+        state["concerns"].extend(concerns)
+        state["alerts"].extend(alerts)
+        
+        return state
+
+class FamilyCommunicationAgent:
+    def __init__(self, llm):
+        self.llm = llm
+        self.mock_data = MockDataGenerator()
+    
+    def generate_family_updates(self, state: CareState) -> CareState:
+        """Create personalized updates for each family member"""
+        notifications = []
+        
+        # Get urgency level
+        alert_levels = [alert["severity"] for alert in state["alerts"]]
+        max_severity = AlertLevel.LOW.value
+        if AlertLevel.URGENT.value in alert_levels:
+            max_severity = AlertLevel.URGENT.value
+        elif AlertLevel.HIGH.value in alert_levels:
+            max_severity = AlertLevel.HIGH.value
+        elif AlertLevel.MEDIUM.value in alert_levels:
+            max_severity = AlertLevel.MEDIUM.value
+        
+        # Generate notifications for each family member
+        for family_member in self.mock_data.get_family_by_parent_id(state["parent_id"]):
+            prefs = family_member.notification_preferences
+            
+            # Determine what to include based on preferences and severity
+            should_send_immediate = False
+            message_parts = []
+            
+            if max_severity in [AlertLevel.URGENT.value, AlertLevel.HIGH.value] and prefs["urgent_alerts"]:
+                should_send_immediate = True
+                urgent_alerts = [a for a in state["alerts"] if a["severity"] in [AlertLevel.URGENT.value, AlertLevel.HIGH.value]]
+                message_parts.append("🚨 **Urgent Update Needed**")
+                for alert in urgent_alerts[:2]:  # Limit to top 2 urgent items
+                    message_parts.append(f"• {alert['message']}")
+            
+            if prefs["daily_summary"]:
+                message_parts.append(f"\n📋 **Daily Summary for {self.mock_data.get_parent_by_id(state['parent_id']).name}**")
+                
+                # Health highlights
+                if state["health_metrics"]:
+                    latest_metrics = {}
+                    for metric in state["health_metrics"]:
+                        if metric["metric_type"] not in latest_metrics or metric["timestamp"] > latest_metrics[metric["metric_type"]]["timestamp"]:
+                            latest_metrics[metric["metric_type"]] = metric
+                    
+                    message_parts.append("📊 **Today's Health Data:**")
+                    if "steps" in latest_metrics:
+                        steps = int(latest_metrics["steps"]["value"])
+                        message_parts.append(f"• Activity: {steps:,} steps")
+                    if "blood_glucose" in latest_metrics:
+                        glucose = latest_metrics["blood_glucose"]["value"]
+                        message_parts.append(f"• Blood Sugar: {glucose} mg/dL")
+                
+                # Medication status
+                if prefs["medication_reminders"] and state["medication_status"]:
+                    today_meds = [m for m in state["medication_status"] 
+                                 if m["scheduled_time"].date() == datetime.now().date()]
+                    taken_count = sum(1 for m in today_meds if m["was_taken"])
+                    total_count = len(today_meds)
+                    
+                    message_parts.append(f"💊 **Medications:** {taken_count}/{total_count} doses taken today")
+            
+            if message_parts:
+                notifications.append({
+                    "recipient": family_member.name,
+                    "recipient_id": family_member.id,
+                    "phone": family_member.phone,
+                    "email": family_member.email,
+                    "message": "\n".join(message_parts),
+                    "urgency": max_severity,
+                    "send_immediately": should_send_immediate,
+                    "channels": ["sms"] if should_send_immediate else ["email"]
+                })
+        
+        state["family_notifications"] = notifications
+        return state
+    
+    def create_daily_summary(self, state: CareState) -> CareState:
+        """Generate comprehensive daily summary"""
+        summary_parts = []
+        
+        # Header with date and overall status
+        today = datetime.now().strftime("%A, %B %d, %Y")
+        summary_parts.append(f"# Daily Care Report - {today}")
+        summary_parts.append(f"**Parent:** {self.mock_data.get_parent_by_id(state['parent_id']).name}")
+        
+        # Overall status indicator
+        if any(alert["severity"] == AlertLevel.URGENT.value for alert in state["alerts"]):
+            summary_parts.append("🔴 **Status: Needs Immediate Attention**")
+        elif any(alert["severity"] == AlertLevel.HIGH.value for alert in state["alerts"]):
+            summary_parts.append("🟡 **Status: Some Concerns**")
+        elif state["concerns"]:
+            summary_parts.append("🟢 **Status: Monitoring**")
+        else:
+            summary_parts.append("✅ **Status: All Good**")
+        
+        # Key metrics summary
+        summary_parts.append("\n## Today's Highlights")
+        
+        if state["health_metrics"]:
+            # Get today's key metrics
+            today_metrics = [m for m in state["health_metrics"] 
+                           if m["timestamp"].date() == datetime.now().date()]
+            
+            if today_metrics:
+                latest_by_type = {}
+                for metric in today_metrics:
+                    metric_type = metric["metric_type"]
+                    if metric_type not in latest_by_type:
+                        latest_by_type[metric_type] = metric
+                
+                summary_parts.append("### Health Metrics")
+                for metric_type, data in latest_by_type.items():
+                    value = data["value"]
+                    unit = data["unit"]
+                    
+                    if metric_type == "steps":
+                        summary_parts.append(f"• **Activity:** {int(value):,} {unit}")
+                    elif metric_type == "blood_glucose":
+                        status = "🔴 High" if value > 150 else "🟡 Elevated" if value > 130 else "✅ Normal"
+                        summary_parts.append(f"• **Blood Sugar:** {value} {unit} {status}")
+                    elif metric_type == "blood_pressure_systolic":
+                        status = "🔴 High" if value > 140 else "🟡 Elevated" if value > 130 else "✅ Normal"
+                        summary_parts.append(f"• **Blood Pressure:** {value} {unit} {status}")
+        
+        # Medication summary
+        if state["medication_status"]:
+            today_meds = [m for m in state["medication_status"] 
+                         if m["scheduled_time"].date() == datetime.now().date()]
+            
+            if today_meds:
+                taken_count = sum(1 for m in today_meds if m["was_taken"])
+                total_count = len(today_meds)
+                
+                summary_parts.append(f"\n### Medication Compliance")
+                summary_parts.append(f"• **Today:** {taken_count}/{total_count} doses taken")
+                
+                if taken_count < total_count:
+                    missed = [m for m in today_meds if not m["was_taken"]]
+                    summary_parts.append("• **Missed doses:**")
+                    for m in missed:
+                        time_str = m["scheduled_time"].strftime("%I:%M %p")
+                        summary_parts.append(f"  - {m['medication']} at {time_str}")
+        
+        # Concerns and alerts
+        if state["concerns"]:
+            summary_parts.append(f"\n## Areas of Attention ({len(state['concerns'])})")
+            for concern in state["concerns"]:
+                summary_parts.append(f"• {concern}")
+        
+        # Action items
+        if state["action_items"]:
+            summary_parts.append(f"\n## Recommended Actions")
+            for action in state["action_items"]:
+                summary_parts.append(f"• {action}")
+        
+        state["daily_summary"] = "\n".join(summary_parts)
+        return state
+
+class ActionPlannerAgent:
+    def __init__(self, llm):
+        self.llm = llm
+    
+    def generate_action_items(self, state: CareState) -> CareState:
+        """Generate prioritized action items based on concerns and alerts"""
+        actions = []
+        
+        # Process alerts to create specific actions
+        urgent_alerts = [a for a in state["alerts"] if a["severity"] == AlertLevel.URGENT.value]
+        high_alerts = [a for a in state["alerts"] if a["severity"] == AlertLevel.HIGH.value]
+        
+        # Urgent actions first
+        for alert in urgent_alerts:
+            if alert["type"] == "vital_concern":
+                actions.append("🚨 URGENT: Schedule emergency medical appointment for blood pressure management")
+            elif alert["type"] == "medication_compliance":
+                actions.append(f"🚨 URGENT: Call parent immediately about missed {alert['message'].split()[0]} medications")
+        
+        # High priority actions
+        for alert in high_alerts:
+            if alert["type"] == "health_concern":
+                actions.append("📞 HIGH: Contact diabetes care team about elevated glucose levels")
+            elif alert["type"] == "medication_compliance":
+                actions.append("📞 HIGH: Review medication routine - consider pill dispenser or reminder system")
+        
+        # Medium priority actions based on concerns
+        concern_keywords = {
+            "low activity": "💪 Encourage gentle exercise - suggest short walks or chair exercises",
+            "insufficient sleep": "😴 Discuss sleep hygiene - check for pain or anxiety issues",
+            "blood pressure": "🩺 Monitor blood pressure daily and log readings for doctor",
+            "medication": "💊 Set up automated medication reminders or family check-ins"
+        }
+        
+        for concern in state["concerns"]:
+            concern_lower = concern.lower()
+            for keyword, action in concern_keywords.items():
+                if keyword in concern_lower and action not in actions:
+                    actions.append(action)
+        
+        # Always include routine actions
+        routine_actions = [
+            "📋 Review tomorrow's medication schedule",
+            "📱 Confirm evening check-in call is scheduled",
+            "📊 Check health metrics sync from devices"
+        ]
+        
+        # Only add routine actions if no urgent/high priority actions
+        if not urgent_alerts and not high_alerts:
+            actions.extend(routine_actions)
+        
+        # Limit to top 5 actions for manageability
+        state["action_items"] = actions[:5]
+        return state
+
+# ============== MAIN LANGGRAPH WORKFLOW ==============
+
+class CareLoopOrchestrator:
+    def __init__(self):
+        # For demo purposes, we'll mock the LLM
+        self.llm = None  # ChatOpenAI would go here in production
+        
+        # Initialize mock data
+        self.mock_data = MockDataGenerator()
+        
+        # Initialize specialized agents
+        self.health_monitor = HealthMonitorAgent(self.llm)
+        self.medication_agent = MedicationAgent(self.llm)
+        self.family_communicator = FamilyCommunicationAgent(self.llm)
+        self.action_planner = ActionPlannerAgent(self.llm)
+        
+        # Build the workflow graph
+        self.graph = self._build_workflow()
+    
+    def _build_workflow(self) -> StateGraph:
+        """Build the LangGraph workflow for daily care monitoring"""
+        workflow = StateGraph(CareState)
+        
+        # Add nodes for each step
+        workflow.add_node("health_analysis", self._health_analysis_node)
+        workflow.add_node("medication_check", self._medication_check_node)
+        workflow.add_node("generate_summary", self._generate_summary_node)
+        workflow.add_node("send_family_notifications", self._family_notifications_node)
+        workflow.add_node("action_planning", self._action_planning_node)
+        workflow.add_node("emergency_check", self._emergency_check_node)
+        
+        # Define the workflow
+        workflow.set_entry_point("health_analysis")
+        workflow.add_edge("health_analysis", "medication_check")
+        workflow.add_edge("medication_check", "emergency_check")
+        workflow.add_conditional_edges(
+            "emergency_check",
+            self._should_trigger_emergency,
+            {
+                "emergency": "send_family_notifications",
+                "continue": "generate_summary"
+            }
+        )
+        workflow.add_edge("generate_summary", "send_family_notifications")
+        workflow.add_edge("send_family_notifications", "action_planning")
+        workflow.add_edge("action_planning", END)
+        
+        return workflow.compile()
+    
+    def _health_analysis_node(self, state: CareState) -> CareState:
+        return self.health_monitor.analyze_health_patterns(state)
+    
+    def _medication_check_node(self, state: CareState) -> CareState:
+        return self.medication_agent.check_medication_compliance(state)
+    
+    def _generate_summary_node(self, state: CareState) -> CareState:
+        return self.family_communicator.create_daily_summary(state)
+    
+    def _family_notifications_node(self, state: CareState) -> CareState:
+        return self.family_communicator.generate_family_updates(state)
+    
+    def _action_planning_node(self, state: CareState) -> CareState:
+        return self.action_planner.generate_action_items(state)
+    
+    def _emergency_check_node(self, state: CareState) -> CareState:
+        """Check if emergency response is needed"""
+        urgent_alerts = [a for a in state["alerts"] if a["severity"] == AlertLevel.URGENT.value]
+        if urgent_alerts:
+            state["emergency_level"] = "urgent"
+        else:
+            state["emergency_level"] = "normal"
+        return state
+    
+    def _should_trigger_emergency(self, state: CareState) -> str:
+        """Decide whether to trigger emergency protocol"""
+        return "emergency" if state["emergency_level"] == "urgent" else "continue"
+    
+    def run_daily_care_cycle(self, parent_id: str) -> Dict[str, Any]:
+        """Execute the complete daily care monitoring workflow"""
+        
+        # Validate parent_id exists
+        if parent_id not in self.mock_data.parents:
+            raise ValueError(f"Parent ID {parent_id} not found")
+        
+        initial_state = {
+            "parent_id": parent_id,
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "health_metrics": [],
+            "medication_status": [],
+            "concerns": [],
+            "alerts": [],
+            "daily_summary": "",
+            "action_items": [],
+            "family_notifications": [],
+            "emergency_level": "normal"
+        }
+        
+        # Run the workflow
+        result = self.graph.invoke(initial_state)
+        
+        # Add timestamp and processing info
+        result["processed_at"] = datetime.now().isoformat()
+        result["next_check"] = (datetime.now() + timedelta(hours=24)).isoformat()
+        
+        return result
+
+# ============== WEB INTERFACE ==============
+
+# Initialize FastAPI app
+app = FastAPI(title="CareLoop - AI-Powered Family Caregiving")
+
+# Initialize the care orchestrator
+care_system = CareLoopOrchestrator()
+
+# Store for demo data
+demo_reports = []
+
+@app.get("/", response_class=HTMLResponse)
+async def get_dashboard():
+    """Serve the main dashboard"""
+    html_content = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>CareLoop Dashboard</title>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <script src="https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js" defer></script>
+    </head>
+    <body class="bg-gray-50">
+        <div x-data="careloop()" class="min-h-screen">
+            <!-- Header -->
+            <header class="bg-blue-600 text-white p-4">
+                <div class="max-w-6xl mx-auto flex justify-between items-center">
+                    <h1 class="text-2xl font-bold">🏠 CareLoop</h1>
+                    <p class="text-blue-100">AI-Powered Family Caregiving</p>
+                </div>
+            </header>
+            
+            <!-- Main Content -->
+            <main class="max-w-6xl mx-auto p-6">
+                <!-- Demo Controls -->
+                <div class="bg-white rounded-lg shadow p-6 mb-6">
+                    <h2 class="text-xl font-semibold mb-4">Hackathon Demo</h2>
+                    <div class="flex flex-col md:flex-row md:items-center mb-6 space-y-4 md:space-y-0 md:space-x-4">
+                        <div class="flex-1">
+                            <label for="parent-select" class="block text-sm font-medium text-gray-700 mb-1">Select Parent:</label>
+                            <select 
+                                id="parent-select"
+                                x-model="selectedParent"
+                                @change="loadParentInfo()"
+                                class="block w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-blue-500 focus:border-blue-500">
+                                <option value="parent_001">Margaret Chen (78) - Diabetes/Hypertension</option>
+                                <option value="parent_002">Robert Johnson (72) - Stroke Recovery</option>
+                                <option value="parent_003">Elena Gonzalez (81) - Early Alzheimer's</option>
+                            </select>
+                        </div>
+                        <div class="flex-none">
+                            <button @click="runCareCheck()" 
+                                    class="bg-blue-600 text-white px-6 py-2 rounded-lg hover:bg-blue-700 w-full md:w-auto"
+                                    :disabled="loading">
+                                <span x-show="!loading">🔄 Run Daily Care Check</span>
+                                <span x-show="loading">🔄 Analyzing...</span>
+                            </button>
+                        </div>
+                    </div>
+                    
+                    <div x-show="parentInfo" class="bg-blue-50 p-4 rounded-lg text-sm">
+                        <h3 class="font-medium text-blue-800" x-text="parentInfo.parent.name + ' (' + parentInfo.parent.age + ')'"></h3>
+                        <div class="mt-2 grid grid-cols-1 md:grid-cols-2 gap-2">
+                            <div>
+                                <p class="text-blue-600 font-medium">Health Conditions:</p>
+                                <ul class="list-disc list-inside text-blue-700 pl-2">
+                                    <template x-for="condition in parentInfo.parent.conditions">
+                                        <li x-text="condition"></li>
+                                    </template>
+                                </ul>
+                            </div>
+                            <div>
+                                <p class="text-blue-600 font-medium">Family Caregivers:</p>
+                                <ul class="list-disc list-inside text-blue-700 pl-2">
+                                    <template x-for="member in parentInfo.family">
+                                        <li x-text="member.name + ' (' + member.relationship + ')'"></li>
+                                    </template>
+                                </ul>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Results -->
+                <div x-show="report" class="space-y-6">
+                    <!-- Status Overview -->
+                    <div class="bg-white rounded-lg shadow p-6">
+                        <h3 class="text-lg font-semibold mb-4">📊 Care Status Overview</h3>
+                        <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
+                            <div class="bg-green-50 p-4 rounded-lg">
+                                <h4 class="font-medium text-green-800">Health Metrics</h4>
+                                <p class="text-green-600" x-text="report?.health_metrics?.length + ' data points collected'"></p>
+                            </div>
+                            <div class="bg-blue-50 p-4 rounded-lg">
+                                <h4 class="font-medium text-blue-800">Medication Status</h4>
+                                <p class="text-blue-600" x-text="report?.medication_status?.length + ' medication events'"></p>
+                            </div>
+                            <div class="bg-orange-50 p-4 rounded-lg">
+                                <h4 class="font-medium text-orange-800">Alerts Generated</h4>
+                                <p class="text-orange-600" x-text="report?.alerts?.length + ' alerts for family'"></p>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- Daily Summary -->
+                    <div class="bg-white rounded-lg shadow p-6">
+                        <h3 class="text-lg font-semibold mb-4">📋 Daily Summary</h3>
+                        <div class="prose max-w-none">
+                            <pre x-text="report?.daily_summary" class="whitespace-pre-wrap font-sans text-sm bg-gray-50 p-4 rounded"></pre>
+                        </div>
+                    </div>
+                    
+                    <!-- Action Items -->
+                    <div class="bg-white rounded-lg shadow p-6">
+                        <h3 class="text-lg font-semibold mb-4">✅ Recommended Actions</h3>
+                        <ul class="space-y-2">
+                            <template x-for="action in report?.action_items">
+                                <li class="flex items-start space-x-2">
+                                    <span class="text-blue-600">•</span>
+                                    <span x-text="action"></span>
+                                </li>
+                            </template>
+                        </ul>
+                    </div>
+                    
+                    <!-- Family Notifications -->
+                    <div class="bg-white rounded-lg shadow p-6">
+                        <h3 class="text-lg font-semibold mb-4">📱 Family Notifications</h3>
+                        <div class="space-y-4">
+                            <template x-for="notification in report?.family_notifications">
+                                <div class="border-l-4 border-blue-500 pl-4 py-2">
+                                    <h4 class="font-medium" x-text="'To: ' + notification.recipient + ' (' + notification.channels.join(', ') + ')'"></h4>
+                                    <pre x-text="notification.message" class="whitespace-pre-wrap text-sm text-gray-600 mt-2"></pre>
+                                </div>
+                            </template>
+                        </div>
+                    </div>
+                    
+                    <!-- Alerts Detail -->
+                    <div x-show="report?.alerts?.length > 0" class="bg-white rounded-lg shadow p-6">
+                        <h3 class="text-lg font-semibold mb-4">⚠️ Care Alerts</h3>
+                        <div class="space-y-3">
+                            <template x-for="alert in report?.alerts">
+                                <div class="border-l-4 pl-4 py-2" 
+                                     :class="{
+                                         'border-red-500 bg-red-50': alert.severity === 'urgent',
+                                         'border-orange-500 bg-orange-50': alert.severity === 'high',
+                                         'border-yellow-500 bg-yellow-50': alert.severity === 'medium',
+                                         'border-blue-500 bg-blue-50': alert.severity === 'low'
+                                     }">
+                                    <div class="flex justify-between items-start">
+                                        <div>
+                                            <h4 class="font-medium" x-text="alert.message"></h4>
+                                            <p class="text-sm text-gray-600" x-text="'Type: ' + alert.type + ' | Severity: ' + alert.severity"></p>
+                                            <p class="text-sm mt-1" x-text="'Recommended: ' + alert.recommended_action"></p>
+                                        </div>
+                                    </div>
+                                </div>
+                            </template>
+                        </div>
+                    </div>
+                </div>
+            </main>
+        </div>
+        
+        <script>
+            function careloop() {
+                return {
+                    loading: false,
+                    report: null,
+                    parentInfo: null,
+                    selectedParent: "parent_001",
+                    
+                    init() {
+                        this.loadParentInfo();
+                    },
+                    
+                    async loadParentInfo() {
+                        try {
+                            const response = await fetch(`/api/parent/${this.selectedParent}`);
+                            this.parentInfo = await response.json();
+                            // Clear previous report when changing parents
+                            this.report = null;
+                        } catch (error) {
+                            console.error('Error loading parent info:', error);
+                        }
+                    },
+                    
+                    async runCareCheck() {
+                        this.loading = true;
+                        try {
+                            const response = await fetch(`/api/care-check/${this.selectedParent}`, {
+                                method: 'POST'
+                            });
+                            this.report = await response.json();
+                        } catch (error) {
+                            console.error('Error running care check:', error);
+                        } finally {
+                            this.loading = false;
+                        }
+                    }
+                }
+            }
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.post("/api/care-check/{parent_id}")
+async def run_care_check(parent_id: str):
+    """Run the daily care check for a parent"""
+    try:
+        result = care_system.run_daily_care_cycle(parent_id)
+        demo_reports.append(result)
+        return result
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.get("/api/reports")
+async def get_reports():
+    """Get all demo reports"""
+    return {"reports": demo_reports}
+
+@app.get("/api/parent/{parent_id}")
+async def get_parent_info(parent_id: str):
+    """Get parent information"""
+    mock_data = MockDataGenerator()
+    return {
+        "parent": asdict(mock_data.get_parent_by_id(parent_id)),
+        "family": [asdict(fm) for fm in mock_data.get_family_by_parent_id(parent_id)]
+    }
+
+# ============== MAIN EXECUTION ==============
+
+if __name__ == "__main__":
+    print("🚀 Starting CareLoop Hackathon Demo")
+    print("=" * 50)
+    
+    # Load mock data
+    mock_data = MockDataGenerator()
+    
+    # Display available parents
+    print("🏠 Available Parent Profiles:")
+    for parent_id, parent in mock_data.parents.items():
+        family_count = len(mock_data.families.get(parent_id, []))
+        conditions = ", ".join(parent.conditions[:2]) + ("..." if len(parent.conditions) > 2 else "")
+        print(f"  • {parent.name} ({parent.age}) - ID: {parent_id}")
+        print(f"    Health: {conditions}")
+        print(f"    Family caregivers: {family_count}")
+    
+    # Run a sample care check for demo
+    print("\n🔄 Running sample care analysis for Margaret Chen...")
+    result = care_system.run_daily_care_cycle("parent_001")
+    
+    print(f"\n📋 Daily Summary:")
+    print(result["daily_summary"])
+    
+    print(f"\n✅ Action Items ({len(result['action_items'])}):")
+    for action in result["action_items"]:
+        print(f"  • {action}")
+    
+    print(f"\n📱 Family Notifications ({len(result['family_notifications'])}):")
+    for notification in result["family_notifications"]:
+        print(f"  → {notification['recipient']}: {notification['urgency']} priority")
+    
+    print(f"\n⚠️ Alerts Generated ({len(result['alerts'])}):")
+    for alert in result["alerts"]:
+        print(f"  • {alert['severity'].upper()}: {alert['message']}")
+    
+    print("\n" + "=" * 50)
+    print("🌐 Starting web interface...")
+    print("Open your browser to: http://localhost:8000")
+    print("Select a parent and click 'Run Daily Care Check' to see the AI agents in action!")
+    
+    # Start the web server
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")

config.py

@@ -0,0 +1,160 @@
+# config.py
+# CareLoop Configuration Management
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+@dataclass
+class DatabaseConfig:
+    """Database configuration settings"""
+    url: str = "sqlite:///careloop_demo.db"
+    echo: bool = False
+    pool_size: int = 10
+    max_overflow: int = 20
+
+@dataclass
+class AIConfig:
+    """AI and LLM configuration"""
+    openai_api_key: str = "demo-key-not-required"
+    model_name: str = "gpt-4"
+    temperature: float = 0.1
+    max_tokens: int = 2000
+    # For hackathon demo, we mock AI responses
+    use_mock_responses: bool = True
+
+@dataclass
+class NotificationConfig:
+    """Notification service configuration"""
+    twilio_account_sid: str = "demo-account"
+    twilio_auth_token: str = "demo-token"
+    twilio_phone_number: str = "+1-555-CARELOOP"
+    email_service: str = "sendgrid"
+    email_api_key: str = "demo-email-key"
+
+@dataclass
+class HealthIntegrationConfig:
+    """Health device and service integrations"""
+    apple_health_enabled: bool = True
+    fitbit_enabled: bool = True
+    omron_enabled: bool = True  # Blood pressure monitors
+    dexcom_enabled: bool = False  # Continuous glucose monitoring
+    epic_fhir_enabled: bool = False  # Electronic health records
+    
+@dataclass
+class SecurityConfig:
+    """Security and privacy settings"""
+    encryption_key: str = "demo-encryption-key-32-chars-long"
+    jwt_secret: str = "demo-jwt-secret-key"
+    session_timeout_hours: int = 24
+    max_login_attempts: int = 5
+    require_2fa: bool = False  # For demo
+    
+@dataclass
+class CareLoopConfig:
+    """Main application configuration"""
+    # Subsystem configs - non-default parameters must come first
+    database: DatabaseConfig
+    ai: AIConfig
+    notifications: NotificationConfig
+    health_integrations: HealthIntegrationConfig
+    security: SecurityConfig
+    
+    # Environment
+    environment: str = "development"
+    debug: bool = True
+    
+    # Web server
+    host: str = "0.0.0.0"
+    port: int = 8000
+    workers: int = 1
+    
+    # Feature flags
+    enable_web_interface: bool = True
+    enable_api: bool = True
+    enable_websockets: bool = True
+    enable_background_tasks: bool = True
+    
+    # Monitoring intervals
+    health_check_interval_hours: int = 4
+    medication_check_interval_hours: int = 2
+    emergency_check_interval_minutes: int = 15
+    
+    def __init__(self):
+        self.database = DatabaseConfig()
+        self.ai = AIConfig()
+        self.notifications = NotificationConfig()
+        self.health_integrations = HealthIntegrationConfig()
+        self.security = SecurityConfig()
+
+def load_config() -> CareLoopConfig:
+    """Load configuration from environment variables"""
+    config = CareLoopConfig()
+    
+    # Override with environment variables if present
+    config.environment = os.getenv("CARELOOP_ENV", "development")
+    config.debug = os.getenv("CARELOOP_DEBUG", "true").lower() == "true"
+    config.host = os.getenv("CARELOOP_HOST", "0.0.0.0")
+    config.port = int(os.getenv("CARELOOP_PORT", "8000"))
+    
+    # Database
+    config.database.url = os.getenv("DATABASE_URL", "sqlite:///careloop_demo.db")
+    
+    # AI Configuration
+    config.ai.openai_api_key = os.getenv("OPENAI_API_KEY", "demo-key")
+    config.ai.use_mock_responses = os.getenv("USE_MOCK_AI", "true").lower() == "true"
+    
+    # Notifications
+    config.notifications.twilio_account_sid = os.getenv("TWILIO_ACCOUNT_SID", "demo")
+    config.notifications.twilio_auth_token = os.getenv("TWILIO_AUTH_TOKEN", "demo")
+    config.notifications.email_api_key = os.getenv("EMAIL_API_KEY", "demo")
+    
+    # Security
+    config.security.encryption_key = os.getenv("ENCRYPTION_KEY", "demo-key-32-chars-very-secure!!")
+    config.security.jwt_secret = os.getenv("JWT_SECRET", "demo-jwt-secret")
+    
+    return config
+
+# Global config instance
+CONFIG = load_config()
+
+# Environment-specific configurations
+ENVIRONMENT_CONFIGS = {
+    "development": {
+        "debug": True,
+        "log_level": "DEBUG",
+        "database_echo": True,
+        "use_mock_integrations": True,
+        "enable_hot_reload": True
+    },
+    "staging": {
+        "debug": False,
+        "log_level": "INFO", 
+        "database_echo": False,
+        "use_mock_integrations": True,
+        "enable_hot_reload": False
+    },
+    "production": {
+        "debug": False,
+        "log_level": "WARNING",
+        "database_echo": False,
+        "use_mock_integrations": False,
+        "enable_hot_reload": False,
+        "require_https": True,
+        "enable_rate_limiting": True
+    }
+}
+
+def get_environment_config(env: str) -> Dict:
+    """Get configuration for specific environment"""
+    return ENVIRONMENT_CONFIGS.get(env, ENVIRONMENT_CONFIGS["development"])
+
+if __name__ == "__main__":
+    print("CareLoop Configuration")
+    print("=" * 30)
+    print(f"Environment: {CONFIG.environment}")
+    print(f"Debug mode: {CONFIG.debug}")
+    print(f"Database: {CONFIG.database.url}")
+    print(f"AI Mock mode: {CONFIG.ai.use_mock_responses}")
+    print(f"Web interface: {CONFIG.enable_web_interface}")
+    print(f"Host: {CONFIG.host}:{CONFIG.port}")

demo_scenarios.py

@@ -0,0 +1,216 @@
+# CareLoop Demo Script - Run Different Scenarios
+# This script demonstrates various AI agent capabilities
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from careloop_main import CareLoopOrchestrator, MockDataGenerator, AlertLevel
+from datetime import datetime, timedelta
+import random
+
+class CareLoopDemo:
+    def __init__(self):
+        self.care_system = CareLoopOrchestrator()
+        self.mock_data = MockDataGenerator()
+    
+    def print_banner(self, title: str):
+        """Print a nice banner for demo sections"""
+        print("\n" + "="*60)
+        print(f"🎯 {title}")
+        print("="*60)
+    
+    def print_section(self, title: str):
+        """Print a section header"""
+        print(f"\n📋 {title}")
+        print("-" * 40)
+    
+    def run_normal_day_scenario(self):
+        """Scenario 1: Normal day with good health metrics"""
+        self.print_banner("SCENARIO 1: Normal Day - Everything Going Well")
+        
+        print("Margaret had a good day:")
+        print("• Took all medications on time")
+        print("• Blood glucose levels stable (110-125 mg/dL)")  
+        print("• Good activity level (3,200 steps)")
+        print("• Slept well (7.5 hours)")
+        print("• Blood pressure normal (128/78)")
+        
+        # Run the care check
+        result = self.care_system.run_daily_care_cycle("parent_001")
+        
+        self.print_section("AI Agent Analysis")
+        print(f"Concerns detected: {len(result['concerns'])}")
+        print(f"Alerts generated: {len(result['alerts'])}")
+        print(f"Action items: {len(result['action_items'])}")
+        
+        if result['concerns']:
+            print("\nConcerns:")
+            for concern in result['concerns']:
+                print(f"  • {concern}")
+        else:
+            print("✅ No concerns detected - everything looks good!")
+        
+        self.print_section("Family Notifications")
+        for notification in result['family_notifications']:
+            print(f"→ {notification['recipient']} ({notification['urgency']} priority)")
+            print(f"  Channels: {', '.join(notification['channels'])}")
+        
+        return result
+    
+    def run_medication_issues_scenario(self):
+        """Scenario 2: Medication compliance problems"""
+        self.print_banner("SCENARIO 2: Medication Compliance Issues")
+        
+        print("Margaret had medication troubles:")
+        print("• Missed evening Metformin dose yesterday")
+        print("• Forgot Lisinopril this morning")  
+        print("• Late with Donepezil twice this week")
+        print("• Blood glucose elevated due to missed Metformin")
+        
+        result = self.care_system.run_daily_care_cycle("parent_001")
+        
+        self.print_section("AI Agent Response")
+        high_alerts = [a for a in result['alerts'] if a['severity'] == 'high']
+        print(f"🚨 High priority alerts: {len(high_alerts)}")
+        print(f"📋 Action items generated: {len(result['action_items'])}")
+        
+        for alert in high_alerts:
+            print(f"\n🔴 {alert['severity'].upper()}: {alert['message']}")
+            print(f"   Recommended: {alert['recommended_action']}")
+        
+        return result
+    
+    def run_family_coordination_scenario(self):
+        """Scenario 3: Complex family coordination"""
+        self.print_banner("SCENARIO 3: Multi-Family Member Coordination")
+        
+        print("Family dynamics in action:")
+        print("• David (son): Primary caregiver, wants all details")
+        print("• Lisa (daughter): Backup caregiver, weekly summaries only")
+        print("• Jennifer (daughter-in-law): Support role, emergencies only")
+        print("• Different notification preferences and access levels")
+        
+        result = self.care_system.run_daily_care_cycle("parent_001")
+        
+        self.print_section("Personalized Communication Strategy")
+        
+        for notification in result['family_notifications']:
+            print(f"\n👤 {notification['recipient']}")
+            print(f"   Role: {notification.get('recipient_id', 'unknown')}")
+            print(f"   Channels: {', '.join(notification['channels'])}")
+            print(f"   Priority: {notification['urgency']}")
+            print(f"   Send immediately: {notification.get('send_immediately', False)}")
+            
+            # Show first few lines of message
+            message_lines = notification['message'].split('\n')[:3]
+            for line in message_lines:
+                if line.strip():
+                    print(f"   Preview: {line.strip()}")
+                    break
+        
+        return result
+    
+    def show_daily_summary(self, result):
+        """Display the complete daily summary"""
+        self.print_section("Complete Daily Summary")
+        print(result['daily_summary'])
+        
+        self.print_section("Action Items")
+        for i, action in enumerate(result['action_items'], 1):
+            print(f"{i}. {action}")
+    
+    def run_interactive_demo(self):
+        """Run an interactive demo session"""
+        self.print_banner("CARELOOP INTERACTIVE DEMO")
+        
+        print("Welcome to the CareLoop AI Caregiving Platform Demo!")
+        print("This demo shows how multiple AI agents work together to")
+        print("monitor Margaret Chen (78) and coordinate her family care.")
+        print("\nMargaret's Profile:")
+        print("• Age: 78")
+        print("• Conditions: Type 2 Diabetes, Hypertension, Mild Cognitive Impairment") 
+        print("• Medications: Metformin, Lisinopril, Donepezil")
+        print("• Family: David (son/primary), Lisa (daughter), Jennifer (daughter-in-law)")
+        
+        while True:
+            print(f"\n{'='*50}")
+            print("Choose a scenario to demonstrate:")
+            print("1. Normal Day - Everything Going Well")
+            print("2. Medication Compliance Issues")
+            print("3. Multi-Family Coordination")
+            print("4. Show Complete Daily Summary")
+            print("5. Exit demo")
+            
+            try:
+                choice = input("\nEnter choice (1-5): ").strip()
+                
+                if choice == "1":
+                    result = self.run_normal_day_scenario()
+                    input("\nPress Enter to continue...")
+                
+                elif choice == "2":
+                    result = self.run_medication_issues_scenario()
+                    input("\nPress Enter to continue...")
+                
+                elif choice == "3":
+                    result = self.run_family_coordination_scenario()
+                    input("\nPress Enter to continue...")
+                
+                elif choice == "4":
+                    print("Running care analysis to generate summary...")
+                    result = self.care_system.run_daily_care_cycle("parent_001")
+                    self.show_daily_summary(result)
+                    input("\nPress Enter to continue...")
+                
+                elif choice == "5":
+                    break
+                
+                else:
+                    print("❌ Invalid choice. Please enter 1-5.")
+                    
+            except KeyboardInterrupt:
+                print("\n👋 Demo interrupted. Thanks for trying CareLoop!")
+                break
+            except Exception as e:
+                print(f"❌ Error: {e}")
+        
+        self.print_banner("DEMO COMPLETE")
+        print("🎯 Key Takeaways:")
+        print("• AI agents work 24/7 to monitor health patterns")
+        print("• Automated family communication reduces caregiver burden")
+        print("• Predictive analytics prevent emergencies before they happen")
+        print("• Personalized care coordination scales to any family size")
+        print("\n💡 CareLoop: Making family caregiving smarter, not harder.")
+
+def run_quick_demo():
+    """Run a quick non-interactive demo for presentations"""
+    demo = CareLoopDemo()
+    
+    print("🚀 CARELOOP QUICK DEMO")
+    print("=" * 40)
+    print("Running AI-powered care analysis for Margaret Chen...")
+    
+    # Quick run through key scenarios
+    result1 = demo.run_normal_day_scenario()
+    print("\nPress Enter for next scenario...")
+    input()
+    
+    result2 = demo.run_medication_issues_scenario()
+    print("\nPress Enter for next scenario...")
+    input()
+    
+    result3 = demo.run_family_coordination_scenario()
+    
+    print("\n🎯 DEMO SUMMARY:")
+    print("✅ Normal day: Routine monitoring and family updates")
+    print("⚠️  Medication issues: Proactive alerts and action items")
+    print("👨‍👩‍👧‍👦 Family coordination: Personalized communication for each member")
+    print("\n💡 Ready for production deployment!")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--quick":
+        run_quick_demo()
+    else:
+        demo = CareLoopDemo()
+        demo.run_interactive_demo()

gradio_app.py

@@ -0,0 +1,622 @@
+#!/usr/bin/env python3
+# gradio_app.py - Gradio interface for CareLoop
+
+import os
+import json
+import gradio as gr
+from datetime import datetime, timedelta
+from dataclasses import asdict
+from typing import Dict, List, Any, Optional
+import random
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+from openai import OpenAI
+from langchain_core.messages import HumanMessage, AIMessage
+
+# Import CareLoop components
+from careloop_main import (
+    MockDataGenerator, 
+    CareState, 
+    HealthMonitorAgent,
+    MedicationAgent,
+    FamilyCommunicationAgent,
+    ActionPlannerAgent,
+    AlertLevel
+)
+
+# Initialize the OpenAI client for Nebius API
+client = OpenAI(
+    base_url="https://api.studio.nebius.com/v1/",
+    api_key=os.environ.get("NEBIUS_API_KEY", "demo-key-for-hackathon")
+)
+
+class NebiusLLM:
+    """LLM wrapper for Nebius API"""
+    
+    def __init__(self, model_name="meta-llama/Meta-Llama-3.1-70B-Instruct"):
+        self.model_name = model_name
+        self.client = client
+        
+    def generate(self, prompt: str) -> str:
+        """Generate text using Nebius API"""
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                max_tokens=512,
+                temperature=0.6,
+                top_p=0.9,
+                extra_body={
+                    "top_k": 50
+                },
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Error calling Nebius API: {e}")
+            # Fall back to mock responses in case of API error
+            return self._generate_mock_response(prompt)
+    
+    def _generate_mock_response(self, prompt: str) -> str:
+        """Generate a mock response for demo purposes"""
+        if "health" in prompt.lower():
+            return "The patient's health metrics show stable vital signs with glucose levels within acceptable range."
+        elif "medication" in prompt.lower():
+            return "Medication compliance has been good this week with only one missed dose of evening medication."
+        elif "summary" in prompt.lower():
+            return "Overall, the patient is doing well with stable health metrics and good medication compliance."
+        else:
+            return "The care system is monitoring the patient's condition and no significant issues have been detected."
+
+class CareLoopSystem:
+    """CareLoop system with Nebius LLM integration"""
+    
+    def __init__(self):
+        self.mock_data = MockDataGenerator()
+        self.llm = NebiusLLM()
+        
+        # Initialize specialized agents
+        self.health_monitor = HealthMonitorAgent(self.llm)
+        self.medication_agent = MedicationAgent(self.llm)
+        self.family_communicator = FamilyCommunicationAgent(self.llm)
+        self.action_planner = ActionPlannerAgent(self.llm)
+        
+        # Store chat history for each parent
+        self.chat_history = {}
+        
+        # Generate historical data for timelines
+        self.historical_data = self._generate_historical_data()
+        
+        # Generate medication compliance data
+        self.medication_compliance = self._generate_medication_compliance()
+    
+    def _generate_historical_data(self) -> Dict[str, Dict[str, List]]:
+        """Generate 7 days of historical health data for each parent"""
+        data = {}
+        today = datetime.now()
+        
+        for parent_id, parent in self.mock_data.parents.items():
+            parent_data = {
+                "dates": [],
+                "blood_pressure_systolic": [],
+                "blood_pressure_diastolic": [],
+                "heart_rate": [],
+                "blood_glucose": [],
+                "weight": [],
+                "temperature": [],
+                "sleep_hours": []
+            }
+            
+            # Set default weight based on parent
+            if parent.name == "Margaret Chen":
+                base_weight = 145.0  # lbs
+            elif parent.name == "Robert Johnson":
+                base_weight = 175.0  # lbs
+            elif parent.name == "Elena Gonzalez":
+                base_weight = 130.0  # lbs
+            else:
+                base_weight = 150.0  # default weight
+            
+            # Generate data for the last 7 days
+            for i in range(7, 0, -1):
+                date = today - timedelta(days=i)
+                parent_data["dates"].append(date.strftime("%Y-%m-%d"))
+                
+                # Generate values based on parent's conditions
+                if "Diabetes" in parent.conditions:
+                    glucose_base = 130
+                    glucose_var = 30
+                else:
+                    glucose_base = 95
+                    glucose_var = 15
+                
+                if "Hypertension" in parent.conditions:
+                    bp_sys_base = 145
+                    bp_sys_var = 15
+                    bp_dia_base = 90
+                    bp_dia_var = 10
+                else:
+                    bp_sys_base = 125
+                    bp_sys_var = 10
+                    bp_dia_base = 80
+                    bp_dia_var = 5
+                
+                # Add some random variation to simulate real-world data
+                parent_data["blood_pressure_systolic"].append(bp_sys_base + random.randint(-bp_sys_var, bp_sys_var))
+                parent_data["blood_pressure_diastolic"].append(bp_dia_base + random.randint(-bp_dia_var, bp_dia_var))
+                parent_data["heart_rate"].append(75 + random.randint(-10, 10))
+                parent_data["blood_glucose"].append(glucose_base + random.randint(-glucose_var, glucose_var))
+                parent_data["weight"].append(base_weight + random.uniform(-0.5, 0.5))
+                parent_data["temperature"].append(round(98.2 + random.uniform(-0.5, 0.8), 1))
+                parent_data["sleep_hours"].append(round(6.5 + random.uniform(-1.5, 1.5), 1))
+            
+            data[parent_id] = parent_data
+        
+        return data
+    
+    def _generate_medication_compliance(self) -> Dict[str, Dict[str, List]]:
+        """Generate medication compliance data for each parent"""
+        compliance = {}
+        
+        for parent_id, parent in self.mock_data.parents.items():
+            parent_compliance = {}
+            
+            for med in parent.medications:
+                med_name = med["name"]
+                med_compliance = []
+                
+                # Generate 7 days of compliance data
+                for _ in range(7):
+                    # 85% chance of taking medication
+                    took_med = random.random() < 0.85
+                    med_compliance.append(took_med)
+                
+                parent_compliance[med_name] = med_compliance
+            
+            compliance[parent_id] = parent_compliance
+        
+        return compliance
+    
+    def run_care_check(self, parent_id: str) -> Dict[str, Any]:
+        """Run a full care check for a specific parent"""
+        # Validate parent_id exists
+        if parent_id not in self.mock_data.parents:
+            raise ValueError(f"Parent ID {parent_id} not found")
+        
+        # Initialize state
+        state = CareState(
+            parent_id=parent_id,
+            date=datetime.now().strftime("%Y-%m-%d"),
+            health_metrics=[],
+            medication_status=[],
+            concerns=[],
+            alerts=[],
+            daily_summary="",
+            action_items=[],
+            family_notifications=[],
+            emergency_level="normal"
+        )
+        
+        # Run the analysis pipeline manually since we're not using langgraph here
+        state = self.health_monitor.analyze_health_patterns(state)
+        state = self.medication_agent.check_medication_compliance(state)
+        
+        # Check for emergency
+        urgent_alerts = [a for a in state["alerts"] if a["severity"] == AlertLevel.URGENT.value]
+        state["emergency_level"] = "urgent" if urgent_alerts else "normal"
+        
+        # Generate daily summary
+        state = self.family_communicator.create_daily_summary(state)
+        
+        # Generate family notifications
+        state = self.family_communicator.generate_family_updates(state)
+        
+        # Generate action items
+        state = self.action_planner.generate_action_items(state)
+        
+        # Add timestamp
+        result = dict(state)
+        result["processed_at"] = datetime.now().isoformat()
+        result["next_check"] = (datetime.now() + timedelta(hours=24)).isoformat()
+        
+        return result
+
+    def get_parent_info(self, parent_id: str) -> Dict[str, Any]:
+        """Get information about a specific parent"""
+        parent = self.mock_data.get_parent_by_id(parent_id)
+        family = self.mock_data.get_family_by_parent_id(parent_id)
+        
+        if not parent:
+            return {"error": f"Parent ID {parent_id} not found"}
+        
+        return {
+            "parent": asdict(parent),
+            "family": [asdict(fm) for fm in family]
+        }
+    
+    def get_health_timeline(self, parent_id: str) -> Dict[str, Any]:
+        """Get historical health data for a specific parent"""
+        if parent_id not in self.historical_data:
+            return {"error": f"No historical data for parent ID {parent_id}"}
+        
+        return self.historical_data[parent_id]
+    
+    def get_medication_compliance(self, parent_id: str) -> Dict[str, Any]:
+        """Get medication compliance data for a specific parent"""
+        if parent_id not in self.medication_compliance:
+            return {"error": f"No medication data for parent ID {parent_id}"}
+        
+        return self.medication_compliance[parent_id]
+    
+    def chat_with_system(self, parent_id: str, message: str) -> str:
+        """Chat with the CareLoop system about a specific parent"""
+        if parent_id not in self.chat_history:
+            self.chat_history[parent_id] = []
+        
+        self.chat_history[parent_id].append({"role": "user", "content": message})
+        
+        # Generate context about the parent
+        parent = self.mock_data.get_parent_by_id(parent_id)
+        if not parent:
+            response = "I couldn't find information about this parent."
+            self.chat_history[parent_id].append({"role": "assistant", "content": response})
+            return response
+        
+        # Create a prompt for the LLM
+        prompt = f"""
+        You are CareLoop, an AI assistant for family caregivers. 
+        
+        Parent information:
+        - Name: {parent.name}
+        - Age: {parent.age}
+        - Health conditions: {', '.join(parent.conditions)}
+        - Medications: {', '.join(med['name'] for med in parent.medications)}
+        
+        The caregiver has asked: {message}
+        
+        Provide a helpful, compassionate response focused on elderly care.
+        """
+        
+        # Get response from LLM
+        response = self.llm.generate(prompt)
+        self.chat_history[parent_id].append({"role": "assistant", "content": response})
+        
+        return response
+    
+    def get_chat_history(self, parent_id: str) -> List[Dict[str, str]]:
+        """Get chat history for a specific parent"""
+        return self.chat_history.get(parent_id, [])
+
+# Initialize the CareLoop system
+care_system = CareLoopSystem()
+
+def format_markdown_report(report: Dict[str, Any]) -> str:
+    """Format the care report as markdown for Gradio display"""
+    if not report:
+        return ""
+    
+    md = []
+    md.append(f"# {report['daily_summary']}")
+    
+    md.append("\n## Action Items")
+    for item in report["action_items"]:
+        md.append(f"- {item}")
+    
+    md.append("\n## Family Notifications")
+    for notif in report["family_notifications"]:
+        md.append(f"**To: {notif['recipient']}** ({notif['urgency']} priority)")
+        md.append(f"```\n{notif['message']}\n```")
+    
+    if report["alerts"]:
+        md.append("\n## Alerts")
+        for alert in report["alerts"]:
+            md.append(f"- **{alert['severity'].upper()}**: {alert['message']}")
+            md.append(f"  - *Recommended Action:* {alert['recommended_action']}")
+    
+    return "\n".join(md)
+
+def format_parent_info(parent_info: Dict[str, Any]) -> str:
+    """Format parent info as markdown for Gradio display"""
+    if not parent_info or "error" in parent_info:
+        return "No parent information available"
+    
+    parent = parent_info["parent"]
+    family = parent_info["family"]
+    
+    md = []
+    md.append(f"# {parent['name']} ({parent['age']})")
+    
+    md.append("\n## Health Conditions")
+    for condition in parent["conditions"]:
+        md.append(f"- {condition}")
+    
+    md.append("\n## Medications")
+    for med in parent["medications"]:
+        times = ", ".join(med["times"])
+        md.append(f"- {med['name']} ({med['dosage']}) - {med['frequency']} at {times}")
+    
+    md.append("\n## Family Caregivers")
+    for member in family:
+        md.append(f"- {member['name']} ({member['relationship']}) - {member['role']}")
+        md.append(f"  - Contact: {member['phone']} | {member['email']}")
+    
+    return "\n".join(md)
+
+def run_care_check(parent_id: str) -> tuple:
+    """Run care check and return formatted results"""
+    try:
+        # Get parent info
+        parent_info = care_system.get_parent_info(parent_id)
+        parent_md = format_parent_info(parent_info)
+        
+        # Run care check
+        report = care_system.run_care_check(parent_id)
+        report_md = format_markdown_report(report)
+        
+        # Create metrics display
+        health_metrics = len(report["health_metrics"])
+        medication_events = len(report["medication_status"])
+        alerts = len(report["alerts"])
+        actions = len(report["action_items"])
+        notifications = len(report["family_notifications"])
+        
+        # Get health timeline data
+        timeline_data = care_system.get_health_timeline(parent_id)
+        timeline_plot = create_health_timeline_plot(timeline_data)
+        
+        # Get medication compliance data
+        compliance_data = care_system.get_medication_compliance(parent_id)
+        compliance_plot = create_medication_compliance_plot(compliance_data)
+        
+        return parent_md, report_md, health_metrics, medication_events, alerts, actions, notifications, timeline_plot, compliance_plot
+    except Exception as e:
+        return f"Error: {str(e)}", "", 0, 0, 0, 0, 0, None, None
+
+def create_health_timeline_plot(timeline_data: Dict[str, List]) -> gr.Plot:
+    """Create a plot of health metrics over time"""
+    if "error" in timeline_data:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.text(0.5, 0.5, "No timeline data available", ha='center', va='center')
+        return fig
+    
+    # Create a figure with multiple subplots
+    fig, axs = plt.subplots(3, 1, figsize=(10, 10), sharex=True)
+    fig.suptitle("Health Metrics Over Time", fontsize=16)
+    
+    # Plot blood pressure and heart rate
+    ax1 = axs[0]
+    dates = timeline_data["dates"]
+    ax1.plot(dates, timeline_data["blood_pressure_systolic"], 'r-', label='Systolic BP')
+    ax1.plot(dates, timeline_data["blood_pressure_diastolic"], 'b-', label='Diastolic BP')
+    ax1.set_ylabel('Blood Pressure (mmHg)')
+    ax1.grid(True)
+    ax1.legend(loc='upper left')
+    
+    # Add heart rate on secondary y-axis
+    ax1_hr = ax1.twinx()
+    ax1_hr.plot(dates, timeline_data["heart_rate"], 'g-', label='Heart Rate')
+    ax1_hr.set_ylabel('Heart Rate (bpm)')
+    ax1_hr.legend(loc='upper right')
+    
+    # Plot blood glucose
+    ax2 = axs[1]
+    ax2.plot(dates, timeline_data["blood_glucose"], 'm-', label='Blood Glucose')
+    ax2.set_ylabel('Blood Glucose (mg/dL)')
+    ax2.grid(True)
+    ax2.legend()
+    
+    # Plot weight and temperature
+    ax3 = axs[2]
+    ax3.plot(dates, timeline_data["weight"], 'k-', label='Weight')
+    ax3.set_xlabel('Date')
+    ax3.set_ylabel('Weight (lbs)')
+    ax3.grid(True)
+    ax3.legend(loc='upper left')
+    
+    # Add temperature on secondary y-axis
+    ax3_temp = ax3.twinx()
+    ax3_temp.plot(dates, timeline_data["temperature"], 'c-', label='Temperature')
+    ax3_temp.set_ylabel('Temperature (°F)')
+    ax3_temp.legend(loc='upper right')
+    
+    plt.tight_layout()
+    return fig
+
+def create_medication_compliance_plot(compliance_data: Dict[str, List]) -> gr.Plot:
+    """Create a plot of medication compliance"""
+    if "error" in compliance_data:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.text(0.5, 0.5, "No medication compliance data available", ha='center', va='center')
+        return fig
+    
+    # Create a figure
+    fig, ax = plt.subplots(figsize=(10, 6))
+    fig.suptitle("7-Day Medication Compliance", fontsize=16)
+    
+    # Set up data
+    medications = list(compliance_data.keys())
+    dates = [f"Day {i+1}" for i in range(7)]
+    
+    # Create a matrix of compliance data
+    compliance_matrix = np.zeros((len(medications), 7))
+    for i, med in enumerate(medications):
+        for j in range(7):
+            compliance_matrix[i, j] = 1 if compliance_data[med][j] else 0
+    
+    # Create heatmap
+    im = ax.imshow(compliance_matrix, cmap='RdYlGn', aspect='auto', vmin=0, vmax=1)
+    
+    # Configure axes
+    ax.set_xticks(np.arange(len(dates)))
+    ax.set_yticks(np.arange(len(medications)))
+    ax.set_xticklabels(dates)
+    ax.set_yticklabels(medications)
+    
+    # Add text annotations
+    for i in range(len(medications)):
+        for j in range(len(dates)):
+            text = "✓" if compliance_matrix[i, j] == 1 else "✗"
+            color = "black" if compliance_matrix[i, j] == 1 else "white"
+            ax.text(j, i, text, ha="center", va="center", color=color, fontweight="bold")
+    
+    ax.set_xlabel("Day")
+    ax.set_title("✓ = Taken, ✗ = Missed")
+    plt.tight_layout()
+    
+    return fig
+
+# Create Gradio interface
+with gr.Blocks(title="CareLoop AI - Family Caregiving Platform", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🏠 CareLoop - AI-Powered Family Caregiving")
+    gr.Markdown("Select a parent and run a care check to see AI analysis of their health and care needs.")
+    
+    # Store parent_id as a state variable
+    current_parent_id = gr.State("parent_001")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            parent_dropdown = gr.Dropdown(
+                choices=[
+                    "Margaret Chen (78) - Diabetes/Hypertension",
+                    "Robert Johnson (72) - Stroke Recovery",
+                    "Elena Gonzalez (81) - Early Alzheimer's"
+                ],
+                value="Margaret Chen (78) - Diabetes/Hypertension",
+                label="Select Parent"
+            )
+            
+            run_button = gr.Button("🔄 Run Care Check", variant="primary")
+            
+            with gr.Accordion("About CareLoop", open=False):
+                gr.Markdown("""
+                ## About CareLoop
+                
+                CareLoop is an AI-powered platform that helps families care for elderly relatives by:
+                
+                - Monitoring health metrics and medication compliance
+                - Generating personalized care insights and recommendations
+                - Coordinating communication between family caregivers
+                - Detecting potential health issues early
+                
+                This demo showcases how AI can transform elderly care by analyzing complex health data
+                and generating actionable insights for family caregivers.
+                """)
+        
+        with gr.Column(scale=2):
+            with gr.Tabs():
+                with gr.Tab("Care Analysis"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            parent_info = gr.Markdown("Select a parent to view their information")
+                        
+                        with gr.Column(scale=2):
+                            care_report = gr.Markdown("Run a care check to see the AI analysis")
+                
+                with gr.Tab("Health Timeline"):
+                    timeline_plot = gr.Plot(label="Health Metrics Over Time")
+                
+                with gr.Tab("Medication Tracker"):
+                    compliance_plot = gr.Plot(label="Medication Compliance")
+                
+                with gr.Tab("Care Metrics"):
+                    with gr.Row():
+                        metric1 = gr.Number(label="Health Data Points", value=0)
+                        metric2 = gr.Number(label="Medication Events", value=0)
+                        metric3 = gr.Number(label="Alerts Generated", value=0)
+                        metric4 = gr.Number(label="Action Items", value=0)
+                        metric5 = gr.Number(label="Family Notifications", value=0)
+                
+                with gr.Tab("Care Assistant"):
+                    chatbot = gr.Chatbot(label="Chat with CareLoop")
+                    msg = gr.Textbox(
+                        placeholder="Ask a question about the patient's care...",
+                        show_label=False
+                    )
+                    clear = gr.Button("Clear")
+    
+    # Set up the event handlers
+    parent_map = {
+        "Margaret Chen (78) - Diabetes/Hypertension": "parent_001",
+        "Robert Johnson (72) - Stroke Recovery": "parent_002",
+        "Elena Gonzalez (81) - Early Alzheimer's": "parent_003"
+    }
+    
+    def get_parent_id(display_name):
+        return parent_map.get(display_name, "parent_001")
+    
+    def update_parent_id(display_name):
+        parent_id = get_parent_id(display_name)
+        return parent_id
+    
+    parent_dropdown.change(
+        fn=update_parent_id,
+        inputs=[parent_dropdown],
+        outputs=[current_parent_id]
+    )
+    
+    run_button.click(
+        fn=lambda p_id: run_care_check(p_id),
+        inputs=[current_parent_id],
+        outputs=[parent_info, care_report, metric1, metric2, metric3, metric4, metric5, timeline_plot, compliance_plot]
+    )
+    
+    # Also update parent info when dropdown changes
+    parent_dropdown.change(
+        fn=lambda p_id: (format_parent_info(care_system.get_parent_info(p_id)), "", 0, 0, 0, 0, 0, 
+                         create_health_timeline_plot(care_system.get_health_timeline(p_id)),
+                         create_medication_compliance_plot(care_system.get_medication_compliance(p_id))),
+        inputs=[current_parent_id],
+        outputs=[parent_info, care_report, metric1, metric2, metric3, metric4, metric5, timeline_plot, compliance_plot]
+    )
+    
+    # Chat functionality - modified to avoid Gradio version compatibility issues
+    def submit_message(p_id, message, history):
+        if not message or message.strip() == "":
+            return "", history
+        response = care_system.chat_with_system(p_id, message)
+        new_history = history + [[message, response]]
+        return "", new_history
+    
+    def clear_chat():
+        return []
+    
+    msg.submit(
+        fn=submit_message,
+        inputs=[current_parent_id, msg, chatbot],
+        outputs=[msg, chatbot]
+    )
+    
+    clear.click(fn=clear_chat, inputs=[], outputs=[chatbot])
+
+if __name__ == "__main__":
+    print("🚀 Starting CareLoop Gradio Interface")
+    print("=" * 50)
+    
+    # Display available parents
+    mock_data = MockDataGenerator()
+    print("🏠 Available Parent Profiles:")
+    for parent_id, parent in mock_data.parents.items():
+        family_count = len(mock_data.families.get(parent_id, []))
+        conditions = ", ".join(parent.conditions[:2]) + ("..." if len(parent.conditions) > 2 else "")
+        print(f"  • {parent.name} ({parent.age}) - ID: {parent_id}")
+        print(f"    Health: {conditions}")
+        print(f"    Family caregivers: {family_count}")
+    
+    print("\n" + "=" * 50)
+    print("💡 Note: Using Nebius API for LLM. Set NEBIUS_API_KEY environment variable for production use.")
+    print("=" * 50)
+    
+    # Launch the Gradio app
+    try:
+        # Launch with standard options for Gradio 4.16.0
+        demo.launch(share=False, show_error=True) 
+    except Exception as e:
+        print(f"Error launching Gradio app: {e}")
+        print("\nTrying alternative launch method...")
+        try:
+            # Alternative launch approach with minimal options
+            demo.queue(False).launch(share=False)
+        except Exception as e2:
+            print(f"Alternative launch also failed: {e2}")
+            print("\nPlease try updating Gradio with: pip install --upgrade gradio") 

requirements-space.txt

@@ -0,0 +1,10 @@
+gradio==4.16.0
+langchain==0.1.17
+langgraph==0.0.27
+langchain-openai==0.1.7
+langchain-core>=0.1.48,<0.2.0
+pandas==2.2.2
+numpy==1.26.4
+matplotlib==3.8.2
+openai==1.84.0
+python-dateutil==2.9.0