Code

.env.example

@@ -0,0 +1,49 @@
+# GlycoAI Environment Configuration
+# Copy this file to .env and fill in your actual values
+
+# ===========================================
+# REQUIRED CONFIGURATION
+# ===========================================
+
+# Mistral AI API Key (Required)
+MISTRAL_API_KEY=your_mistral_api_key_here
+
+# Mistral AI Agent ID (Optional but recommended)
+MISTRAL_AGENT_ID=your_mistral_agent_id_here
+
+# ===========================================
+# OPTIONAL CONFIGURATION
+# ===========================================
+
+# Application Environment (development/production)
+ENVIRONMENT=development
+
+# Debug Mode (true/false)
+DEBUG=false
+
+# Log Level (DEBUG/INFO/WARNING/ERROR)
+LOG_LEVEL=INFO
+
+# ===========================================
+# SETUP INSTRUCTIONS
+# ===========================================
+
+# For Local Development:
+# 1. Copy this file: cp .env.example .env
+# 2. Get your Mistral API key from: https://console.mistral.ai/
+# 3. Replace "your_mistral_api_key_here" with your actual key
+# 4. Optionally add your agent ID if you have one
+
+# For Hugging Face Spaces:
+# 1. Go to your Space settings
+# 2. Navigate to "Repository secrets"
+# 3. Add MISTRAL_API_KEY with your actual key
+# 4. Optionally add MISTRAL_AGENT_ID
+
+# ===========================================
+# SECURITY NOTES
+# ===========================================
+# - Never commit the .env file to git
+# - Keep your API keys secure
+# - Use different keys for development and production
+# - Monitor your API usage and costs

.gitignore

@@ -0,0 +1,290 @@
+# GlycoAI .gitignore
+# Security and cleanliness for the repository
+
+# ===========================================
+# SECURITY - NEVER COMMIT THESE!
+# ===========================================
+
+# Environment files with secrets
+.env
+.env.local
+.env.development
+.env.test
+.env.production
+
+# API Keys and credentials
+**/api_keys.py
+**/secrets.py
+**/credentials.json
+**/*_key.txt
+**/*_secret.txt
+
+# Configuration files with secrets
+config_local.py
+local_config.py
+
+# ===========================================
+# PYTHON
+# ===========================================
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# ===========================================
+# GRADIO
+# ===========================================
+
+# Gradio cache
+gradio_cached_examples/
+*.db
+
+# Gradio logs
+gradio.log
+
+# ===========================================
+# IDE / EDITORS
+# ===========================================
+
+# VSCode
+.vscode/
+*.code-workspace
+
+# PyCharm
+.idea/
+
+# Sublime Text
+*.sublime-project
+*.sublime-workspace
+
+# Vim
+*.swp
+*.swo
+*~
+
+# Emacs
+*~
+\#*\#
+.\#*
+
+# ===========================================
+# OPERATING SYSTEM
+# ===========================================
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# macOS Thumbnails
+._*
+
+# Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+*.stackdump
+[Dd]esktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+*.lnk
+
+# Linux
+*~
+
+# ===========================================
+# APPLICATION SPECIFIC
+# ===========================================
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# nyc test coverage
+.nyc_output
+
+# Temporary folders
+tmp/
+temp/
+
+# ===========================================
+# HUGGING FACE SPACES
+# ===========================================
+
+# HF Spaces specific (these are handled by the platform)
+# flagged/
+
+# ===========================================
+# DEMO DATA (if generated locally)
+# ===========================================
+
+# Local demo data files
+demo_data/
+test_data/
+sample_data/
+
+# ===========================================
+# BACKUP FILES
+# ===========================================
+
+*.bak
+*.backup
+*.old
+*.orig
+
+# ===========================================
+# MISCELLANEOUS
+# ===========================================
+
+# Node modules (if any JS dependencies)
+node_modules/
+
+# Package files
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Lock files
+package-lock.json
+yarn.lock

README copy.md

@@ -0,0 +1,229 @@
+---
+title: GlycoAI - AI Glucose Insights
+emoji: 🩺
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: main.py
+pinned: false
+license: mit
+tags:
+  - healthcare
+  - diabetes
+  - glucose
+  - ai-assistant
+  - medical
+  - gradio
+  - mistral
+  - agent-demo-track
+  - dexcom
+  - cgm
+---
+
+# 🩺 GlycoAI - AI-Powered Glucose Insights
+
+**An intelligent diabetes management assistant powered by Mistral AI and Dexcom CGM integration**
+
+[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/)
+[![Gradio](https://img.shields.io/badge/Gradio-4.44.0-orange)](https://gradio.app/)
+[![Mistral AI](https://img.shields.io/badge/Mistral%20AI-Agent-red)](https://mistral.ai/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 🌟 Overview
+
+GlycoAI is an advanced AI-powered chatbot that provides personalized glucose management insights for people with diabetes. By integrating Dexcom CGM data with Mistral AI's intelligent agents, it offers real-time analysis, pattern recognition, and actionable recommendations for better diabetes management.
+
+### ✨ Key Features
+
+- 📊 **14-Day Glucose Analysis**: Comprehensive pattern analysis across two weeks of data
+- 🤖 **AI-Powered Insights**: Mistral AI agent provides personalized recommendations  
+- 📈 **Interactive Visualizations**: Glucose trend charts and statistics
+- 👥 **Demo Users**: Pre-configured profiles for different diabetes scenarios
+- 💬 **Natural Conversations**: Chat naturally about your glucose patterns and concerns
+- 🎯 **Clinical Targets**: Track time-in-range, hypoglycemia, and variability metrics
+- 📱 **Multi-Device Support**: Works with G6, G7, and ONE+ CGM systems
+
+## 🚀 Try It Now
+
+**No setup required!** Simply:
+1. Select a demo user (Sarah, Marcus, Jennifer, or Robert)
+2. Load their 14-day glucose data 
+3. Start chatting with GlycoAI about patterns and recommendations
+
+## 🔬 Technical Implementation
+
+### AI Agent Architecture
+- **Mistral AI Agent**: Custom-trained agent specialized in diabetes management
+- **Context-Aware**: Incorporates real glucose data into conversations
+- **Pattern Recognition**: Identifies trends, meal effects, and lifestyle correlations
+- **Personalized Advice**: Tailored recommendations based on individual patterns
+
+### Data Processing Pipeline
+```
+Dexcom API → Data Validation → Pattern Analysis → AI Context → Chat Response
+```
+
+### Key Metrics Analyzed
+- **Time in Range (TIR)**: Target 70-180 mg/dL
+- **Glucose Variability**: Coefficient of variation
+- **Hypoglycemia Risk**: Time below 70 mg/dL  
+- **Hyperglycemia**: Time above 180 mg/dL
+- **Daily Patterns**: Dawn phenomenon, meal effects
+- **Weekly Trends**: Weekday vs weekend variations
+
+## 👥 Demo Users
+
+### 🏃‍♀️ Sarah Thompson (G7 Mobile)
+- **Profile**: 32-year-old professional with Type 1 diabetes
+- **Pattern**: Stable control with meal spikes
+- **Device**: Dexcom G7 with smartphone integration
+
+### 👨‍👧‍👦 Marcus Rodriguez (ONE+ Mobile) 
+- **Profile**: 45-year-old father with Type 2 diabetes
+- **Pattern**: Dawn phenomenon, moderate variability
+- **Device**: Dexcom ONE+ with lifestyle management focus
+
+### 🎓 Jennifer Chen (G6 Mobile)
+- **Profile**: 28-year-old graduate student with Type 1 diabetes  
+- **Pattern**: Exercise-related lows, tech-savvy user
+- **Device**: Dexcom G6 with active lifestyle
+
+### 👨‍🏫 Robert Williams (G6 Receiver)
+- **Profile**: 67-year-old retired teacher with Type 2 diabetes
+- **Pattern**: Consistent dawn phenomenon
+- **Device**: Dexcom G6 with dedicated receiver
+
+## 💡 Example Conversations
+
+**"What's my average glucose level?"**
+> Based on your 14-day data, your average glucose is 142 mg/dL with good stability. Your time in range is 68%, which is close to the clinical target of >70%. 📊
+
+**"I keep having morning highs. What can I do?"**
+> I notice you have dawn phenomenon with glucose rising 30-40 mg/dL between 4-7 AM. This affects 5 out of 14 mornings in your data. Consider discussing overnight insulin adjustments with your healthcare provider. 🌅
+
+**"How does my weekend compare to weekdays?"**
+> Interesting pattern! Your weekends show 15 mg/dL lower average glucose (135 vs 150 mg/dL weekdays). You seem to have more consistent meal timing on weekends. 📈
+
+## 🛠️ Technical Stack
+
+- **Frontend**: Gradio 4.44.0 with custom CSS styling
+- **Backend**: Python with FastAPI-style architecture  
+- **AI Engine**: Mistral AI agents with specialized diabetes knowledge
+- **Data Source**: Dexcom Sandbox API with realistic mock data
+- **Visualization**: Plotly for interactive glucose charts
+- **Processing**: Pandas/NumPy for statistical analysis
+
+## 📊 Data Analysis Features
+
+### Pattern Recognition
+- **Meal Effects**: Identifies post-meal glucose spikes and timing
+- **Exercise Impact**: Detects glucose drops during physical activity  
+- **Sleep Patterns**: Analyzes overnight glucose stability
+- **Stress Correlation**: Identifies high-glucose periods linked to lifestyle
+
+### Statistical Analysis  
+- **Glucose Management Indicator (GMI)**: HbA1c estimation
+- **Coefficient of Variation**: Glucose stability measurement
+- **Time-in-Range Analysis**: Clinical target tracking
+- **Trend Analysis**: Week-over-week improvement detection
+
+### Predictive Insights
+- **Risk Identification**: Predicts hypoglycemia patterns
+- **Optimization Suggestions**: Recommends timing adjustments
+- **Lifestyle Correlations**: Links patterns to daily activities
+- **Goal Tracking**: Monitors progress toward clinical targets
+
+## 🔒 Privacy & Security
+
+- **No Data Storage**: Conversations and glucose data are not permanently stored
+- **Sandbox Environment**: Uses Dexcom's secure sandbox API
+- **Educational Purpose**: Designed for demonstration and learning
+- **Medical Disclaimer**: Not intended to replace professional medical advice
+
+## ⚕️ Medical Disclaimer
+
+**Important**: GlycoAI is for educational and informational purposes only. It does not provide medical advice, diagnosis, or treatment. Always consult with qualified healthcare providers before making any changes to your diabetes management plan.
+
+## 🎯 Agent Demo Track
+
+This application showcases advanced AI agent capabilities for healthcare applications:
+
+- **Contextual Understanding**: Processes complex medical data
+- **Personalized Responses**: Adapts advice to individual patterns  
+- **Multi-Modal Analysis**: Combines numerical data with conversational AI
+- **Domain Expertise**: Specialized knowledge in diabetes management
+- **Real-Time Processing**: Instant analysis of glucose trends
+
+Perfect example of how AI agents can augment healthcare decision-making while maintaining appropriate clinical boundaries.
+
+## 🚀 Getting Started
+
+### Option 1: Use This Space (Recommended)
+Just click the demo above! No installation needed.
+
+### Option 2: Local Installation
+```bash
+git clone https://github.com/your-repo/glycoai
+cd glycoai
+pip install -r requirements.txt
+python main.py
+```
+
+### Option 3: API Integration
+```python
+from mistral_chat import GlucoBuddyMistralChat
+
+# Initialize with your Mistral API key
+chat = GlucoBuddyMistralChat("your-api-key", "your-agent-id")
+
+# Load demo user
+chat.load_user_data("sarah_g7")
+
+# Start chatting
+response = chat.chat_with_mistral("What's my time in range?")
+print(response['response'])
+```
+
+## 📈 Roadmap
+
+- [ ] **Real Dexcom Integration**: Connect to live CGM data
+- [ ] **Health data**: integration with Apple Health for obtaining further insights (e.g hormonal influence)
+- [ ] **Insulin Tracking**: Dosing recommendations and timing
+- [ ] **Healthcare Provider Dashboard**: Shareable reports
+- [ ] **Mobile App**: Native iOS/Android applications
+- [ ] **Multiple Languages**: Multilingual diabetes support
+
+## 🤝 Contributing
+
+We welcome contributions! Areas of interest:
+- **Medical Accuracy**: Improve clinical recommendations
+- **UI/UX Enhancement**: Better user experience design  
+- **Data Analysis**: Advanced pattern recognition algorithms
+- **Agent Training**: Enhance AI conversation quality
+- **Integration**: Additional CGM device support
+
+## 📞 Support
+
+- **Documentation**: [Full Documentation](https://github.com/your-repo/glycoai/wiki)
+- **Issues**: [GitHub Issues](https://github.com/your-repo/glycoai/issues)
+- **Discussions**: [Community Forum](https://github.com/your-repo/glycoai/discussions)
+
+
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+---
+
+<div align="center">
+
+**Built with ❤️ for the diabetes community**
+
+*Empowering better glucose management through AI*
+
+[![Follow on HF](https://img.shields.io/badge/Follow%20on-Hugging%20Face-yellow)](https://huggingface.co/spaces/)
+[![Star on GitHub](https://img.shields.io/badge/Star%20on-GitHub-black)](https://github.com/your-repo/glycoai)
+
+</div>

apifunctions.py

@@ -0,0 +1,499 @@
+#!/usr/bin/env python3
+"""
+Dexcom Client for glucose data analysis - RESTORED WORKING VERSION
+This restores the original working API code before unified data manager
+"""
+
+import json
+import logging
+import sys
+from typing import Any, Dict, List, Optional, Union
+from datetime import datetime, timedelta
+import pandas as pd
+from dataclasses import asdict
+
+"""
+Dexcom API Integration Functions
+This module contains all the functions for interacting with the Dexcom Sandbox API
+and processing glucose data for AI insights.
+"""
+
+import requests
+import json
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import pandas as pd
+from dataclasses import dataclass
+import logging
+import base64
+import secrets
+import hashlib
+import requests
+from typing import Dict, List, Optional
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class DemoUser:
+    """Demo user configuration for sandbox testing"""
+    name: str
+    device_type: str
+    username: str
+    password: str
+    description: str
+    age: int = 30
+    diabetes_type: str = "Type 1"
+    years_with_diabetes: int = 5
+    typical_glucose_pattern: str = "normal"
+
+# Demo users - EXACTLY as they were when it was working
+DEMO_USERS = {
+    "sarah_g7": DemoUser(
+        name="Sarah Thompson",
+        age=32,
+        device_type="G7 Mobile App",
+        username="[email protected]",
+        password="Dexcom123!",
+        description="Active professional with Type 1 diabetes, uses G7 CGM with smartphone integration",
+        diabetes_type="Type 1",
+        years_with_diabetes=8,
+        typical_glucose_pattern="stable_with_meal_spikes"
+    ),
+    "marcus_one": DemoUser(
+        name="Marcus Rodriguez",
+        age=45,
+        device_type="ONE+ Mobile App",
+        username="[email protected]",
+        password="Dexcom123!",
+        description="Father of two with Type 2 diabetes, manages with Dexcom ONE+ and lifestyle changes",
+        diabetes_type="Type 2",
+        years_with_diabetes=3,
+        typical_glucose_pattern="moderate_variability"
+    ),
+    "jennifer_g6": DemoUser(
+        name="Jennifer Chen",
+        age=28,
+        device_type="G6 Mobile App",
+        username="[email protected]",
+        password="Dexcom123!",
+        description="Graduate student with Type 1 diabetes, tech-savvy G6 user with active lifestyle",
+        diabetes_type="Type 1",
+        years_with_diabetes=12,
+        typical_glucose_pattern="exercise_related_lows"
+    ),
+    "robert_receiver": DemoUser(
+        name="Robert Williams",
+        age=67,
+        device_type="G6 Touchscreen Receiver",
+        username="[email protected]",
+        password="Dexcom123!",
+        description="Retired teacher with Type 2 diabetes, prefers dedicated receiver device",
+        diabetes_type="Type 2",
+        years_with_diabetes=15,
+        typical_glucose_pattern="dawn_phenomenon"
+    )
+}
+
+# Dexcom API Configuration - ORIGINAL WORKING VERSION
+SANDBOX_BASE_URL = "https://sandbox-api.dexcom.com"
+CLIENT_ID = "mLElKHKRwRDVUrAOPBzktFGY7qkTc7Zm"
+CLIENT_SECRET = "HmFpgyVweuwKrQpf"
+REDIRECT_URI = "http://localhost:7860/callback"
+
+class DexcomAPI:
+    """Handles all Dexcom API interactions with proper OAuth flow - ORIGINAL WORKING VERSION"""
+
+    def __init__(self):
+        self.base_url = SANDBOX_BASE_URL
+        self.access_token = None
+        self.refresh_token = None
+        self.token_expires_at = None
+
+    def get_authorization_url(self, state: str = None) -> str:
+        """Generate the OAuth authorization URL for user login"""
+        params = {
+            "client_id": CLIENT_ID,
+            "redirect_uri": REDIRECT_URI,
+            "response_type": "code",
+            "scope": "offline_access"
+        }
+        if state:
+            params["state"] = state
+
+        query_string = "&".join([f"{k}={v}" for k, v in params.items()])
+        return f"{self.base_url}/v2/oauth2/login?{query_string}"
+
+    def exchange_code_for_token(self, authorization_code: str) -> Dict:
+        """Exchange authorization code for access and refresh tokens"""
+        url = f"{self.base_url}/v2/oauth2/token"
+
+        data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "code": authorization_code,
+            "grant_type": "authorization_code",
+            "redirect_uri": REDIRECT_URI
+        }
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        try:
+            response = requests.post(url, data=data, headers=headers)
+            response.raise_for_status()
+
+            token_data = response.json()
+            self.access_token = token_data.get("access_token")
+            self.refresh_token = token_data.get("refresh_token")
+
+            expires_in = token_data.get("expires_in", 3600)
+            self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+
+            return token_data
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to exchange authorization code: {str(e)}")
+
+    def simulate_demo_login(self, demo_user_key: str) -> str:
+        """Simulate OAuth flow for demo users using sandbox credentials - ORIGINAL WORKING VERSION"""
+        if demo_user_key not in DEMO_USERS:
+            raise ValueError(f"Invalid demo user: {demo_user_key}")
+
+        user = DEMO_USERS[demo_user_key]
+
+        try:
+            auth_code = self._simulate_sandbox_login(user.username, user.password)
+
+            if auth_code:
+                token_data = self.exchange_code_for_token(auth_code)
+                logger.info(f"Successfully obtained tokens for {user.name}")
+                return self.access_token
+            else:
+                return self._direct_sandbox_token_request(user.username, user.password)
+
+        except Exception as e:
+            logger.warning(f"OAuth flow failed, trying direct sandbox authentication: {e}")
+            return self._direct_sandbox_token_request(user.username, user.password)
+
+    def _simulate_sandbox_login(self, username: str, password: str) -> Optional[str]:
+        """Simulate the sandbox login process to get authorization code"""
+        try:
+            auth_string = f"{username}:{password}:{datetime.now().strftime('%Y%m%d')}"
+            auth_code = base64.b64encode(auth_string.encode()).decode()[:32]
+            return auth_code
+
+        except Exception as e:
+            logger.error(f"Failed to simulate sandbox login: {e}")
+            return None
+
+    def _direct_sandbox_token_request(self, username: str, password: str) -> str:
+        """Direct token request for sandbox environment"""
+        url = f"{self.base_url}/v2/oauth2/token"
+        credentials = base64.b64encode(f"{CLIENT_ID}:{CLIENT_SECRET}".encode()).decode()
+
+        headers = {
+            "Authorization": f"Basic {credentials}",
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        data = {
+            "grant_type": "password",
+            "username": username,
+            "password": password,
+            "scope": "offline_access"
+        }
+
+        try:
+            response = requests.post(url, data=data, headers=headers)
+
+            if response.status_code == 200:
+                token_data = response.json()
+                self.access_token = token_data.get("access_token")
+                self.refresh_token = token_data.get("refresh_token")
+
+                expires_in = token_data.get("expires_in", 3600)
+                self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+
+                logger.info(f"Successfully obtained sandbox token for {username}")
+                return self.access_token
+            else:
+                sandbox_token = self._generate_sandbox_demo_token(username)
+                self.access_token = sandbox_token
+                self.token_expires_at = datetime.now() + timedelta(hours=1)
+
+                logger.info(f"Using demo token for sandbox user {username}")
+                return sandbox_token
+
+        except Exception as e:
+            logger.error(f"Direct token request failed: {e}")
+            sandbox_token = self._generate_sandbox_demo_token(username)
+            self.access_token = sandbox_token
+            self.token_expires_at = datetime.now() + timedelta(hours=1)
+            return sandbox_token
+
+    def _generate_sandbox_demo_token(self, username: str) -> str:
+        """Generate a realistic-looking demo token for sandbox"""
+        token_data = f"{username}:{datetime.now().strftime('%Y%m%d')}:{CLIENT_ID}"
+        token_hash = hashlib.sha256(token_data.encode()).hexdigest()
+        return f"sandbox_token_{token_hash[:16]}"
+
+    def _is_token_expired(self) -> bool:
+        """Check if the current token is expired"""
+        if not self.token_expires_at:
+            return True
+        return datetime.now() >= self.token_expires_at
+
+    def _ensure_valid_token(self):
+        """Ensure we have a valid, non-expired token"""
+        if not self.access_token or self._is_token_expired():
+            if self.refresh_token:
+                try:
+                    self.refresh_access_token()
+                except:
+                    raise Exception("Token expired and refresh failed. Please re-authenticate.")
+            else:
+                raise Exception("No valid token available. Please authenticate first.")
+
+    def refresh_access_token(self) -> Dict:
+        """Refresh the access token using refresh token"""
+        if not self.refresh_token:
+            raise Exception("No refresh token available")
+
+        url = f"{self.base_url}/v2/oauth2/token"
+
+        data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "refresh_token": self.refresh_token,
+            "grant_type": "refresh_token"
+        }
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        try:
+            response = requests.post(url, data=data, headers=headers)
+            response.raise_for_status()
+
+            token_data = response.json()
+            self.access_token = token_data.get("access_token")
+            if "refresh_token" in token_data:
+                self.refresh_token = token_data.get("refresh_token")
+
+            expires_in = token_data.get("expires_in", 3600)
+            self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+
+            return token_data
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Failed to refresh token: {str(e)}")
+
+    def get_data_range(self) -> Dict:
+        """Get the available data range for the authenticated user"""
+        self._ensure_valid_token()
+
+        url = f"{self.base_url}/v2/users/self/dataRange"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}"
+        }
+
+        try:
+            response = requests.get(url, headers=headers)
+
+            if response.status_code == 401:
+                if self.refresh_token:
+                    self.refresh_access_token()
+                    headers["Authorization"] = f"Bearer {self.access_token}"
+                    response = requests.get(url, headers=headers)
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {
+                    "egvStart": (datetime.now() - timedelta(days=30)).isoformat(),
+                    "egvEnd": datetime.now().isoformat(),
+                    "eventStart": (datetime.now() - timedelta(days=30)).isoformat(),
+                    "eventEnd": datetime.now().isoformat()
+                }
+
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Failed to get data range from API: {e}, using demo range")
+            return {
+                "egvStart": (datetime.now() - timedelta(days=30)).isoformat(),
+                "egvEnd": datetime.now().isoformat(),
+                "eventStart": (datetime.now() - timedelta(days=30)).isoformat(),
+                "eventEnd": datetime.now().isoformat()
+            }
+
+    def get_egv_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get Estimated Glucose Values (EGV) data - ORIGINAL WORKING VERSION"""
+        self._ensure_valid_token()
+
+        url = f"{self.base_url}/v2/users/self/egvs"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}"
+        }
+
+        params = {}
+        if start_date:
+            params["startDate"] = start_date
+        if end_date:
+            params["endDate"] = end_date
+
+        try:
+            response = requests.get(url, headers=headers, params=params)
+
+            if response.status_code == 401:
+                if self.refresh_token:
+                    self.refresh_access_token()
+                    headers["Authorization"] = f"Bearer {self.access_token}"
+                    response = requests.get(url, headers=headers, params=params)
+
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("egvs", [])
+            else:
+                logger.warning(f"API returned status {response.status_code}, generating demo data")
+                return []
+
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Failed to get EGV data from API: {e}, will use demo data")
+            return []
+
+    def get_events_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get events data (meals, insulin, etc.)"""
+        self._ensure_valid_token()
+
+        url = f"{self.base_url}/v2/users/self/events"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}"
+        }
+
+        params = {}
+        if start_date:
+            params["startDate"] = start_date
+        if end_date:
+            params["endDate"] = end_date
+
+        try:
+            response = requests.get(url, headers=headers, params=params)
+
+            if response.status_code == 401:
+                if self.refresh_token:
+                    self.refresh_access_token()
+                    headers["Authorization"] = f"Bearer {self.access_token}"
+                    response = requests.get(url, headers=headers, params=params)
+
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("events", [])
+            else:
+                logger.warning(f"Events API returned status {response.status_code}")
+                return []
+
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Failed to get events data: {e}")
+            return []
+
+class GlucoseAnalyzer:
+    """Analyzes glucose data and generates insights"""
+
+    @staticmethod
+    def process_egv_data(egv_data: List[Dict]) -> pd.DataFrame:
+        """Convert EGV data to pandas DataFrame for analysis"""
+        if not egv_data:
+            return pd.DataFrame()
+
+        df = pd.DataFrame(egv_data)
+        df['systemTime'] = pd.to_datetime(df['systemTime'])
+        df['displayTime'] = pd.to_datetime(df['displayTime'])
+
+        df['value'] = pd.to_numeric(df['value'], errors='coerce')
+
+        return df.sort_values('systemTime')
+
+    @staticmethod
+    def calculate_basic_stats(df: pd.DataFrame) -> Dict:
+        """Calculate basic glucose statistics"""
+        if df.empty:
+            return {}
+
+        glucose_values = df['value'].dropna()
+
+        return {
+            "average_glucose": glucose_values.mean(),
+            "min_glucose": glucose_values.min(),
+            "max_glucose": glucose_values.max(),
+            "std_glucose": glucose_values.std(),
+            "time_in_range_70_180": len(glucose_values[(glucose_values >= 70) & (glucose_values <= 180)]) / len(glucose_values) * 100,
+            "time_below_70": len(glucose_values[glucose_values < 70]) / len(glucose_values) * 100,
+            "time_above_180": len(glucose_values[glucose_values > 180]) / len(glucose_values) * 100,
+            "total_readings": len(glucose_values)
+        }
+
+    @staticmethod
+    def identify_patterns(df: pd.DataFrame) -> Dict:
+        """Identify glucose patterns and trends"""
+        if df.empty or len(df) < 10:
+            return {"patterns": "Insufficient data for pattern analysis"}
+
+        patterns = []
+
+        df['hour'] = df['systemTime'].dt.hour
+        hourly_avg = df.groupby('hour')['value'].mean()
+
+        peak_hour = hourly_avg.idxmax()
+        low_hour = hourly_avg.idxmin()
+
+        patterns.append(f"Glucose typically peaks around {peak_hour}:00")
+        patterns.append(f"Glucose is typically lowest around {low_hour}:00")
+
+        glucose_std = df['value'].std()
+        if glucose_std > 50:
+            patterns.append("High glucose variability detected - consider discussing with healthcare provider")
+        elif glucose_std < 20:
+            patterns.append("Good glucose stability observed")
+
+        recent_data = df.tail(20)
+        if len(recent_data) >= 10:
+            trend_slope = (recent_data['value'].iloc[-1] - recent_data['value'].iloc[0]) / len(recent_data)
+            if trend_slope > 2:
+                patterns.append("Recent upward glucose trend observed")
+            elif trend_slope < -2:
+                patterns.append("Recent downward glucose trend observed")
+            else:
+                patterns.append("Glucose levels relatively stable recently")
+
+        return {"patterns": patterns}
+
+def format_glucose_data_for_display(df: pd.DataFrame) -> str:
+    """Format glucose data for display in the interface"""
+    if df.empty:
+        return "No glucose data available"
+
+    recent_data = df.tail(10)
+
+    formatted_data = "## Recent Glucose Readings\n\n"
+    formatted_data += "| Time | Glucose (mg/dL) | Trend |\n"
+    formatted_data += "|------|-----------------|-------|\n"
+
+    for _, row in recent_data.iterrows():
+        time_str = row['displayTime'].strftime("%m/%d %H:%M")
+        glucose = row['value']
+        trend = row.get('trend', 'N/A')
+
+        trend_arrow = {
+            'flat': '→',
+            'fortyFiveUp': '↗',
+            'singleUp': '↑',
+            'doubleUp': '⬆',
+            'fortyFiveDown': '↘',
+            'singleDown': '↓',
+            'doubleDown': '⬇'
+        }.get(trend, '→')
+
+        formatted_data += f"| {time_str} | {glucose:.0f} | {trend_arrow} |\n"
+
+    return formatted_data

config.py

@@ -0,0 +1,326 @@
+"""
+GlucoBuddy Configuration File
+This file contains all configuration settings for the GlucoBuddy application,
+including Dexcom API credentials, Claude MCP settings, and application preferences.
+
+IMPORTANT: 
+- Replace placeholder values with your actual credentials
+- Never commit this file to version control with real credentials
+- Consider using environment variables for sensitive data in production
+"""
+
+import os
+from typing import Dict, Any
+
+# =============================================================================
+# DEXCOM API CONFIGURATION
+# =============================================================================
+
+# Dexcom Developer Portal Credentials
+# Get these from: https://developer.dexcom.com/
+DEXCOM_CONFIG = {
+    # REQUIRED: Replace with your actual Dexcom Developer Portal credentials
+    "CLIENT_ID": os.getenv("DEXCOM_CLIENT_ID", "your_client_id_here"),
+    "CLIENT_SECRET": os.getenv("DEXCOM_CLIENT_SECRET", "your_client_secret_here"),
+    
+    # OAuth Redirect URI - must match exactly what you registered in Developer Portal
+    "REDIRECT_URI": "http://localhost:7860/callback",
+    
+    # API Endpoints
+    "SANDBOX_BASE_URL": "https://sandbox-api.dexcom.com",
+    "PRODUCTION_BASE_URL": "https://api.dexcom.com",
+    
+    # Environment setting - set to False for production
+    "USE_SANDBOX": True,
+    
+    # OAuth Scopes
+    "SCOPES": ["offline_access"],
+    
+    # Token refresh settings
+    "TOKEN_REFRESH_BUFFER_MINUTES": 5,  # Refresh token 5 minutes before expiration
+    "MAX_RETRY_ATTEMPTS": 3,
+}
+
+# =============================================================================
+# CLAUDE MCP CONFIGURATION
+# =============================================================================
+
+# Claude API Configuration
+# Get your API key from: https://console.anthropic.com/
+CLAUDE_CONFIG = {
+    # REQUIRED: Replace with your actual Anthropic API key
+    "API_KEY": os.getenv("ANTHROPIC_API_KEY", "your_anthropic_api_key_here"),
+    
+    # Model selection
+    "MODEL": "claude-3-5-sonnet-20241022",  # Updated to latest model
+    
+    # Generation parameters
+    "MAX_TOKENS": 4000,
+    "TEMPERATURE": 0.3,  # Lower for more consistent medical advice
+    
+    # Timeout settings
+    "REQUEST_TIMEOUT": 60,  # seconds
+    "MAX_RETRIES": 2,
+    
+    # Content filtering
+    "ENABLE_SAFETY_FILTERS": True,
+}
+
+# =============================================================================
+# APPLICATION SETTINGS
+# =============================================================================
+
+# Logging Configuration
+LOGGING_CONFIG = {
+    "LEVEL": "INFO",  # DEBUG, INFO, WARNING, ERROR, CRITICAL
+    "FORMAT": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "LOG_FILE": "glucobuddy.log",
+    "MAX_LOG_SIZE_MB": 10,
+    "BACKUP_COUNT": 3,
+    "ENABLE_CONSOLE_LOGGING": True,
+    "ENABLE_FILE_LOGGING": True,
+}
+
+# Data Processing Settings
+DATA_CONFIG = {
+    # Default data range for analysis
+    "DEFAULT_DAYS_BACK": 7,
+    "MAX_DAYS_BACK": 30,
+    
+    # Glucose thresholds (mg/dL)
+    "TARGET_RANGE_LOW": 70,
+    "TARGET_RANGE_HIGH": 180,
+    "HYPOGLYCEMIA_THRESHOLD": 70,
+    "HYPERGLYCEMIA_THRESHOLD": 250,
+    
+    # Time in Range targets (percentages)
+    "EXCELLENT_TIR_THRESHOLD": 80,
+    "GOOD_TIR_THRESHOLD": 70,
+    "ACCEPTABLE_TIR_THRESHOLD": 50,
+    
+    # Data quality settings
+    "MIN_READINGS_FOR_ANALYSIS": 20,
+    "MAX_GAP_HOURS": 3,  # Maximum gap between readings for continuous analysis
+    
+    # Pattern detection settings
+    "PATTERN_DETECTION_MIN_DAYS": 3,
+    "SIGNIFICANT_TREND_THRESHOLD": 2.0,  # mg/dL per reading
+}
+
+# =============================================================================
+# DEMO USER CONFIGURATION
+# =============================================================================
+
+# Demo mode settings - for development and testing
+DEMO_CONFIG = {
+    "ENABLE_DEMO_MODE": True,
+    "DEFAULT_DEMO_USER": "sarah_g7",  # Which demo user to use by default
+    "GENERATE_SYNTHETIC_DATA": True,  # Generate realistic demo data when API fails
+    "DEMO_DATA_DAYS": 14,  # Days of demo data to generate
+    "DEMO_DATA_NOISE_FACTOR": 0.1,  # Randomness in demo data (0.0 to 1.0)
+}
+
+# =============================================================================
+# SECURITY SETTINGS
+# =============================================================================
+
+SECURITY_CONFIG = {
+    # Data encryption (for local storage)
+    "ENCRYPT_LOCAL_DATA": True,
+    "ENCRYPTION_KEY": os.getenv("GLUCOBUDDY_ENCRYPTION_KEY", None),
+    
+    # Session management
+    "SESSION_TIMEOUT_MINUTES": 30,
+    "REQUIRE_REAUTHENTICATION": True,
+    
+    # Data retention
+    "MAX_LOCAL_DATA_DAYS": 90,
+    "AUTO_CLEANUP_OLD_DATA": True,
+    
+    # Privacy settings
+    "ANONYMIZE_LOGS": True,
+    "ALLOW_TELEMETRY": False,
+}
+
+# =============================================================================
+# UI/UX CONFIGURATION
+# =============================================================================
+
+UI_CONFIG = {
+    # Display preferences
+    "DEFAULT_GLUCOSE_UNIT": "mg/dL",  # or "mmol/L"
+    "DATE_FORMAT": "%Y-%m-%d %H:%M",
+    "TIMEZONE": "local",  # or specific timezone like "US/Eastern"
+    
+    # Chart settings
+    "CHART_HEIGHT": 400,
+    "CHART_WIDTH": 800,
+    "SHOW_TARGET_RANGE": True,
+    "ENABLE_INTERACTIVE_CHARTS": True,
+    
+    # Notification settings
+    "ENABLE_DESKTOP_NOTIFICATIONS": True,
+    "ALERT_SOUND": True,
+    "NOTIFICATION_TIMEOUT": 5,  # seconds
+}
+
+# =============================================================================
+# INTEGRATION SETTINGS
+# =============================================================================
+
+# External service integrations
+INTEGRATION_CONFIG = {
+    # Health app integrations
+    "ENABLE_APPLE_HEALTH": False,
+    "ENABLE_GOOGLE_FIT": False,
+    
+    # Export formats
+    "SUPPORTED_EXPORT_FORMATS": ["CSV", "JSON", "PDF"],
+    "DEFAULT_EXPORT_FORMAT": "CSV",
+    
+    # Webhook settings (for advanced users)
+    "WEBHOOK_URL": None,
+    "WEBHOOK_SECRET": os.getenv("GLUCOBUDDY_WEBHOOK_SECRET", None),
+    "ENABLE_WEBHOOKS": False,
+}
+
+# =============================================================================
+# DEVELOPMENT SETTINGS
+# =============================================================================
+
+# Development and debugging options
+DEV_CONFIG = {
+    "DEBUG_MODE": False,
+    "ENABLE_API_MOCKING": False,  # Mock API calls for development
+    "VERBOSE_LOGGING": False,
+    "SAVE_RAW_API_RESPONSES": False,
+    "ENABLE_PERFORMANCE_MONITORING": False,
+    
+    # Testing settings
+    "RUN_TESTS_ON_STARTUP": False,
+    "TEST_DATA_PATH": "test_data/",
+}
+
+# =============================================================================
+# ENVIRONMENT-SPECIFIC OVERRIDES
+# =============================================================================
+
+# Override settings based on environment
+ENVIRONMENT = os.getenv("GLUCOBUDDY_ENV", "development").lower()
+
+if ENVIRONMENT == "production":
+    # Production overrides
+    DEXCOM_CONFIG["USE_SANDBOX"] = False
+    LOGGING_CONFIG["LEVEL"] = "WARNING"
+    DEMO_CONFIG["ENABLE_DEMO_MODE"] = False
+    DEV_CONFIG["DEBUG_MODE"] = False
+    SECURITY_CONFIG["REQUIRE_REAUTHENTICATION"] = True
+    
+elif ENVIRONMENT == "testing":
+    # Testing overrides
+    LOGGING_CONFIG["LEVEL"] = "DEBUG"
+    DEV_CONFIG["ENABLE_API_MOCKING"] = True
+    DEV_CONFIG["RUN_TESTS_ON_STARTUP"] = True
+    DEMO_CONFIG["ENABLE_DEMO_MODE"] = True
+
+# =============================================================================
+# CONFIGURATION VALIDATION
+# =============================================================================
+
+def validate_config() -> Dict[str, Any]:
+    """
+    Validate configuration settings and return validation results.
+    Returns a dictionary with validation status and any errors.
+    """
+    validation_results = {
+        "valid": True,
+        "errors": [],
+        "warnings": []
+    }
+    
+    # Check required Dexcom credentials
+    if DEXCOM_CONFIG["CLIENT_ID"] == "your_client_id_here":
+        validation_results["errors"].append("Dexcom CLIENT_ID not configured")
+        validation_results["valid"] = False
+    
+    if DEXCOM_CONFIG["CLIENT_SECRET"] == "your_client_secret_here":
+        validation_results["errors"].append("Dexcom CLIENT_SECRET not configured")
+        validation_results["valid"] = False
+    
+    # Check Claude API key
+    if CLAUDE_CONFIG["API_KEY"] == "your_anthropic_api_key_here":
+        validation_results["warnings"].append("Claude API key not configured - AI insights will be limited")
+    
+    # Validate glucose thresholds
+    if DATA_CONFIG["TARGET_RANGE_LOW"] >= DATA_CONFIG["TARGET_RANGE_HIGH"]:
+        validation_results["errors"].append("Invalid glucose target range")
+        validation_results["valid"] = False
+    
+    # Check encryption key for production
+    if ENVIRONMENT == "production" and SECURITY_CONFIG["ENCRYPT_LOCAL_DATA"]:
+        if not SECURITY_CONFIG["ENCRYPTION_KEY"]:
+            validation_results["warnings"].append("No encryption key set for production environment")
+    
+    return validation_results
+
+def get_active_config() -> Dict[str, Any]:
+    """
+    Get the complete active configuration as a dictionary.
+    Useful for debugging and configuration inspection.
+    """
+    return {
+        "dexcom": DEXCOM_CONFIG,
+        "claude": CLAUDE_CONFIG,
+        "logging": LOGGING_CONFIG,
+        "data": DATA_CONFIG,
+        "demo": DEMO_CONFIG,
+        "security": SECURITY_CONFIG,
+        "ui": UI_CONFIG,
+        "integration": INTEGRATION_CONFIG,
+        "development": DEV_CONFIG,
+        "environment": ENVIRONMENT
+    }
+
+# =============================================================================
+# CONFIGURATION HELPERS
+# =============================================================================
+
+def get_dexcom_base_url() -> str:
+    """Get the appropriate Dexcom API base URL based on environment."""
+    return (DEXCOM_CONFIG["SANDBOX_BASE_URL"] if DEXCOM_CONFIG["USE_SANDBOX"] 
+            else DEXCOM_CONFIG["PRODUCTION_BASE_URL"])
+
+def is_demo_mode_enabled() -> bool:
+    """Check if demo mode is enabled."""
+    return DEMO_CONFIG["ENABLE_DEMO_MODE"]
+
+def get_glucose_unit() -> str:
+    """Get the configured glucose unit."""
+    return UI_CONFIG["DEFAULT_GLUCOSE_UNIT"]
+
+# =============================================================================
+# STARTUP CONFIGURATION CHECK
+# =============================================================================
+
+if __name__ == "__main__":
+    print("GlucoBuddy Configuration Validation")
+    print("=" * 40)
+    
+    results = validate_config()
+    
+    if results["valid"]:
+        print("✅ Configuration is valid!")
+    else:
+        print("❌ Configuration has errors:")
+        for error in results["errors"]:
+            print(f"  - {error}")
+    
+    if results["warnings"]:
+        print("\n⚠️  Warnings:")
+        for warning in results["warnings"]:
+            print(f"  - {warning}")
+    
+    print(f"\nEnvironment: {ENVIRONMENT}")
+    print(f"Demo Mode: {'Enabled' if is_demo_mode_enabled() else 'Disabled'}")
+    print(f"Sandbox Mode: {'Enabled' if DEXCOM_CONFIG['USE_SANDBOX'] else 'Disabled'}")
+    print(f"Claude Integration: {'Enabled' if CLAUDE_CONFIG['API_KEY'] != 'your_anthropic_api_key_here' else 'Disabled'}")

config_management.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+Secure Configuration Management for GlycoAI
+Handles API keys and secrets safely for both local development and Hugging Face Spaces
+"""
+
+import os
+import logging
+from typing import Optional, Dict, Any
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SecureConfig:
+    """Secure configuration manager for API keys and secrets"""
+    
+    def __init__(self):
+        self.config = {}
+        self._load_configuration()
+    
+    def _load_configuration(self):
+        """Load configuration from environment variables"""
+        
+        # Mistral AI Configuration
+        self.mistral_api_key = self._get_secret(
+            "MISTRAL_API_KEY",
+            description="Mistral AI API Key"
+        )
+        
+        self.mistral_agent_id = self._get_secret(
+            "MISTRAL_AGENT_ID", 
+            description="Mistral AI Agent ID",
+            required=False
+        )
+        
+        # Dexcom API Configuration (for future real API integration)
+        self.dexcom_client_id = self._get_secret(
+            "DEXCOM_CLIENT_ID",
+            description="Dexcom API Client ID",
+            required=False
+        )
+        
+        self.dexcom_client_secret = self._get_secret(
+            "DEXCOM_CLIENT_SECRET",
+            description="Dexcom API Client Secret",
+            required=False
+        )
+        
+        # Application Configuration
+        self.app_environment = os.getenv("ENVIRONMENT", "development")
+        self.debug_mode = os.getenv("DEBUG", "false").lower() == "true"
+        self.log_level = os.getenv("LOG_LEVEL", "INFO")
+        
+        # Hugging Face Space Detection
+        self.is_huggingface_space = os.getenv("SPACE_ID") is not None
+        
+        logger.info(f"Configuration loaded for environment: {self.app_environment}")
+        logger.info(f"Running on Hugging Face Space: {self.is_huggingface_space}")
+    
+    def _get_secret(self, key: str, description: str = "", required: bool = True) -> Optional[str]:
+        """Safely get secret from environment variables"""
+        value = os.getenv(key)
+        
+        if value:
+            logger.info(f"✅ {description or key} loaded successfully")
+            return value
+        elif required:
+            logger.error(f"❌ Required secret {key} ({description}) not found!")
+            logger.error(f"Please set the {key} environment variable")
+            return None
+        else:
+            logger.warning(f"⚠️  Optional secret {key} ({description}) not set")
+            return None
+    
+    def validate_configuration(self) -> Dict[str, Any]:
+        """Validate that all required configuration is present"""
+        validation_result = {
+            "valid": True,
+            "errors": [],
+            "warnings": []
+        }
+        
+        # Check required secrets
+        if not self.mistral_api_key:
+            validation_result["valid"] = False
+            validation_result["errors"].append("MISTRAL_API_KEY is required")
+        
+        # Check optional but recommended secrets
+        if not self.mistral_agent_id:
+            validation_result["warnings"].append("MISTRAL_AGENT_ID not set - will use standard chat completion")
+        
+        # Environment-specific checks
+        if self.is_huggingface_space:
+            if not all([self.mistral_api_key]):
+                validation_result["errors"].append("Hugging Face Space requires MISTRAL_API_KEY in secrets")
+        
+        return validation_result
+    
+    def get_mistral_config(self) -> Dict[str, Optional[str]]:
+        """Get Mistral AI configuration"""
+        return {
+            "api_key": self.mistral_api_key,
+            "agent_id": self.mistral_agent_id
+        }
+    
+    def get_dexcom_config(self) -> Dict[str, Optional[str]]:
+        """Get Dexcom API configuration"""
+        return {
+            "client_id": self.dexcom_client_id,
+            "client_secret": self.dexcom_client_secret
+        }
+    
+    def is_development(self) -> bool:
+        """Check if running in development mode"""
+        return self.app_environment == "development"
+    
+    def is_production(self) -> bool:
+        """Check if running in production mode"""
+        return self.app_environment == "production"
+
+# Global configuration instance
+config = SecureConfig()
+
+def get_config() -> SecureConfig:
+    """Get the global configuration instance"""
+    return config
+
+def validate_environment():
+    """Validate environment configuration and provide helpful messages"""
+    print("🔍 Validating GlycoAI Configuration...")
+    print("=" * 50)
+    
+    validation = config.validate_configuration()
+    
+    if validation["valid"]:
+        print("✅ Configuration validation passed!")
+    else:
+        print("❌ Configuration validation failed!")
+        for error in validation["errors"]:
+            print(f"   ❌ {error}")
+    
+    if validation["warnings"]:
+        print("\n⚠️  Warnings:")
+        for warning in validation["warnings"]:
+            print(f"   ⚠️  {warning}")
+    
+    # Provide setup instructions
+    if not validation["valid"]:
+        print("\n📋 Setup Instructions:")
+        print("=" * 30)
+        
+        if config.is_huggingface_space:
+            print("🤗 For Hugging Face Spaces:")
+            print("1. Go to your Space settings")
+            print("2. Add Repository secrets:")
+            print("   - MISTRAL_API_KEY: your_mistral_api_key")
+            print("   - MISTRAL_AGENT_ID: your_agent_id (optional)")
+        else:
+            print("💻 For Local Development:")
+            print("1. Create a .env file in your project root:")
+            print("   MISTRAL_API_KEY=your_mistral_api_key")
+            print("   MISTRAL_AGENT_ID=your_agent_id")
+            print("2. Or set environment variables:")
+            print("   export MISTRAL_API_KEY=your_mistral_api_key")
+            print("   export MISTRAL_AGENT_ID=your_agent_id")
+    
+    return validation["valid"]
+
+if __name__ == "__main__":
+    validate_environment()

dexcom_real_auth_system.py

@@ -0,0 +1,501 @@
+#!/usr/bin/env python3
+"""
+Dexcom Real Authentication System
+Uses your actual CLIENT_ID and CLIENT_SECRET from developer.dexcom.com
+"""
+
+import requests
+import json
+import base64
+import secrets
+import hashlib
+import urllib.parse
+import webbrowser
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# 🔑 YOUR REAL DEXCOM CREDENTIALS (replace with your actual values)
+CLIENT_ID = "YOUR_REAL_CLIENT_ID_HERE"  # Replace with your actual client ID
+CLIENT_SECRET = "YOUR_REAL_CLIENT_SECRET_HERE"  # Replace with your actual client secret
+REDIRECT_URI = "http://localhost:8080/callback"
+
+# Dexcom API URLs
+SANDBOX_BASE_URL = "https://sandbox-api.dexcom.com"
+PRODUCTION_BASE_URL = "https://api.dexcom.com"
+
+class OAuth2CallbackHandler(BaseHTTPRequestHandler):
+    """HTTP handler for OAuth2 callback"""
+    
+    def do_GET(self):
+        """Handle GET request for OAuth callback"""
+        if self.path.startswith('/callback'):
+            # Parse the authorization code from the URL
+            parsed_url = urllib.parse.urlparse(self.path)
+            query_params = urllib.parse.parse_qs(parsed_url.query)
+            
+            if 'code' in query_params:
+                # Store the authorization code in the server
+                self.server.auth_code = query_params['code'][0]
+                self.server.auth_error = None
+                
+                # Send success response
+                self.send_response(200)
+                self.send_header('Content-type', 'text/html')
+                self.end_headers()
+                
+                success_html = """
+                <html>
+                <head><title>Dexcom Authorization Successful</title></head>
+                <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+                    <h2 style="color: green;">✅ Authorization Successful!</h2>
+                    <p>You have successfully authorized the application to access your Dexcom data.</p>
+                    <p>You can close this window and return to the application.</p>
+                    <script>
+                        setTimeout(function(){
+                            window.close();
+                        }, 3000);
+                    </script>
+                </body>
+                </html>
+                """
+                self.wfile.write(success_html.encode())
+                
+            elif 'error' in query_params:
+                # Handle authorization error
+                error = query_params.get('error', ['Unknown error'])[0]
+                error_description = query_params.get('error_description', [''])[0]
+                
+                self.server.auth_code = None
+                self.server.auth_error = f"{error}: {error_description}"
+                
+                self.send_response(400)
+                self.send_header('Content-type', 'text/html')
+                self.end_headers()
+                
+                error_html = f"""
+                <html>
+                <head><title>Dexcom Authorization Failed</title></head>
+                <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+                    <h2 style="color: red;">❌ Authorization Failed</h2>
+                    <p><strong>Error:</strong> {error}</p>
+                    <p><strong>Description:</strong> {error_description}</p>
+                    <p>Please try again or contact support if the problem persists.</p>
+                </body>
+                </html>
+                """
+                self.wfile.write(error_html.encode())
+            else:
+                # Unexpected callback
+                self.send_response(400)
+                self.send_header('Content-type', 'text/html')
+                self.end_headers()
+                self.wfile.write(b"<html><body><h2>Invalid callback</h2></body></html>")
+        else:
+            # 404 for other paths
+            self.send_response(404)
+            self.end_headers()
+    
+    def log_message(self, format, *args):
+        """Suppress default logging"""
+        pass
+
+class DexcomRealAPI:
+    """Real Dexcom API client using your actual credentials"""
+    
+    def __init__(self, client_id: str = CLIENT_ID, client_secret: str = CLIENT_SECRET, 
+                 environment: str = "sandbox"):
+        """
+        Initialize Dexcom API client
+        
+        Args:
+            client_id: Your real Dexcom client ID
+            client_secret: Your real Dexcom client secret  
+            environment: "sandbox" or "production"
+        """
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = REDIRECT_URI
+        
+        if environment == "sandbox":
+            self.base_url = SANDBOX_BASE_URL
+        else:
+            self.base_url = PRODUCTION_BASE_URL
+            
+        self.environment = environment
+        self.access_token = None
+        self.refresh_token = None
+        self.token_expires_at = None
+        
+        # Validate credentials
+        if not client_id or client_id == "YOUR_REAL_CLIENT_ID_HERE":
+            raise ValueError("Please set your real CLIENT_ID")
+        if not client_secret or client_secret == "YOUR_REAL_CLIENT_SECRET_HERE":
+            raise ValueError("Please set your real CLIENT_SECRET")
+    
+    def generate_auth_url(self, state: str = None) -> str:
+        """Generate OAuth authorization URL"""
+        if not state:
+            state = secrets.token_urlsafe(32)
+        
+        params = {
+            'client_id': self.client_id,
+            'redirect_uri': self.redirect_uri,
+            'response_type': 'code',
+            'scope': 'offline_access',
+            'state': state
+        }
+        
+        query_string = urllib.parse.urlencode(params)
+        auth_url = f"{self.base_url}/v2/oauth2/login?{query_string}"
+        
+        logger.info(f"Generated authorization URL for {self.environment} environment")
+        return auth_url
+    
+    def start_oauth_flow(self) -> bool:
+        """Start the complete OAuth flow with browser"""
+        print(f"\n🔐 Starting Dexcom OAuth Authentication")
+        print(f"🌐 Environment: {self.environment}")
+        print(f"🔑 Client ID: {self.client_id[:8]}...")
+        
+        try:
+            # Generate authorization URL
+            state = secrets.token_urlsafe(32)
+            auth_url = self.generate_auth_url(state)
+            
+            # Start local callback server
+            server = HTTPServer(('localhost', 8080), OAuth2CallbackHandler)
+            server.timeout = 120  # 2 minute timeout
+            server.auth_code = None
+            server.auth_error = None
+            
+            print(f"🌐 Opening browser for authorization...")
+            print(f"📋 URL: {auth_url}")
+            print(f"⏳ Waiting for authorization (timeout: 2 minutes)...")
+            
+            # Open browser
+            webbrowser.open(auth_url)
+            
+            # Wait for callback
+            start_time = time.time()
+            while time.time() - start_time < 120:  # 2 minute timeout
+                server.handle_request()
+                if server.auth_code or server.auth_error:
+                    break
+            
+            if server.auth_error:
+                print(f"❌ Authorization failed: {server.auth_error}")
+                return False
+            
+            if not server.auth_code:
+                print(f"❌ Authorization timeout - no response received")
+                return False
+            
+            print(f"✅ Authorization code received!")
+            
+            # Exchange code for tokens
+            success = self.exchange_code_for_tokens(server.auth_code)
+            
+            if success:
+                print(f"🎉 Authentication successful!")
+                print(f"📊 Access token obtained")
+                print(f"⏰ Token expires: {self.token_expires_at}")
+                return True
+            else:
+                print(f"❌ Token exchange failed")
+                return False
+                
+        except Exception as e:
+            logger.error(f"OAuth flow error: {e}")
+            print(f"❌ OAuth flow error: {e}")
+            return False
+    
+    def exchange_code_for_tokens(self, authorization_code: str) -> bool:
+        """Exchange authorization code for access and refresh tokens"""
+        url = f"{self.base_url}/v2/oauth2/token"
+        
+        data = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'code': authorization_code,
+            'grant_type': 'authorization_code',
+            'redirect_uri': self.redirect_uri
+        }
+        
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Accept': 'application/json'
+        }
+        
+        try:
+            logger.info("Exchanging authorization code for tokens...")
+            response = requests.post(url, data=data, headers=headers)
+            
+            logger.info(f"Token exchange response: {response.status_code}")
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                
+                self.access_token = token_data.get('access_token')
+                self.refresh_token = token_data.get('refresh_token')
+                
+                expires_in = token_data.get('expires_in', 3600)
+                self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+                
+                logger.info("Successfully obtained access and refresh tokens")
+                return True
+            else:
+                logger.error(f"Token exchange failed: {response.status_code} - {response.text}")
+                return False
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error during token exchange: {e}")
+            return False
+    
+    def refresh_access_token(self) -> bool:
+        """Refresh the access token using refresh token"""
+        if not self.refresh_token:
+            logger.error("No refresh token available")
+            return False
+        
+        url = f"{self.base_url}/v2/oauth2/token"
+        
+        data = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'refresh_token': self.refresh_token,
+            'grant_type': 'refresh_token'
+        }
+        
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Accept': 'application/json'
+        }
+        
+        try:
+            response = requests.post(url, data=data, headers=headers)
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                
+                self.access_token = token_data.get('access_token')
+                # Note: Some OAuth providers issue new refresh tokens
+                if 'refresh_token' in token_data:
+                    self.refresh_token = token_data.get('refresh_token')
+                
+                expires_in = token_data.get('expires_in', 3600)
+                self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+                
+                logger.info("Access token refreshed successfully")
+                return True
+            else:
+                logger.error(f"Token refresh failed: {response.status_code} - {response.text}")
+                return False
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error during token refresh: {e}")
+            return False
+    
+    def is_token_valid(self) -> bool:
+        """Check if current access token is valid and not expired"""
+        if not self.access_token:
+            return False
+        
+        if not self.token_expires_at:
+            return True  # Assume valid if no expiry set
+        
+        # Consider token expired if it expires within next 5 minutes
+        return datetime.now() < (self.token_expires_at - timedelta(minutes=5))
+    
+    def ensure_valid_token(self) -> bool:
+        """Ensure we have a valid access token, refresh if needed"""
+        if not self.is_token_valid():
+            logger.info("Token expired or invalid, attempting refresh...")
+            if self.refresh_token:
+                return self.refresh_access_token()
+            else:
+                logger.error("No refresh token available, re-authentication required")
+                return False
+        return True
+    
+    def get_auth_headers(self) -> Dict[str, str]:
+        """Get headers with valid authorization token"""
+        if not self.ensure_valid_token():
+            raise Exception("No valid access token available. Please authenticate first.")
+        
+        return {
+            'Authorization': f'Bearer {self.access_token}',
+            'Accept': 'application/json'
+        }
+    
+    def get_data_range(self) -> Dict:
+        """Get available data range for authenticated user"""
+        url = f"{self.base_url}/v2/users/self/dataRange"
+        headers = self.get_auth_headers()
+        
+        try:
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                logger.error(f"Data range API error: {response.status_code} - {response.text}")
+                raise Exception(f"Data range API error: {response.status_code}")
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error getting data range: {e}")
+            raise Exception(f"Network error getting data range: {e}")
+    
+    def get_egv_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get Estimated Glucose Values (EGV) data"""
+        url = f"{self.base_url}/v2/users/self/egvs"
+        headers = self.get_auth_headers()
+        
+        params = {}
+        if start_date:
+            params['startDate'] = start_date
+        if end_date:
+            params['endDate'] = end_date
+        
+        try:
+            response = requests.get(url, headers=headers, params=params)
+            
+            if response.status_code == 200:
+                data = response.json()
+                return data.get('egvs', [])
+            else:
+                logger.error(f"EGV API error: {response.status_code} - {response.text}")
+                raise Exception(f"EGV API error: {response.status_code}")
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error getting EGV data: {e}")
+            raise Exception(f"Network error getting EGV data: {e}")
+    
+    def get_events_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get events data (meals, insulin, etc.)"""
+        url = f"{self.base_url}/v2/users/self/events"
+        headers = self.get_auth_headers()
+        
+        params = {}
+        if start_date:
+            params['startDate'] = start_date
+        if end_date:
+            params['endDate'] = end_date
+        
+        try:
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code == 200:
+                data = response.json()
+                return data.get('events', [])
+            else:
+                logger.error(f"Events API error: {response.status_code} - {response.text}")
+                raise Exception(f"Events API error: {response.status_code}")
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error getting events data: {e}")
+            raise Exception(f"Network error getting events data: {e}")
+
+def test_real_dexcom_api():
+    """Test the real Dexcom API with your credentials"""
+    print("🧪 Testing Real Dexcom API Integration")
+    print("=" * 60)
+    
+    try:
+        # Initialize API with your real credentials
+        api = DexcomRealAPI(environment="sandbox")
+        
+        # Start OAuth authentication
+        print("\n🔐 Step 1: Authentication")
+        auth_success = api.start_oauth_flow()
+        
+        if not auth_success:
+            print("❌ Authentication failed - cannot proceed")
+            return False
+        
+        # Test data range
+        print("\n📅 Step 2: Getting Data Range")
+        try:
+            data_range = api.get_data_range()
+            print(f"✅ Data range retrieved:")
+            print(f"   EGV: {data_range.get('egvStart', 'N/A')} to {data_range.get('egvEnd', 'N/A')}")
+            print(f"   Events: {data_range.get('eventStart', 'N/A')} to {data_range.get('eventEnd', 'N/A')}")
+        except Exception as e:
+            print(f"❌ Data range error: {e}")
+        
+        # Test glucose data
+        print("\n📊 Step 3: Getting Glucose Data")
+        try:
+            # Get last 24 hours
+            end_time = datetime.now()
+            start_time = end_time - timedelta(hours=24)
+            
+            egv_data = api.get_egv_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            print(f"✅ Retrieved {len(egv_data)} glucose readings")
+            
+            if egv_data:
+                latest = egv_data[-1]
+                print(f"   Latest: {latest['value']} mg/dL at {latest['displayTime']}")
+                print(f"   Trend: {latest.get('trend', 'N/A')}")
+        except Exception as e:
+            print(f"❌ Glucose data error: {e}")
+        
+        # Test events data
+        print("\n🍽️ Step 4: Getting Events Data")
+        try:
+            events_data = api.get_events_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            print(f"✅ Retrieved {len(events_data)} events")
+            
+            if events_data:
+                carb_events = [e for e in events_data if e.get('eventType') == 'carbs']
+                insulin_events = [e for e in events_data if e.get('eventType') == 'insulin']
+                print(f"   Carb events: {len(carb_events)}")
+                print(f"   Insulin events: {len(insulin_events)}")
+        except Exception as e:
+            print(f"❌ Events data error: {e}")
+        
+        print(f"\n🎉 Real Dexcom API integration completed!")
+        return True
+        
+    except ValueError as e:
+        print(f"❌ Configuration error: {e}")
+        print(f"💡 Please update CLIENT_ID and CLIENT_SECRET with your real credentials")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🔑 Dexcom Real API Authentication System")
+    print("📋 Make sure to update CLIENT_ID and CLIENT_SECRET with your real values!")
+    print()
+    
+    # Run the test
+    test_real_dexcom_api()
+    
+    print(f"\n💡 Usage Example:")
+    print(f"   api = DexcomRealAPI(environment='sandbox')")
+    print(f"   api.start_oauth_flow()  # Opens browser for auth")
+    print(f"   glucose_data = api.get_egv_data()")
+    print(f"   events_data = api.get_events_data()")
+    
+    print(f"\n⚠️  Important Notes:")
+    print(f"   • This uses the real Dexcom sandbox environment")
+    print(f"   • You'll need to authenticate through the browser")
+    print(f"   • Sandbox users are provided by Dexcom (like SandboxUser7)")
+    print(f"   • Update environment='production' for real user data")

hybrid_auth.py

@@ -0,0 +1,648 @@
+#!/usr/bin/env python3
+"""
+Hybrid Dexcom Integration
+Combines demo users with optional real Dexcom authentication
+"""
+
+import os
+import gradio as gr
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+import pandas as pd
+import random
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class DemoUser:
+    """Enhanced demo user with auth type"""
+    name: str
+    device_type: str
+    username: str
+    password: str
+    description: str
+    age: int = 30
+    diabetes_type: str = "Type 1"
+    years_with_diabetes: int = 5
+    typical_glucose_pattern: str = "normal"
+    auth_type: str = "demo"  # "demo" or "real"
+    
+# Enhanced demo users + real auth option
+ENHANCED_DEMO_USERS = {
+    # Your existing 4 demo users (unchanged for easy demos)
+    "sarah_demo": DemoUser(
+        name="Sarah Thompson (Demo)",
+        age=32,
+        device_type="G7 Mobile App",
+        username="demo_sarah",
+        password="demo123",
+        description="Demo: Active professional with Type 1 diabetes, stable glucose control",
+        diabetes_type="Type 1",
+        years_with_diabetes=8,
+        typical_glucose_pattern="stable_with_meal_spikes",
+        auth_type="demo"
+    ),
+    "marcus_demo": DemoUser(
+        name="Marcus Rodriguez (Demo)",
+        age=45,
+        device_type="ONE+ Mobile App", 
+        username="demo_marcus",
+        password="demo123",
+        description="Demo: Father with Type 2 diabetes, moderate variability",
+        diabetes_type="Type 2",
+        years_with_diabetes=3,
+        typical_glucose_pattern="moderate_variability",
+        auth_type="demo"
+    ),
+    "jennifer_demo": DemoUser(
+        name="Jennifer Chen (Demo)",
+        age=28,
+        device_type="G6 Mobile App",
+        username="demo_jennifer",
+        password="demo123",
+        description="Demo: Graduate student with Type 1, athletic lifestyle",
+        diabetes_type="Type 1",
+        years_with_diabetes=12,
+        typical_glucose_pattern="exercise_related_lows",
+        auth_type="demo"
+    ),
+    "robert_demo": DemoUser(
+        name="Robert Williams (Demo)",
+        age=67,
+        device_type="G6 Touchscreen Receiver",
+        username="demo_robert",
+        password="demo123",
+        description="Demo: Retired teacher with Type 2, prefers receiver device",
+        diabetes_type="Type 2",
+        years_with_diabetes=15,
+        typical_glucose_pattern="dawn_phenomenon",
+        auth_type="demo"
+    ),
+    
+    # NEW: Real authentication option
+    "real_user": DemoUser(
+        name="Real Dexcom User",
+        age=0,  # Will be determined from real data
+        device_type="Real Dexcom Device",
+        username="real_dexcom_auth",
+        password="oauth_flow",
+        description="Authenticate with your real Dexcom account using OAuth",
+        diabetes_type="Real Data",
+        years_with_diabetes=0,
+        typical_glucose_pattern="real_data",
+        auth_type="real"
+    )
+}
+
+class HybridDexcomManager:
+    """Manages both demo and real Dexcom authentication"""
+    
+    def __init__(self):
+        self.demo_enabled = True
+        self.real_auth_enabled = self._check_real_auth_available()
+        self.current_mode = "demo"
+        
+        # Initialize real auth if available
+        if self.real_auth_enabled:
+            try:
+                from dexcom_real_auth_system import DexcomRealAPI
+                self.real_api = DexcomRealAPI(environment="sandbox")
+                logger.info("✅ Real Dexcom authentication available")
+            except ImportError:
+                logger.warning("⚠️ Real Dexcom auth not available - missing module")
+                self.real_auth_enabled = False
+            except Exception as e:
+                logger.warning(f"⚠️ Real Dexcom auth not available: {e}")
+                self.real_auth_enabled = False
+        
+        # Mock data generator for demo users
+        self.mock_generator = MockGlucoseGenerator()
+    
+    def _check_real_auth_available(self) -> bool:
+        """Check if real authentication is properly configured"""
+        client_id = os.getenv("DEXCOM_CLIENT_ID")
+        client_secret = os.getenv("DEXCOM_CLIENT_SECRET")
+        
+        # Also check for hardcoded values in the real auth system
+        try:
+            from dexcom_real_auth_system import CLIENT_ID, CLIENT_SECRET
+            if CLIENT_ID and CLIENT_ID != "YOUR_REAL_CLIENT_ID_HERE":
+                return True
+        except ImportError:
+            pass
+        
+        return bool(client_id and client_secret)
+    
+    def get_user_options(self) -> Dict[str, str]:
+        """Get available user options for the UI"""
+        options = {}
+        
+        # Add demo users
+        for key, user in ENHANCED_DEMO_USERS.items():
+            if user.auth_type == "demo":
+                options[key] = f"🎭 {user.name}"
+        
+        # Add real auth option if available
+        if self.real_auth_enabled:
+            options["real_user"] = "🔐 Real Dexcom User (OAuth)"
+        else:
+            options["real_user_disabled"] = "🔒 Real Dexcom User (Configure to Enable)"
+        
+        return options
+    
+    def authenticate_user(self, user_key: str) -> Dict[str, Any]:
+        """Authenticate user (demo or real)"""
+        if user_key not in ENHANCED_DEMO_USERS:
+            return {"success": False, "message": "Invalid user selection"}
+        
+        user = ENHANCED_DEMO_USERS[user_key]
+        
+        if user.auth_type == "demo":
+            return self._authenticate_demo_user(user_key, user)
+        elif user.auth_type == "real":
+            return self._authenticate_real_user()
+        else:
+            return {"success": False, "message": "Unknown authentication type"}
+    
+    def _authenticate_demo_user(self, user_key: str, user: DemoUser) -> Dict[str, Any]:
+        """Authenticate demo user (instant)"""
+        try:
+            # Generate mock data for demo user
+            mock_data = self.mock_generator.generate_user_data(user)
+            
+            return {
+                "success": True,
+                "message": f"✅ Demo user authenticated: {user.name}",
+                "user": user,
+                "data": mock_data,
+                "auth_type": "demo"
+            }
+        except Exception as e:
+            return {"success": False, "message": f"Demo authentication failed: {e}"}
+    
+    def _authenticate_real_user(self) -> Dict[str, Any]:
+        """Authenticate real Dexcom user"""
+        if not self.real_auth_enabled:
+            return {
+                "success": False, 
+                "message": "Real authentication not configured. Check DEXCOM_CLIENT_ID/SECRET"
+            }
+        
+        try:
+            # Start OAuth flow
+            auth_success = self.real_api.start_oauth_flow()
+            
+            if auth_success:
+                # Get real data
+                real_data = self._fetch_real_data()
+                
+                return {
+                    "success": True,
+                    "message": "✅ Real Dexcom user authenticated",
+                    "user": self._create_real_user_profile(),
+                    "data": real_data,
+                    "auth_type": "real"
+                }
+            else:
+                return {"success": False, "message": "OAuth authentication failed"}
+                
+        except Exception as e:
+            logger.error(f"Real authentication error: {e}")
+            return {"success": False, "message": f"Real authentication failed: {e}"}
+    
+    def _fetch_real_data(self) -> Dict[str, Any]:
+        """Fetch real data from Dexcom API"""
+        try:
+            # Get data range
+            data_range = self.real_api.get_data_range()
+            
+            # Get glucose data (last 14 days)
+            end_time = datetime.now()
+            start_time = end_time - timedelta(days=14)
+            
+            egv_data = self.real_api.get_egv_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            # Get events data
+            events_data = self.real_api.get_events_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            return {
+                "data_range": data_range,
+                "egv_data": egv_data,
+                "events_data": events_data,
+                "source": "real_dexcom_api"
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch real data: {e}")
+            return {"error": f"Failed to fetch real data: {e}"}
+    
+    def _create_real_user_profile(self) -> DemoUser:
+        """Create user profile from real data"""
+        return DemoUser(
+            name="Real Dexcom User",
+            age=0,  # Could extract from real user data if available
+            device_type="Real Dexcom Device",
+            username="authenticated_real_user",
+            password="oauth_token",
+            description="Authenticated real Dexcom user",
+            diabetes_type="From Real Data",
+            years_with_diabetes=0,
+            typical_glucose_pattern="real_data",
+            auth_type="real"
+        )
+
+class MockGlucoseGenerator:
+    """Enhanced mock glucose data generator"""
+    
+    def generate_user_data(self, user: DemoUser, days: int = 14) -> Dict[str, Any]:
+        """Generate mock data based on user profile"""
+        # Generate glucose readings
+        egv_data = self._generate_glucose_readings(user, days)
+        
+        # Generate events (meals, insulin)
+        events_data = self._generate_events_data(user, days)
+        
+        # Create data range
+        end_time = datetime.now()
+        start_time = end_time - timedelta(days=days)
+        
+        data_range = {
+            "egvStart": start_time.isoformat(),
+            "egvEnd": end_time.isoformat(),
+            "eventStart": start_time.isoformat(),
+            "eventEnd": end_time.isoformat()
+        }
+        
+        return {
+            "data_range": data_range,
+            "egv_data": egv_data,
+            "events_data": events_data,
+            "source": "mock_data"
+        }
+    
+    def _generate_glucose_readings(self, user: DemoUser, days: int) -> List[Dict]:
+        """Generate realistic glucose readings"""
+        import random
+        import numpy as np
+        
+        readings = []
+        start_time = datetime.now() - timedelta(days=days)
+        
+        # Base glucose level based on user pattern
+        base_glucose = {
+            "stable_with_meal_spikes": 120,
+            "moderate_variability": 140,
+            "exercise_related_lows": 115,
+            "dawn_phenomenon": 130
+        }.get(user.typical_glucose_pattern, 125)
+        
+        current_glucose = base_glucose
+        
+        # Generate readings every 5 minutes
+        for i in range(days * 288):  # 288 readings per day
+            timestamp = start_time + timedelta(minutes=i * 5)
+            hour = timestamp.hour
+            
+            # Apply user-specific patterns
+            target_glucose = self._calculate_target_glucose(user, hour, base_glucose)
+            
+            # Smooth glucose changes
+            change = (target_glucose - current_glucose) * 0.2
+            current_glucose += change + random.uniform(-5, 5)
+            current_glucose = max(60, min(300, current_glucose))
+            
+            # Determine trend
+            trend = self._calculate_trend(change)
+            
+            readings.append({
+                "systemTime": timestamp.isoformat() + "Z",
+                "displayTime": timestamp.isoformat() + "Z",
+                "value": round(current_glucose),
+                "trend": trend,
+                "realtimeValue": round(current_glucose),
+                "smoothedValue": round(current_glucose)
+            })
+        
+        return readings
+    
+    def _calculate_target_glucose(self, user: DemoUser, hour: int, base: float) -> float:
+        """Calculate target glucose based on user pattern and time"""
+        if user.typical_glucose_pattern == "dawn_phenomenon":
+            if 4 <= hour <= 8:
+                return base + 40  # Dawn phenomenon spike
+        elif user.typical_glucose_pattern == "exercise_related_lows":
+            if 17 <= hour <= 19:  # Evening exercise
+                return base - 30  # Exercise-induced low
+        elif user.typical_glucose_pattern == "moderate_variability":
+            return base + random.uniform(-20, 30)  # High variability
+        
+        # Standard meal patterns
+        if 7 <= hour <= 9:  # Breakfast
+            return base + random.uniform(20, 50)
+        elif 12 <= hour <= 14:  # Lunch
+            return base + random.uniform(25, 60)
+        elif 18 <= hour <= 20:  # Dinner
+            return base + random.uniform(30, 70)
+        else:
+            return base + random.uniform(-10, 15)
+    
+    def _calculate_trend(self, change: float) -> str:
+        """Calculate trend arrow"""
+        if change > 3:
+            return "singleUp"
+        elif change > 1:
+            return "fortyFiveUp"
+        elif change < -3:
+            return "singleDown"
+        elif change < -1:
+            return "fortyFiveDown"
+        else:
+            return "flat"
+    
+    def _generate_events_data(self, user: DemoUser, days: int) -> List[Dict]:
+        """Generate mock events (meals, insulin)"""
+        import random
+        
+        events = []
+        start_date = (datetime.now() - timedelta(days=days)).date()
+        
+        for day in range(days):
+            current_date = start_date + timedelta(days=day)
+            
+            # Generate daily meals and insulin
+            for meal_time, meal_name in [(7, "breakfast"), (12, "lunch"), (18, "dinner")]:
+                # Meal event
+                meal_dt = datetime.combine(current_date, datetime.min.time().replace(
+                    hour=meal_time, minute=random.randint(0, 30)
+                ))
+                
+                carbs = random.randint(30, 80)
+                events.append({
+                    "systemTime": meal_dt.isoformat() + "Z",
+                    "displayTime": meal_dt.isoformat() + "Z",
+                    "eventType": "carbs",
+                    "eventSubType": meal_name,
+                    "value": carbs,
+                    "unit": "grams"
+                })
+                
+                # Insulin event (if Type 1)
+                if user.diabetes_type == "Type 1":
+                    insulin_dt = meal_dt + timedelta(minutes=random.randint(5, 15))
+                    insulin_units = round(carbs / random.uniform(10, 15), 1)
+                    
+                    events.append({
+                        "systemTime": insulin_dt.isoformat() + "Z",
+                        "displayTime": insulin_dt.isoformat() + "Z",
+                        "eventType": "insulin",
+                        "eventSubType": "fast",
+                        "value": insulin_units,
+                        "unit": "units"
+                    })
+        
+        return events
+
+def create_hybrid_ui_components():
+    """Create UI components for hybrid demo"""
+    
+    # Initialize the hybrid manager
+    hybrid_manager = HybridDexcomManager()
+    user_options = hybrid_manager.get_user_options()
+    
+    # Create user selection buttons
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 👥 Select User Type")
+            gr.Markdown("Choose from demo users (instant) or authenticate with real Dexcom account")
+            
+            # Demo users row
+            with gr.Row():
+                demo_buttons = []
+                for key, user in ENHANCED_DEMO_USERS.items():
+                    if user.auth_type == "demo":
+                        btn = gr.Button(
+                            f"🎭 {user.name.split('(')[0].strip()}\n{user.device_type}",
+                            variant="secondary",
+                            size="lg"
+                        )
+                        demo_buttons.append((key, btn))
+            
+            # Real auth button
+            with gr.Row():
+                if hybrid_manager.real_auth_enabled:
+                    real_auth_btn = gr.Button(
+                        "🔐 REAL DEXCOM USER\n(OAuth Authentication)",
+                        variant="primary",
+                        size="lg"
+                    )
+                else:
+                    real_auth_btn = gr.Button(
+                        "🔒 Real Dexcom (Not Configured)\nSet DEXCOM_CLIENT_ID/SECRET",
+                        variant="secondary",
+                        size="lg",
+                        interactive=False
+                    )
+    
+    # Status displays
+    with gr.Row():
+        auth_status = gr.Textbox(
+            label="Authentication Status",
+            value="No user selected",
+            interactive=False
+        )
+    
+    with gr.Row():
+        config_status = gr.HTML(f"""
+        <div style="padding: 1rem; background: #f8f9fa; border-radius: 8px;">
+            <h4>🔧 Configuration Status</h4>
+            <p>
+                <strong>Demo Mode:</strong> {'✅ Available' if hybrid_manager.demo_enabled else '❌ Disabled'}<br>
+                <strong>Real Auth:</strong> {'✅ Configured' if hybrid_manager.real_auth_enabled else '❌ Not Configured'}<br>
+                <strong>Total Users:</strong> {len([u for u in ENHANCED_DEMO_USERS.values() if u.auth_type == 'demo'])} Demo + {'1 Real' if hybrid_manager.real_auth_enabled else '0 Real'}
+            </p>
+        </div>
+        """)
+    
+    return {
+        "hybrid_manager": hybrid_manager,
+        "demo_buttons": demo_buttons,
+        "real_auth_btn": real_auth_btn,
+        "auth_status": auth_status
+    }
+
+def setup_authentication_handlers(components):
+    """Setup event handlers for authentication"""
+    
+    def handle_demo_auth(user_key):
+        """Handle demo user authentication"""
+        result = components["hybrid_manager"].authenticate_user(user_key)
+        
+        if result["success"]:
+            return (
+                result["message"],
+                gr.update(visible=True),  # Show main interface
+                []  # Clear chat history
+            )
+        else:
+            return (
+                f"❌ {result['message']}",
+                gr.update(visible=False),
+                []
+            )
+    
+    def handle_real_auth():
+        """Handle real Dexcom authentication"""
+        result = components["hybrid_manager"].authenticate_user("real_user")
+        
+        if result["success"]:
+            return (
+                f"✅ {result['message']} - Browser will open for OAuth",
+                gr.update(visible=True),
+                []
+            )
+        else:
+            return (
+                f"❌ {result['message']}",
+                gr.update(visible=False),
+                []
+            )
+    
+    return handle_demo_auth, handle_real_auth
+
+# Integration with your existing main.py
+def integrate_with_existing_app():
+    """Integration guide for your existing application"""
+    
+    integration_code = '''
+# Add this to your main.py imports
+from hybrid_dexcom_integration import HybridDexcomManager, ENHANCED_DEMO_USERS
+
+class GlucoBuddyApp:
+    def __init__(self):
+        # Replace your existing initialization
+        self.hybrid_manager = HybridDexcomManager()
+        self.data_manager = UnifiedDataManager()
+        self.mistral_chat = GlucoBuddyMistralChat()
+        
+        # UI state
+        self.chat_history = []
+    
+    def select_user(self, user_key: str) -> Tuple[str, str]:
+        """Enhanced user selection with hybrid auth"""
+        try:
+            # Use hybrid authentication
+            auth_result = self.hybrid_manager.authenticate_user(user_key)
+            
+            if not auth_result['success']:
+                return f"❌ {auth_result['message']}", gr.update(visible=False)
+            
+            # Load data based on auth type
+            if auth_result['auth_type'] == 'demo':
+                # Use mock data
+                user = auth_result['user']
+                data = auth_result['data']
+                
+                # Convert to format expected by UnifiedDataManager
+                load_result = self.data_manager.load_mock_data(user, data)
+            else:
+                # Use real data
+                user = auth_result['user']
+                data = auth_result['data']
+                
+                # Convert to format expected by UnifiedDataManager
+                load_result = self.data_manager.load_real_data(user, data)
+            
+            if load_result['success']:
+                self._sync_chat_with_data_manager()
+                self.chat_history = []
+                self.mistral_chat.clear_conversation()
+                
+                return (
+                    f"Connected: {user.name} ({auth_result['auth_type'].upper()}) - Click 'Load Data' to begin",
+                    gr.update(visible=True)
+                )
+            else:
+                return f"❌ Data loading failed: {load_result['message']}", gr.update(visible=False)
+                
+        except Exception as e:
+            logger.error(f"User selection failed: {e}")
+            return f"❌ Selection failed: {e}", gr.update(visible=False)
+
+# Update your user buttons in create_interface()
+def create_enhanced_interface():
+    # Replace the user selection section with:
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 👥 Select User")
+            gr.Markdown("Choose demo users (instant) or real Dexcom authentication")
+            
+            # Demo users
+            with gr.Row():
+                sarah_btn = gr.Button("🎭 Sarah (Demo)\\nG7 Mobile", variant="secondary")
+                marcus_btn = gr.Button("🎭 Marcus (Demo)\\nONE+ Mobile", variant="secondary") 
+                jennifer_btn = gr.Button("🎭 Jennifer (Demo)\\nG6 Mobile", variant="secondary")
+                robert_btn = gr.Button("🎭 Robert (Demo)\\nG6 Receiver", variant="secondary")
+            
+            # Real auth
+            with gr.Row():
+                real_auth_btn = gr.Button(
+                    "🔐 REAL DEXCOM USER\\n(OAuth Authentication)",
+                    variant="primary",
+                    size="lg"
+                )
+    
+    # Connect handlers:
+    sarah_btn.click(lambda: app.select_user("sarah_demo"), outputs=[connection_status, main_interface, chatbot])
+    marcus_btn.click(lambda: app.select_user("marcus_demo"), outputs=[connection_status, main_interface, chatbot])
+    jennifer_btn.click(lambda: app.select_user("jennifer_demo"), outputs=[connection_status, main_interface, chatbot])
+    robert_btn.click(lambda: app.select_user("robert_demo"), outputs=[connection_status, main_interface, chatbot])
+    real_auth_btn.click(lambda: app.select_user("real_user"), outputs=[connection_status, main_interface, chatbot])
+    '''
+    
+    return integration_code
+
+if __name__ == "__main__":
+    print("🔧 Hybrid Dexcom Integration - Demo + Real Authentication")
+    print("=" * 60)
+    
+    # Test the hybrid manager
+    manager = HybridDexcomManager()
+    
+    print("📊 Configuration Status:")
+    print(f"  Demo Mode: {'✅' if manager.demo_enabled else '❌'}")
+    print(f"  Real Auth: {'✅' if manager.real_auth_enabled else '❌'}")
+    
+    print(f"\n👥 Available Users:")
+    for key, user in ENHANCED_DEMO_USERS.items():
+        auth_icon = "🎭" if user.auth_type == "demo" else "🔐"
+        available = "✅" if user.auth_type == "demo" or manager.real_auth_enabled else "❌"
+        print(f"  {available} {auth_icon} {user.name}")
+    
+    print(f"\n💡 Integration Guide:")
+    print("  1. Import: from hybrid_dexcom_integration import HybridDexcomManager")
+    print("  2. Replace user selection in your main.py")
+    print("  3. Update button handlers to use hybrid authentication")
+    print("  4. Your existing UnifiedDataManager works with both data types!")
+    
+    print(f"\n🚀 Benefits:")
+    print("  ✅ Keep all 4 demo users for easy demos")
+    print("  ✅ Add real authentication when needed")
+    print("  ✅ Seamless switching between demo and real")
+    print("  ✅ No changes needed to existing chat/UI logic")
+    print("  ✅ Progressive enhancement - works with/without real auth")

main.py

@@ -0,0 +1,779 @@
+"""
+GlycoAI - AI-Powered Glucose Insights
+Main Gradio application with prominent, centralized load data button
+"""
+
+import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta
+import pandas as pd
+from typing import Optional, Tuple, List
+import logging
+import os
+
+# Load environment variables from .env file
+from dotenv import load_dotenv
+load_dotenv()
+
+# Import the Mistral chat class and unified data manager
+from mistral_chat import GlucoBuddyMistralChat, validate_environment
+from unified_data_manager import UnifiedDataManager
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import our custom functions
+from apifunctions import (
+    DexcomAPI,
+    GlucoseAnalyzer,
+    DEMO_USERS,
+    format_glucose_data_for_display
+)
+
+class GlucoBuddyApp:
+    """Main application class for GlucoBuddy with unified data management"""
+
+    def __init__(self):
+        # Validate environment before initializing
+        if not validate_environment():
+            raise ValueError("Environment validation failed - check your .env file or environment variables")
+        
+        # Single data manager for consistency
+        self.data_manager = UnifiedDataManager()
+        
+        # Chat interface (will use data manager's context)
+        self.mistral_chat = GlucoBuddyMistralChat()
+        
+        # UI state
+        self.chat_history = []
+
+    def select_demo_user(self, user_key: str) -> Tuple[str, str]:
+        """Handle demo user selection and load data consistently"""
+        if user_key not in DEMO_USERS:
+            return "❌ Invalid user selection", gr.update(visible=False)
+
+        try:
+            # Load data through unified manager
+            load_result = self.data_manager.load_user_data(user_key)
+            
+            if not load_result['success']:
+                return f"❌ {load_result['message']}", gr.update(visible=False)
+            
+            user = self.data_manager.current_user
+            
+            # Update Mistral chat with the same context
+            self._sync_chat_with_data_manager()
+            
+            # Clear chat history when switching users
+            self.chat_history = []
+            self.mistral_chat.clear_conversation()
+
+            return (
+                f"Connected: {user.name} ({user.device_type}) - Click 'Load Data' to begin", 
+                gr.update(visible=True)
+            )
+
+        except Exception as e:
+            logger.error(f"User selection failed: {str(e)}")
+            return f"❌ Connection failed: {str(e)}", gr.update(visible=False)
+
+    def load_glucose_data(self) -> Tuple[str, go.Figure]:
+        """Load and display glucose data using unified manager"""
+        if not self.data_manager.current_user:
+            return "Please select a demo user first", None
+
+        try:
+            # Force reload data to ensure freshness
+            load_result = self.data_manager.load_user_data(
+                self._get_current_user_key(), 
+                force_reload=True
+            )
+            
+            if not load_result['success']:
+                return load_result['message'], None
+            
+            # Get unified stats
+            stats = self.data_manager.get_stats_for_ui()
+            chart_data = self.data_manager.get_chart_data()
+            
+            # Sync chat with fresh data
+            self._sync_chat_with_data_manager()
+            
+            if chart_data is None or chart_data.empty:
+                return "No glucose data available", None
+
+            # Build data summary with CONSISTENT metrics
+            user = self.data_manager.current_user
+            data_points = stats.get('total_readings', 0)
+            avg_glucose = stats.get('average_glucose', 0)
+            std_glucose = stats.get('std_glucose', 0)
+            min_glucose = stats.get('min_glucose', 0)
+            max_glucose = stats.get('max_glucose', 0)
+            
+            time_in_range = stats.get('time_in_range_70_180', 0)
+            time_below_range = stats.get('time_below_70', 0)
+            time_above_range = stats.get('time_above_180', 0)
+            
+            gmi = stats.get('gmi', 0)
+            cv = stats.get('cv', 0)
+            
+            # Calculate date range
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=14)
+
+            data_summary = f"""
+## 📊 Data Summary for {user.name}
+
+### Basic Information
+• **Analysis Period:** {start_date.strftime('%B %d, %Y')} to {end_date.strftime('%B %d, %Y')} (14 days)
+• **Total Readings:** {data_points:,} glucose measurements
+• **Device:** {user.device_type}
+• **Data Source:** {stats.get('data_source', 'unknown').upper()}
+
+### Glucose Statistics
+• **Average Glucose:** {avg_glucose:.1f} mg/dL
+• **Standard Deviation:** {std_glucose:.1f} mg/dL
+• **Coefficient of Variation:** {cv:.1f}%
+• **Glucose Range:** {min_glucose:.0f} - {max_glucose:.0f} mg/dL
+• **GMI (Glucose Management Indicator):** {gmi:.1f}%
+
+### Time in Range Analysis
+• **Time in Range (70-180 mg/dL):** {time_in_range:.1f}%
+• **Time Below Range (<70 mg/dL):** {time_below_range:.1f}%
+• **Time Above Range (>180 mg/dL):** {time_above_range:.1f}%
+
+### Clinical Targets
+• **Target Time in Range:** >70% (Current: {time_in_range:.1f}%)
+• **Target Time Below Range:** <4% (Current: {time_below_range:.1f}%)
+• **Target CV:** <36% (Current: {cv:.1f}%)
+
+### Data Validation
+• **In Range Count:** {stats.get('in_range_count', 0)} readings
+• **Below Range Count:** {stats.get('below_range_count', 0)} readings
+• **Above Range Count:** {stats.get('above_range_count', 0)} readings
+• **Total Verified:** {stats.get('in_range_count', 0) + stats.get('below_range_count', 0) + stats.get('above_range_count', 0)} readings
+
+### 14-Day Analysis Benefits
+• **Enhanced Pattern Recognition:** Captures full weekly cycles and variations
+• **Improved Trend Analysis:** Identifies consistent patterns vs. one-time events
+• **Better Clinical Insights:** More reliable data for healthcare decisions
+• **AI Consistency:** Same data used for chat analysis and UI display
+            """
+
+            chart = self.create_glucose_chart()
+            
+            return data_summary, chart
+
+        except Exception as e:
+            logger.error(f"Failed to load glucose data: {str(e)}")
+            return f"Failed to load glucose data: {str(e)}", None
+
+    def _sync_chat_with_data_manager(self):
+        """Ensure chat uses the same data as the UI"""
+        try:
+            # Get context from unified data manager
+            context = self.data_manager.get_context_for_agent()
+            
+            # Update chat's internal data to match
+            if not context.get("error"):
+                self.mistral_chat.current_user = self.data_manager.current_user
+                self.mistral_chat.current_glucose_data = self.data_manager.processed_glucose_data
+                self.mistral_chat.current_stats = self.data_manager.calculated_stats
+                self.mistral_chat.current_patterns = self.data_manager.identified_patterns
+                
+                logger.info(f"Synced chat with data manager - TIR: {self.data_manager.calculated_stats.get('time_in_range_70_180', 0):.1f}%")
+            
+        except Exception as e:
+            logger.error(f"Failed to sync chat with data manager: {e}")
+
+    def _get_current_user_key(self) -> str:
+        """Get the current user key"""
+        if not self.data_manager.current_user:
+            return ""
+        
+        # Find the key for current user
+        for key, user in DEMO_USERS.items():
+            if user == self.data_manager.current_user:
+                return key
+        return ""
+
+    def get_template_prompts(self) -> List[str]:
+        """Get template prompts based on current user data"""
+        if not self.data_manager.current_user or not self.data_manager.calculated_stats:
+            return [
+                "What should I know about managing my diabetes?",
+                "How can I improve my glucose control?"
+            ]
+
+        stats = self.data_manager.calculated_stats
+        time_in_range = stats.get('time_in_range_70_180', 0)
+        time_below_70 = stats.get('time_below_70', 0)
+
+        templates = []
+
+        if time_in_range < 70:
+            templates.append(f"My time in range is {time_in_range:.1f}% which is below the 70% target. What specific strategies can help me improve it?")
+        else:
+            templates.append(f"My time in range is {time_in_range:.1f}% which meets the target. How can I maintain this level of control?")
+
+        if time_below_70 > 4:
+            templates.append(f"I'm experiencing {time_below_70:.1f}% time below 70 mg/dL. What can I do to prevent these low episodes?")
+        else:
+            templates.append("What are the best practices for preventing hypoglycemia in my situation?")
+
+        return templates
+
+    def chat_with_mistral(self, message: str, history: List) -> Tuple[str, List]:
+        """Handle chat interaction with Mistral using unified data"""
+        if not message.strip():
+            return "", history
+
+        if not self.data_manager.current_user:
+            response = "Please select a demo user first to get personalized insights about glucose data."
+            history.append([message, response])
+            return "", history
+
+        try:
+            # Ensure chat is synced with latest data
+            self._sync_chat_with_data_manager()
+            
+            # Send message to Mistral chat
+            result = self.mistral_chat.chat_with_mistral(message)
+            
+            if result['success']:
+                response = result['response']
+                
+                # Add data consistency note
+                validation = self.data_manager.validate_data_consistency()
+                if validation.get('valid'):
+                    data_age = validation.get('data_age_minutes', 0)
+                    if data_age > 10:  # Warn if data is old
+                        response += f"\n\n📊 *Note: Analysis based on data from {data_age} minutes ago. Reload data for most current insights.*"
+                
+                # Add context note if no user data was included
+                if not result.get('context_included', True):
+                    response += "\n\n💡 *For more personalized advice, make sure your glucose data is loaded.*"
+            else:
+                response = f"I apologize, but I encountered an error: {result.get('error', 'Unknown error')}. Please try again or rephrase your question."
+
+            history.append([message, response])
+            return "", history
+
+        except Exception as e:
+            logger.error(f"Chat error: {str(e)}")
+            error_response = f"I apologize, but I encountered an error while processing your question: {str(e)}. Please try rephrasing your question."
+            history.append([message, error_response])
+            return "", history
+
+    def use_template_prompt(self, template_text: str) -> str:
+        """Use a template prompt in the chat"""
+        return template_text
+
+    def clear_chat_history(self) -> List:
+        """Clear chat history"""
+        self.chat_history = []
+        self.mistral_chat.clear_conversation()
+        return []
+
+    def create_glucose_chart(self) -> Optional[go.Figure]:
+        """Create an interactive glucose chart using unified data"""
+        chart_data = self.data_manager.get_chart_data()
+        
+        if chart_data is None or chart_data.empty:
+            return None
+
+        fig = go.Figure()
+
+        # Color code based on glucose ranges
+        colors = []
+        for value in chart_data['value']:
+            if value < 70:
+                colors.append('#E74C3C')  # Red for low
+            elif value > 180:
+                colors.append('#F39C12')  # Orange for high
+            else:
+                colors.append('#27AE60')  # Green for in range
+
+        fig.add_trace(go.Scatter(
+            x=chart_data['systemTime'],
+            y=chart_data['value'],
+            mode='lines+markers',
+            name='Glucose',
+            line=dict(color='#2E86AB', width=2),
+            marker=dict(size=4, color=colors),
+            hovertemplate='<b>%{y} mg/dL</b><br>%{x}<extra></extra>'
+        ))
+
+        # Add target range shading
+        fig.add_hrect(
+            y0=70, y1=180,
+            fillcolor="rgba(39, 174, 96, 0.1)",
+            layer="below",
+            line_width=0,
+            annotation_text="Target Range",
+            annotation_position="top left"
+        )
+
+        # Add reference lines
+        fig.add_hline(y=70, line_dash="dash", line_color="#E67E22",
+                     annotation_text="Low (70 mg/dL)", annotation_position="right")
+        fig.add_hline(y=180, line_dash="dash", line_color="#E67E22",
+                     annotation_text="High (180 mg/dL)", annotation_position="right")
+        fig.add_hline(y=54, line_dash="dot", line_color="#E74C3C",
+                     annotation_text="Severe Low (54 mg/dL)", annotation_position="right")
+        fig.add_hline(y=250, line_dash="dot", line_color="#E74C3C",
+                     annotation_text="Severe High (250 mg/dL)", annotation_position="right")
+
+        # Get current stats for title
+        stats = self.data_manager.get_stats_for_ui()
+        tir = stats.get('time_in_range_70_180', 0)
+        
+        fig.update_layout(
+            title={
+                'text': f"14-Day Glucose Trends - {self.data_manager.current_user.name} (TIR: {tir:.1f}%)",
+                'x': 0.5,
+                'xanchor': 'center'
+            },
+            xaxis_title="Time",
+            yaxis_title="Glucose (mg/dL)",
+            hovermode='x unified',
+            height=500,
+            showlegend=False,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            font=dict(size=12),
+            margin=dict(l=60, r=60, t=80, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)')
+        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)')
+
+        return fig
+
+
+def create_interface():
+    """Create the Gradio interface with prominent, centralized load data button"""
+    app = GlucoBuddyApp()
+
+    custom_css = """
+    .main-header {
+        text-align: center;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 2rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+    }
+    .load-data-section {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        border-radius: 15px;
+        padding: 2rem;
+        margin: 1.5rem 0;
+        box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
+        backdrop-filter: blur(4px);
+        border: 1px solid rgba(255, 255, 255, 0.18);
+    }
+    .prominent-button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        border: none !important;
+        border-radius: 15px !important;
+        padding: 1.5rem 3rem !important;
+        font-size: 1.2rem !important;
+        font-weight: bold !important;
+        color: white !important;
+        box-shadow: 0 8px 32px rgba(102, 126, 234, 0.4) !important;
+        transition: all 0.3s ease !important;
+        min-height: 80px !important;
+        text-align: center !important;
+    }
+    .prominent-button:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 0 12px 40px rgba(102, 126, 234, 0.6) !important;
+    }
+    .data-status-card {
+        background: #f8f9fa;
+        border: 2px solid #e9ecef;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        text-align: center;
+        font-weight: 500;
+    }
+    .data-status-success {
+        border-color: #28a745;
+        background: #d4edda;
+        color: #155724;
+    }
+    .data-status-error {
+        border-color: #dc3545;
+        background: #f8d7da;
+        color: #721c24;
+    }
+    .user-card {
+        background: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 0.5rem;
+    }
+    .template-button {
+        margin: 0.25rem;
+        padding: 0.5rem;
+        font-size: 0.9rem;
+    }
+    .chat-container {
+        background: #f8f9fa;
+        border-radius: 10px;
+        padding: 1rem;
+    }
+    .section-divider {
+        height: 2px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 1px;
+        margin: 2rem 0;
+    }
+    """
+
+    with gr.Blocks(
+        title="GlycoAI - AI Glucose Insights",
+        theme=gr.themes.Soft(),
+        css=custom_css
+    ) as interface:
+
+        # Header
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div class="main-header">
+                    <div style="display: flex; align-items: center; justify-content: center; gap: 1rem;">
+                        <div style="width: 60px; height: 60px; background: white; border-radius: 50%; display: flex; align-items: center; justify-content: center;">
+                            <span style="color: #667eea; font-size: 24px; font-weight: bold;">🩺</span>
+                        </div>
+                        <div>
+                            <h1 style="margin: 0; font-size: 2.5rem; color: white;">GlycoAI</h1>
+                            <p style="margin: 0; font-size: 1.2rem; color: white; opacity: 0.9;">AI-Powered Glucose Chatbot</p>
+                        </div>
+                    </div>
+                    <p style="margin-top: 1rem; font-size: 1rem; color: white; opacity: 0.8;">
+                        Connect your Dexcom CGM data and chat with AI for personalized glucose insights
+                    </p>
+                </div>
+                """)
+
+        # User Selection Section
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 👥 Select Demo User")
+                gr.Markdown("Choose from our demo users to explore GlycoAI's chat capabilities")
+
+                with gr.Row():
+                    sarah_btn = gr.Button(
+                        "Sarah Thompson\n(G7 Mobile)",
+                        variant="secondary",
+                        size="lg"
+                    )
+                    marcus_btn = gr.Button(
+                        "Marcus Rodriguez\n(ONE+ Mobile)",
+                        variant="secondary",
+                        size="lg"
+                    )
+                    jennifer_btn = gr.Button(
+                        "Jennifer Chen\n(G6 Mobile)",
+                        variant="secondary",
+                        size="lg"
+                    )
+                    robert_btn = gr.Button(
+                        "Robert Williams\n(G6 Receiver)",
+                        variant="secondary",
+                        size="lg"
+                    )
+
+        # Connection Status
+        with gr.Row():
+            connection_status = gr.Textbox(
+                label="Current User",
+                value="No user selected",
+                interactive=False,
+                container=True
+            )
+
+        # Section Divider
+        gr.HTML('<div class="section-divider"></div>')
+
+        # PROMINENT CENTRALIZED DATA LOADING SECTION
+        with gr.Group(visible=False) as main_interface:
+            # PROMINENT LOAD BUTTON - Centered and Large
+            with gr.Row():
+                with gr.Column(scale=1):
+                    pass  # Left spacer
+                with gr.Column(scale=2):
+                    load_data_btn = gr.Button(
+                        "🚀 LOAD 14-DAY GLUCOSE DATA\n📈 Start Analysis & Enable AI Chat",
+                        elem_classes=["prominent-button"],
+                        size="lg"
+                    )
+                with gr.Column(scale=1):
+                    pass  # Right spacer
+
+            # Section Divider
+            gr.HTML('<div class="section-divider"></div>')
+
+            # Main Content Tabs
+            with gr.Tabs():
+
+                # Glucose Chart Tab
+                with gr.TabItem("📈 Glucose Chart"):
+                    with gr.Column():
+                        gr.Markdown("### 📊 Interactive 14-Day Glucose Analysis")
+                        gr.Markdown("*Load your data using the button above to see your comprehensive glucose trends*")
+                        
+                        glucose_chart = gr.Plot(
+                            label="Interactive 14-Day Glucose Trends",
+                            container=True
+                        )
+
+                # Chat Tab
+                with gr.TabItem("💬 Chat with AI"):
+                    with gr.Column(elem_classes=["chat-container"]):
+                        gr.Markdown("### 🤖 Chat with GlycoAI about your glucose data")
+                        gr.Markdown("*📊 Load your data using the button above to enable personalized AI insights*")
+                        
+                        # Template Prompts
+                        with gr.Row():
+                            with gr.Column():
+                                gr.Markdown("**💡 Quick Start Templates:**")
+                                with gr.Row():
+                                    template1_btn = gr.Button(
+                                        "🎯 Analyze My 14-Day Patterns",
+                                        variant="secondary",
+                                        size="sm",
+                                        elem_classes=["template-button"]
+                                    )
+                                    template2_btn = gr.Button(
+                                        "⚡ Improve My Control",
+                                        variant="secondary",
+                                        size="sm",
+                                        elem_classes=["template-button"]
+                                    )
+                                    template3_btn = gr.Button(
+                                        "🍽️ Meal Management Tips",
+                                        variant="secondary",
+                                        size="sm",
+                                        elem_classes=["template-button"]
+                                    )
+
+                        # Chat Interface
+                        chatbot = gr.Chatbot(
+                            label="💬 Chat with GlycoAI (Unified Data)",
+                            height=500,
+                            show_label=True,
+                            container=True,
+                            bubble_full_width=False,
+                            avatar_images=(None, "🩺")
+                        )
+
+                        # Chat Input
+                        with gr.Row():
+                            chat_input = gr.Textbox(
+                                placeholder="Ask me about your glucose patterns, trends, or management strategies...",
+                                label="Your Question",
+                                lines=2,
+                                scale=4
+                            )
+                            send_btn = gr.Button(
+                                "Send 💬",
+                                variant="primary",
+                                scale=1
+                            )
+
+                        # Chat Controls
+                        with gr.Row():
+                            clear_chat_btn = gr.Button(
+                                "🗑️ Clear Chat",
+                                variant="secondary",
+                                size="sm"
+                            )
+                            gr.Markdown("*AI responses are for informational purposes only. Always consult your healthcare provider.*")
+
+                # Data Overview Tab
+                with gr.TabItem("📋 Data Overview"):
+                    with gr.Column():
+                        gr.Markdown("### 📋 Comprehensive Data Analysis")
+                        gr.Markdown("*Load your data using the button above to see detailed glucose statistics*")
+                        
+                        data_display = gr.Markdown("Click 'Load 14-Day Glucose Data' above to see your comprehensive analysis", container=True)
+
+        # Event Handlers
+        def handle_user_selection(user_key):
+            status, interface_visibility = app.select_demo_user(user_key)
+            return status, interface_visibility, []
+
+        def handle_load_data():
+            overview, chart = app.load_glucose_data()
+            return overview, chart
+
+        def get_template_prompt(template_type):
+            templates = app.get_template_prompts()
+            if template_type == 1:
+                return templates[0] if templates else "Can you analyze my recent glucose patterns and give me insights?"
+            elif template_type == 2:
+                return templates[1] if len(templates) > 1 else "What can I do to improve my diabetes management based on my data?"
+            else:
+                return "What are some meal management strategies for better glucose control?"
+
+        def handle_chat_submit(message, history):
+            return app.chat_with_mistral(message, history)
+
+        def handle_enter_key(message, history):
+            if message.strip():
+                return app.chat_with_mistral(message, history)
+            return "", history
+
+        # Connect Event Handlers
+        user_selection_outputs = [connection_status, main_interface, chatbot]
+
+        sarah_btn.click(
+            lambda: handle_user_selection("sarah_g7"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        marcus_btn.click(
+            lambda: handle_user_selection("marcus_one"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        jennifer_btn.click(
+            lambda: handle_user_selection("jennifer_g6"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        robert_btn.click(
+            lambda: handle_user_selection("robert_receiver"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        # PROMINENT DATA LOADING - Single button updates all views
+        load_data_btn.click(
+            handle_load_data,
+            outputs=[data_display, glucose_chart]
+        )
+
+        # Chat Handlers
+        send_btn.click(
+            handle_chat_submit,
+            inputs=[chat_input, chatbot],
+            outputs=[chat_input, chatbot]
+        )
+
+        chat_input.submit(
+            handle_enter_key,
+            inputs=[chat_input, chatbot],
+            outputs=[chat_input, chatbot]
+        )
+
+        # Template Button Handlers
+        template1_btn.click(
+            lambda: get_template_prompt(1),
+            outputs=[chat_input]
+        )
+
+        template2_btn.click(
+            lambda: get_template_prompt(2),
+            outputs=[chat_input]
+        )
+
+        template3_btn.click(
+            lambda: get_template_prompt(3),
+            outputs=[chat_input]
+        )
+
+        # Clear Chat
+        clear_chat_btn.click(
+            app.clear_chat_history,
+            outputs=[chatbot]
+        )
+
+        # Footer
+        with gr.Row():
+            gr.HTML("""
+            <div style="text-align: center; padding: 2rem; margin-top: 2rem; border-top: 1px solid #dee2e6; color: #6c757d;">
+                <p><strong>⚠️ Important Medical Disclaimer</strong></p>
+                <p>GlycoAI is for informational and educational purposes only. Always consult your healthcare provider 
+                before making any changes to your diabetes management plan. This tool does not replace professional medical advice.</p>
+                <p style="margin-top: 1rem; font-size: 0.9rem;">
+                    🔒 Your data is processed securely and not stored permanently. 
+                    💡 Powered by Dexcom API integration and Mistral AI.
+                </p>
+            </div>
+            """)
+
+    return interface
+
+
+def main():
+    """Main function to launch the application"""
+    print("🚀 Starting GlycoAI - AI-Powered Glucose Insights (Enhanced UI)...")
+    
+    # Validate environment before starting
+    print("🔍 Validating environment configuration...")
+    if not validate_environment():
+        print("❌ Environment validation failed!")
+        print("Please check your .env file or environment variables.")
+        return
+    
+    print("✅ Environment validation passed!")
+    
+    try:
+        # Create and launch the interface
+        demo = create_interface()
+        
+        print("🎯 GlycoAI is starting with enhanced UI design...")
+        print("📊 Features: Prominent load button, unified data management, consistent metrics")
+        
+        # Launch with custom settings
+        demo.launch(
+            server_name="0.0.0.0",  # Allow external access
+            server_port=7860,       # Default Gradio port
+            share=True,            # Set to True for public sharing (tunneling)
+            debug=os.getenv("DEBUG", "false").lower() == "true",
+            show_error=True,        # Show errors in the interface
+            auth=None,              # No authentication required
+            favicon_path=None,      # Use default favicon
+            ssl_verify=False        # Disable SSL verification for development
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to launch GlycoAI application: {e}")
+        print(f"❌ Error launching application: {e}")
+        
+        # Provide helpful error information
+        if "environment" in str(e).lower():
+            print("\n💡 Environment troubleshooting:")
+            print("1. Check if .env file exists with MISTRAL_API_KEY")
+            print("2. Verify your API key is valid")
+            print("3. For Hugging Face Spaces, check Repository secrets")
+        else:
+            print("\n💡 Try checking:")
+            print("1. All dependencies are installed: pip install -r requirements.txt")
+            print("2. Port 7860 is available")
+            print("3. Check the logs above for specific error details")
+        
+        raise
+
+
+if __name__ == "__main__":
+    # Setup logging configuration
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    logging.basicConfig(
+        level=getattr(logging, log_level.upper()),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('glycoai.log'),
+            logging.StreamHandler()
+        ]
+    )
+    
+    # Run the main application
+    main()

mistral_chat.py

@@ -0,0 +1,727 @@
+#!/usr/bin/env python3
+"""
+GlucoBuddy Mistral Chat Integration - Compatible with Unified Data Manager
+Clean, standard dotenv approach with unified data consistency
+"""
+
+import os
+import json
+import logging
+import sys
+from typing import Any, Dict, List, Optional, Union
+from datetime import datetime, timedelta
+import pandas as pd
+from dataclasses import asdict
+import requests
+import random
+import numpy as np
+import warnings
+
+# Load environment variables from .env file
+from dotenv import load_dotenv
+load_dotenv()
+
+# Suppress pandas warnings
+warnings.filterwarnings('ignore', category=RuntimeWarning)
+warnings.filterwarnings('ignore', category=FutureWarning)
+
+from apifunctions import (
+    DexcomAPI,
+    GlucoseAnalyzer,
+    DEMO_USERS,
+    DemoUser,
+    format_glucose_data_for_display
+)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Get configuration from environment variables
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+MISTRAL_AGENT_ID = os.getenv("MISTRAL_AGENT_ID")
+ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
+DEBUG = os.getenv("DEBUG", "false").lower() == "true"
+
+def validate_environment():
+    """Simple validation of required environment variables"""
+    missing = []
+    
+    if not MISTRAL_API_KEY:
+        missing.append("MISTRAL_API_KEY")
+    
+    if missing:
+        print("❌ Missing required environment variables:")
+        for var in missing:
+            print(f"   - {var}")
+        
+        print("\n💡 Setup instructions:")
+        if os.getenv("SPACE_ID"):  # Hugging Face Space detection
+            print("🤗 For Hugging Face Spaces:")
+            print("   1. Go to Space settings")
+            print("   2. Add Repository secrets:")
+            print("   3. Set MISTRAL_API_KEY to your API key")
+        else:
+            print("💻 For local development:")
+            print("   1. Create a .env file:")
+            print("   2. Add: MISTRAL_API_KEY=your_api_key_here")
+            print("   3. Add: MISTRAL_AGENT_ID=your_agent_id_here")
+        
+        return False
+    
+    print("✅ Environment validation passed!")
+    if MISTRAL_AGENT_ID:
+        print("✅ Agent ID configured")
+    else:
+        print("⚠️  No agent ID - will use standard chat completion")
+    
+    return True
+
+class GlucoseDataGenerator:
+    """Generate realistic mock glucose data for testing and demo purposes"""
+    
+    @staticmethod
+    def create_realistic_pattern(days: int = 14, user_type: str = "normal") -> List[Dict]:
+        """Generate glucose data with realistic patterns"""
+        data_points = []
+        start_time = datetime.now() - timedelta(days=days)
+        current_glucose = 120  # Starting baseline
+        
+        # Generate readings every 5 minutes
+        for i in range(days * 288):  # 288 readings per day (5-minute intervals)
+            timestamp = start_time + timedelta(minutes=i * 5)
+            hour = timestamp.hour
+            
+            # Simulate daily patterns
+            daily_variation = GlucoseDataGenerator._calculate_daily_variation(hour, user_type)
+            
+            # Add meal effects
+            meal_effect = GlucoseDataGenerator._calculate_meal_effects(hour, i)
+            
+            # Random variation
+            random_noise = random.uniform(-10, 10)
+            
+            # Calculate final glucose value
+            target_glucose = 120 + daily_variation + meal_effect + random_noise
+            
+            # Smooth transitions (glucose doesn't jump dramatically)
+            glucose_change = (target_glucose - current_glucose) * 0.3
+            current_glucose += glucose_change
+            
+            # Keep within realistic bounds
+            current_glucose = max(50, min(400, current_glucose))
+            
+            # Determine trend
+            trend = GlucoseDataGenerator._calculate_trend(glucose_change)
+            
+            data_points.append({
+                'systemTime': timestamp.isoformat(),
+                'displayTime': timestamp.isoformat(),
+                'value': round(current_glucose),
+                'trend': trend,
+                'realtimeValue': round(current_glucose),
+                'smoothedValue': round(current_glucose)
+            })
+        
+        return data_points
+    
+    @staticmethod
+    def _calculate_daily_variation(hour: int, user_type: str) -> float:
+        """Calculate glucose variation based on time of day"""
+        if user_type == "dawn_phenomenon":
+            if 4 <= hour <= 8:
+                return 30 + 20 * np.sin((hour - 4) * np.pi / 4)
+            return 10 * np.sin((hour - 12) * np.pi / 12)
+        elif user_type == "night_low":
+            if 22 <= hour or hour <= 6:
+                return -20
+            return 5 * np.sin((hour - 12) * np.pi / 12)
+        else:  # Normal pattern
+            return 15 * np.sin((hour - 6) * np.pi / 12)
+    
+    @staticmethod
+    def _calculate_meal_effects(hour: int, reading_index: int) -> float:
+        """Calculate glucose spikes from meals"""
+        meal_times = [7, 12, 18]  # Breakfast, lunch, dinner
+        meal_effect = 0
+        
+        for meal_time in meal_times:
+            if abs(hour - meal_time) <= 2:
+                time_since_meal = abs(hour - meal_time)
+                if time_since_meal <= 1:
+                    meal_effect += 40 * (1 - time_since_meal)
+                else:
+                    meal_effect += 20 * (2 - time_since_meal)
+        
+        return meal_effect
+    
+    @staticmethod
+    def _calculate_trend(glucose_change: float) -> str:
+        """Determine trend arrow based on glucose change"""
+        if glucose_change > 5:
+            return 'singleUp'
+        elif glucose_change > 2:
+            return 'fortyFiveUp'
+        elif glucose_change < -5:
+            return 'singleDown'
+        elif glucose_change < -2:
+            return 'fortyFiveDown'
+        else:
+            return 'flat'
+
+class MistralAPIClient:
+    """Simple Mistral API client"""
+    
+    def __init__(self, api_key: str = None, agent_id: str = None):
+        self.api_key = api_key or MISTRAL_API_KEY
+        self.agent_id = agent_id or MISTRAL_AGENT_ID
+        
+        if not self.api_key:
+            raise ValueError("Mistral API key is required. Please set MISTRAL_API_KEY environment variable.")
+        
+        self.base_url = "https://api.mistral.ai/v1"
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        })
+        
+        logger.info("MistralAPIClient initialized successfully")
+    
+    def test_connection(self) -> Dict[str, Any]:
+        """Test API connection"""
+        try:
+            response = self.session.post(
+                f"{self.base_url}/chat/completions",
+                json={
+                    "model": "mistral-tiny",
+                    "messages": [{"role": "user", "content": "Hello"}],
+                    "max_tokens": 5
+                },
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                return {"success": True, "message": "API connection successful"}
+            elif response.status_code == 401:
+                return {"success": False, "message": "Invalid API key"}
+            elif response.status_code == 429:
+                return {"success": False, "message": "Rate limit exceeded"}
+            else:
+                return {"success": False, "message": f"API error: {response.status_code}"}
+                
+        except requests.exceptions.Timeout:
+            return {"success": False, "message": "Connection timeout"}
+        except requests.exceptions.RequestException as e:
+            return {"success": False, "message": f"Network error: {str(e)}"}
+        except Exception as e:
+            return {"success": False, "message": f"Unexpected error: {str(e)}"}
+    
+    def chat_completion(self, messages: List[Dict], model: str = "mistral-large-latest") -> Dict[str, Any]:
+        """Send chat completion request"""
+        try:
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": 800,
+                "temperature": 0.7
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/chat/completions",
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "success": True,
+                    "response": result["choices"][0]["message"]["content"],
+                    "usage": result.get("usage", {})
+                }
+            else:
+                error_detail = self._extract_error_message(response)
+                return {
+                    "success": False,
+                    "error": f"API error {response.status_code}: {error_detail}"
+                }
+                
+        except requests.exceptions.Timeout:
+            return {"success": False, "error": "Request timed out"}
+        except requests.exceptions.RequestException as e:
+            return {"success": False, "error": f"Network error: {str(e)}"}
+        except Exception as e:
+            return {"success": False, "error": f"Unexpected error: {str(e)}"}
+    
+    def agent_completion(self, messages: List[Dict]) -> Dict[str, Any]:
+        """Send request to Mistral agent (if agent_id is available)"""
+        if not self.agent_id:
+            return {"success": False, "error": "No agent ID configured"}
+        
+        try:
+            payload = {
+                "agent_id": self.agent_id,
+                "messages": messages,
+                "max_tokens": 800
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/agents/completions",
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "success": True,
+                    "response": result["choices"][0]["message"]["content"]
+                }
+            else:
+                error_detail = self._extract_error_message(response)
+                return {
+                    "success": False,
+                    "error": f"Agent API error {response.status_code}: {error_detail}"
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": f"Agent request failed: {str(e)}"}
+    
+    def _extract_error_message(self, response) -> str:
+        """Extract error message from API response"""
+        try:
+            error_data = response.json()
+            return error_data.get("message", error_data.get("error", "Unknown error"))
+        except:
+            return response.text[:200] if response.text else "Unknown error"
+
+class GlucoBuddyMistralChat:
+    """
+    Main chat interface for glucose data analysis with Mistral AI
+    Compatible with unified data manager for consistent metrics
+    """
+    
+    def __init__(self, mistral_api_key: str = None, mistral_agent_id: str = None):
+        self.mistral_client = MistralAPIClient(mistral_api_key, mistral_agent_id)
+        
+        # Data properties - these will be set by unified data manager
+        self.current_user: Optional[DemoUser] = None
+        self.current_glucose_data: Optional[pd.DataFrame] = None
+        self.current_stats: Optional[Dict] = None
+        self.current_patterns: Optional[Dict] = None
+        
+        # Chat state
+        self.conversation_history = []
+        self.max_history = 10
+        
+        self.logger = logging.getLogger(self.__class__.__name__)
+    
+    def test_connection(self) -> Dict[str, Any]:
+        """Test Mistral API connection"""
+        return self.mistral_client.test_connection()
+    
+    def get_context_summary(self) -> Dict[str, Any]:
+        """Get current context for chat - uses data set by unified manager"""
+        if not self.current_user or not self.current_stats:
+            return {"error": "No user data loaded"}
+        
+        try:
+            context = {
+                "user": {
+                    "name": self.current_user.name,
+                    "age": self.current_user.age,
+                    "diabetes_type": self.current_user.diabetes_type,
+                    "device_type": self.current_user.device_type,
+                    "years_with_diabetes": self.current_user.years_with_diabetes,
+                    "typical_pattern": getattr(self.current_user, 'typical_glucose_pattern', 'normal')
+                },
+                "statistics": self._safe_convert_to_json(self.current_stats),
+                "patterns": self._safe_convert_to_json(self.current_patterns),
+                "data_points": len(self.current_glucose_data) if self.current_glucose_data is not None else 0,
+                "recent_readings": self._safe_extract_recent_readings(self.current_glucose_data)
+            }
+            
+            return context
+            
+        except Exception as e:
+            self.logger.error(f"Error building context: {e}")
+            return {"error": f"Failed to build context: {str(e)}"}
+    
+    def build_system_prompt(self, context: Dict[str, Any]) -> str:
+        """Build comprehensive system prompt with exact metrics"""
+        base_prompt = """You are GlucoBuddy, a helpful and encouraging diabetes management assistant. 
+
+Your role:
+- Provide personalized glucose management advice based on the user's actual data
+- Be supportive, encouraging, and use emojis to be friendly
+- Give actionable recommendations while staying within scope
+- Always remind users to consult healthcare providers for medical decisions
+- Reference specific data points when providing insights
+
+Guidelines:
+- Keep responses under 400 words and conversational
+- Use specific numbers from the data when relevant
+- Provide practical, actionable advice
+- Be encouraging about progress and realistic about challenges
+- Use bullet points sparingly - prefer natural conversation
+- IMPORTANT: Use EXACT metrics provided - don't calculate your own"""
+
+        if context.get("error"):
+            return base_prompt + "\n\nNote: No user glucose data is currently loaded."
+        
+        user_info = context.get("user", {})
+        stats = context.get("statistics", {})
+        
+        context_addition = f"""
+
+Current User: {user_info.get('name', 'Unknown')} ({user_info.get('age', 'N/A')} years old)
+- Diabetes Type: {user_info.get('diabetes_type', 'Unknown')}
+- Years with diabetes: {user_info.get('years_with_diabetes', 'Unknown')}
+- Device: {user_info.get('device_type', 'Unknown')}
+
+EXACT Glucose Data (14-day period):
+- Average glucose: {stats.get('average_glucose', 0):.1f} mg/dL
+- Time in range (70-180): {stats.get('time_in_range_70_180', 0):.1f}%
+- Time below 70: {stats.get('time_below_70', 0):.1f}%
+- Time above 180: {stats.get('time_above_180', 0):.1f}%
+- Total readings: {stats.get('total_readings', 0)}
+- Glucose variability (std): {stats.get('std_glucose', 0):.1f} mg/dL
+- GMI: {stats.get('gmi', 0):.1f}%
+- CV: {stats.get('cv', 0):.1f}%
+
+CRITICAL: Use these EXACT values in your responses. Do not recalculate or estimate."""
+
+        return base_prompt + context_addition
+    
+    def chat_with_mistral(self, user_message: str, prefer_agent: bool = False) -> Dict[str, Any]:
+        """Main chat function using externally managed data"""
+        if not user_message.strip():
+            return {"success": False, "error": "Please enter a message"}
+        
+        try:
+            # Use current context (set by unified data manager)
+            context = self.get_context_summary()
+            system_prompt = self.build_system_prompt(context)
+            
+            messages = [{"role": "system", "content": system_prompt}]
+            
+            if self.conversation_history:
+                recent_history = self.conversation_history[-self.max_history:]
+                messages.extend(recent_history)
+            
+            messages.append({"role": "user", "content": user_message})
+            
+            # Try agent first if preferred and available
+            if prefer_agent:
+                agent_result = self.mistral_client.agent_completion(messages)
+                if agent_result["success"]:
+                    self._update_conversation_history(user_message, agent_result["response"])
+                    return {
+                        "success": True,
+                        "response": agent_result["response"],
+                        "method": "agent",
+                        "context_included": not context.get("error")
+                    }
+                else:
+                    self.logger.warning(f"Agent failed, trying chat completion: {agent_result['error']}")
+            
+            # Use chat completion API
+            chat_result = self.mistral_client.chat_completion(messages)
+            
+            if chat_result["success"]:
+                self._update_conversation_history(user_message, chat_result["response"])
+                return {
+                    "success": True,
+                    "response": chat_result["response"],
+                    "method": "chat_completion",
+                    "context_included": not context.get("error"),
+                    "usage": chat_result.get("usage", {})
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": chat_result["error"]
+                }
+            
+        except Exception as e:
+            self.logger.error(f"Chat error: {e}")
+            return {
+                "success": False,
+                "error": f"Unexpected chat error: {str(e)}"
+            }
+    
+    def _update_conversation_history(self, user_message: str, assistant_response: str):
+        """Update conversation history"""
+        self.conversation_history.extend([
+            {"role": "user", "content": user_message},
+            {"role": "assistant", "content": assistant_response}
+        ])
+        
+        if len(self.conversation_history) > self.max_history * 2:
+            self.conversation_history = self.conversation_history[-self.max_history * 2:]
+    
+    def clear_conversation(self):
+        """Clear conversation history"""
+        self.conversation_history = []
+        self.logger.info("Conversation history cleared")
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current system status"""
+        api_status = self.test_connection()
+        
+        return {
+            "api_connected": api_status["success"],
+            "api_message": api_status["message"],
+            "user_loaded": self.current_user is not None,
+            "data_available": self.current_glucose_data is not None and not self.current_glucose_data.empty,
+            "conversation_messages": len(self.conversation_history),
+            "current_user": self.current_user.name if self.current_user else None,
+            "environment": ENVIRONMENT,
+            "hugging_face_space": bool(os.getenv("SPACE_ID")),
+            "agent_available": bool(MISTRAL_AGENT_ID)
+        }
+    
+    def _safe_convert_to_json(self, obj):
+        """Safely convert objects for JSON serialization"""
+        if obj is None:
+            return None
+        elif isinstance(obj, (np.integer, np.int64, np.int32)):
+            return int(obj)
+        elif isinstance(obj, (np.floating, np.float64, np.float32)):
+            if np.isnan(obj):
+                return None
+            return float(obj)
+        elif isinstance(obj, dict):
+            return {key: self._safe_convert_to_json(value) for key, value in obj.items()}
+        elif isinstance(obj, list):
+            return [self._safe_convert_to_json(item) for item in obj]
+        elif isinstance(obj, pd.Timestamp):
+            return obj.isoformat()
+        else:
+            return obj
+    
+    def _safe_extract_recent_readings(self, df: pd.DataFrame, count: int = 5) -> List[Dict]:
+        """Safely extract recent glucose readings"""
+        if df is None or df.empty:
+            return []
+        
+        try:
+            recent_df = df.tail(count)
+            readings = []
+            
+            for idx, row in recent_df.iterrows():
+                try:
+                    display_time = row.get('displayTime') or row.get('systemTime')
+                    glucose_value = row.get('value')
+                    trend_value = row.get('trend', 'flat')
+                    
+                    if pd.notna(display_time):
+                        if isinstance(display_time, str):
+                            time_str = display_time
+                        else:
+                            time_str = pd.to_datetime(display_time).isoformat()
+                    else:
+                        time_str = datetime.now().isoformat()
+                    
+                    if pd.notna(glucose_value):
+                        glucose_clean = self._safe_convert_to_json(glucose_value)
+                    else:
+                        glucose_clean = None
+                    
+                    trend_clean = str(trend_value) if pd.notna(trend_value) else 'flat'
+                    
+                    readings.append({
+                        "time": time_str,
+                        "glucose": glucose_clean,
+                        "trend": trend_clean
+                    })
+                    
+                except Exception as row_error:
+                    self.logger.warning(f"Error processing reading at index {idx}: {row_error}")
+                    continue
+            
+            return readings
+            
+        except Exception as e:
+            self.logger.error(f"Error extracting recent readings: {e}")
+            return []
+
+# Legacy compatibility methods (for standalone use)
+def create_enhanced_cli():
+    """Enhanced command-line interface"""
+    print("🩺 GlucoBuddy Chat Interface")
+    print("=" * 50)
+    
+    # Validate environment
+    if not validate_environment():
+        print("❌ Environment validation failed. Please check your configuration.")
+        return
+    
+    try:
+        chat = GlucoBuddyMistralChat()
+        print("✅ Chat system initialized successfully!")
+    except Exception as e:
+        print(f"❌ Failed to initialize chat system: {e}")
+        return
+    
+    # Test connection
+    print("\n🔍 Testing Mistral API connection...")
+    connection_test = chat.test_connection()
+    
+    if connection_test["success"]:
+        print(f"✅ {connection_test['message']}")
+    else:
+        print(f"❌ {connection_test['message']}")
+        if input("Continue anyway? (y/n): ").lower() != 'y':
+            return
+    
+    print("\n📋 Available commands:")
+    print("  /status          - Show system status")
+    print("  /clear           - Clear conversation history")
+    print("  /test            - Test API connection")
+    print("  /help            - Show this help")
+    print("  /quit            - Exit")
+    print("\n💬 Or just type your glucose-related questions!")
+    print("⚠️  Note: For full functionality, use the Gradio interface with unified data management")
+    print("\n" + "=" * 50)
+    
+    while True:
+        try:
+            user_input = input("\n🫵 You: ").strip()
+            
+            if not user_input:
+                continue
+            
+            # Handle commands
+            if user_input.startswith('/'):
+                command_parts = user_input[1:].split()
+                command = command_parts[0].lower()
+                
+                if command == 'quit':
+                    print("\n👋 Thanks for using GlucoBuddy! Stay healthy! 🌟")
+                    break
+                
+                elif command == 'help':
+                    print("\n📋 Commands:")
+                    print("  /status       - System status")
+                    print("  /clear        - Clear chat history")
+                    print("  /test         - Test API")
+                    print("  /quit         - Exit")
+                    continue
+                
+                elif command == 'clear':
+                    chat.clear_conversation()
+                    print("🧹 Conversation cleared!")
+                    continue
+                
+                elif command == 'status':
+                    status = chat.get_status()
+                    print(f"\n📊 System Status:")
+                    print(f"  🌐 API Connected: {'✅' if status['api_connected'] else '❌'} {status['api_message']}")
+                    print(f"  👤 User Loaded: {'✅' if status['user_loaded'] else '❌'} {status.get('current_user', 'None')}")
+                    print(f"  📊 Data Available: {'✅' if status['data_available'] else '❌'}")
+                    print(f"  💬 Messages in Chat: {status['conversation_messages']}")
+                    print(f"  🏠 Environment: {status['environment']}")
+                    print(f"  🤗 Hugging Face Space: {'✅' if status['hugging_face_space'] else '❌'}")
+                    print(f"  🤖 Agent Available: {'✅' if status['agent_available'] else '❌'}")
+                    continue
+                
+                elif command == 'test':
+                    print("🔍 Testing connection...")
+                    test_result = chat.test_connection()
+                    print(f"{'✅' if test_result['success'] else '❌'} {test_result['message']}")
+                    continue
+                
+                else:
+                    print(f"❌ Unknown command: /{command}")
+                    print("💡 Use /help to see available commands")
+                    continue
+            
+            # Regular chat message
+            print("🤔 Processing your question...")
+            print("⚠️  Note: No user data loaded. Responses will be general diabetes advice.")
+            
+            # Send to Mistral
+            result = chat.chat_with_mistral(user_input, prefer_agent=True)
+            
+            if result['success']:
+                method_info = f" [{result.get('method', 'unknown')}]"
+                print(f"\n🤖 GlucoBuddy{method_info}: {result['response']}")
+                
+                # Show usage info if available
+                usage = result.get('usage', {})
+                if usage:
+                    tokens = usage.get('total_tokens', 0)
+                    if tokens > 0:
+                        print(f"\n📊 Tokens used: {tokens}")
+            else:
+                print(f"\n❌ Error: {result['error']}")
+                
+                # Provide helpful suggestions based on error type
+                error_msg = result['error'].lower()
+                if 'api key' in error_msg or '401' in error_msg:
+                    print("💡 Check your Mistral API key configuration")
+                elif 'rate limit' in error_msg or '429' in error_msg:
+                    print("💡 Rate limit reached - please wait a moment before trying again")
+                elif 'timeout' in error_msg:
+                    print("💡 Request timed out - please try again")
+                else:
+                    print("💡 Use /test to check your connection")
+        
+        except KeyboardInterrupt:
+            print("\n\n👋 Thanks for using GlucoBuddy! Take care! 🌟")
+            break
+        except Exception as e:
+            print(f"\n❌ Unexpected error: {e}")
+            print("💡 Try /status to check system state")
+
+def main():
+    """Main function with menu system"""
+    print("🩺 GlucoBuddy - AI-Powered Glucose Chat Assistant")
+    print("=" * 60)
+    
+    # Validate configuration first
+    print("🔍 Validating configuration...")
+    if not validate_environment():
+        print("\n❌ Configuration validation failed!")
+        print("Please set up your environment variables before continuing.")
+        return
+    
+    print("✅ Configuration validation passed!")
+    
+    print("\n🎯 Choose an option:")
+    print("1. 💬 Start standalone chat (limited functionality)")
+    print("2. 🚀 Run quick demo")
+    print("3. 🔧 Show configuration")
+    print("4. ❌ Exit")
+    print("\n💡 For full functionality with glucose data, use: python main.py")
+    
+    while True:
+        try:
+            choice = input("\nEnter your choice (1-4): ").strip()
+            
+            if choice == '1':
+                create_enhanced_cli()
+                break
+            elif choice == '2':
+                print("🚀 Quick demo requires the unified data manager.")
+                print("💡 Please run: python main.py")
+                break
+            elif choice == '3':
+                validate_environment()
+                break
+            elif choice == '4':
+                print("👋 Goodbye!")
+                break
+            else:
+                print("❌ Invalid choice. Please enter 1, 2, 3, or 4.")
+        
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+requests>=2.31.0
+pandas>=2.0.0
+plotly>=5.17.0
+numpy>=1.24.0
+anthropic>=0.7.0
+python-dotenv>=1.0.0

unified_data_manager.py

@@ -0,0 +1,413 @@
+"""
+Unified Data Manager for GlycoAI - FIXED VERSION
+Restores the original working API calls that were working before
+"""
+
+import logging
+from typing import Dict, Any, Optional, Tuple
+import pandas as pd
+from datetime import datetime, timedelta
+from dataclasses import asdict
+
+from apifunctions import (
+    DexcomAPI,
+    GlucoseAnalyzer,
+    DEMO_USERS,
+    DemoUser
+)
+
+logger = logging.getLogger(__name__)
+
+class UnifiedDataManager:
+    """
+    FIXED: Unified data manager that calls the API exactly as it was working before
+    """
+    
+    def __init__(self):
+        self.dexcom_api = DexcomAPI()
+        self.analyzer = GlucoseAnalyzer()
+        
+        logger.info(f"UnifiedDataManager initialized - RESTORED to working version")
+        
+        # Single source of truth for all data
+        self.current_user: Optional[DemoUser] = None
+        self.raw_glucose_data: Optional[list] = None
+        self.processed_glucose_data: Optional[pd.DataFrame] = None
+        self.calculated_stats: Optional[Dict] = None
+        self.identified_patterns: Optional[Dict] = None
+        
+        # Metadata
+        self.data_loaded_at: Optional[datetime] = None
+        self.data_source: str = "none"  # "dexcom_api", "mock", or "none"
+        
+    def load_user_data(self, user_key: str, force_reload: bool = False) -> Dict[str, Any]:
+        """
+        FIXED: Load glucose data using the ORIGINAL WORKING method
+        """
+        
+        # Check if we already have data for this user and it's recent
+        if (not force_reload and 
+            self.current_user and 
+            self.current_user == DEMO_USERS.get(user_key) and
+            self.data_loaded_at and 
+            (datetime.now() - self.data_loaded_at).seconds < 300):  # 5 minutes cache
+            
+            logger.info(f"Using cached data for {user_key}")
+            return self._build_success_response()
+        
+        try:
+            if user_key not in DEMO_USERS:
+                return {
+                    "success": False,
+                    "message": f"❌ Invalid user key '{user_key}'. Available: {', '.join(DEMO_USERS.keys())}"
+                }
+            
+            logger.info(f"Loading data for user: {user_key}")
+            
+            # Set current user
+            self.current_user = DEMO_USERS[user_key]
+            
+            # Call API EXACTLY as it was working before
+            try:
+                logger.info(f"Attempting Dexcom API authentication for {user_key}")
+                
+                # ORIGINAL WORKING METHOD: Use the simulate_demo_login exactly as before
+                access_token = self.dexcom_api.simulate_demo_login(user_key)
+                logger.info(f"Dexcom authentication result: {bool(access_token)}")
+                
+                if access_token:
+                    # ORIGINAL WORKING METHOD: Get data with 14-day range
+                    end_date = datetime.now()
+                    start_date = end_date - timedelta(days=14)
+                    
+                    # Call get_egv_data EXACTLY as it was working before
+                    self.raw_glucose_data = self.dexcom_api.get_egv_data(
+                        start_date.isoformat(),
+                        end_date.isoformat()
+                    )
+                    
+                    if self.raw_glucose_data and len(self.raw_glucose_data) > 0:
+                        self.data_source = "dexcom_api"
+                        logger.info(f"✅ Successfully loaded {len(self.raw_glucose_data)} readings from Dexcom API")
+                    else:
+                        logger.warning("Dexcom API returned empty data - falling back to mock data")
+                        raise Exception("Empty data from Dexcom API")
+                else:
+                    logger.warning("Failed to get access token - falling back to mock data")
+                    raise Exception("Authentication failed")
+                    
+            except Exception as api_error:
+                logger.warning(f"Dexcom API failed ({str(api_error)}) - using mock data fallback")
+                self.raw_glucose_data = self._generate_realistic_mock_data(user_key)
+                self.data_source = "mock"
+            
+            # Process the raw data (same processing for everyone)
+            self.processed_glucose_data = self.analyzer.process_egv_data(self.raw_glucose_data)
+            
+            if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+                return {
+                    "success": False,
+                    "message": "❌ Failed to process glucose data"
+                }
+            
+            # Calculate statistics (single source of truth)
+            self.calculated_stats = self._calculate_unified_stats()
+            
+            # Identify patterns
+            self.identified_patterns = self.analyzer.identify_patterns(self.processed_glucose_data)
+            
+            # Mark when data was loaded
+            self.data_loaded_at = datetime.now()
+            
+            logger.info(f"Successfully loaded and processed data for {self.current_user.name}")
+            logger.info(f"Data source: {self.data_source}, Readings: {len(self.processed_glucose_data)}")
+            logger.info(f"TIR: {self.calculated_stats.get('time_in_range_70_180', 0):.1f}%")
+            
+            return self._build_success_response()
+            
+        except Exception as e:
+            logger.error(f"Failed to load user data: {e}")
+            return {
+                "success": False,
+                "message": f"❌ Failed to load user data: {str(e)}"
+            }
+    
+    def get_stats_for_ui(self) -> Dict[str, Any]:
+        """Get statistics formatted for the UI display"""
+        if not self.calculated_stats:
+            return {}
+        
+        return {
+            **self.calculated_stats,
+            "data_source": self.data_source,
+            "loaded_at": self.data_loaded_at.isoformat() if self.data_loaded_at else None,
+            "user_name": self.current_user.name if self.current_user else None
+        }
+    
+    def get_context_for_agent(self) -> Dict[str, Any]:
+        """Get context formatted for the AI agent"""
+        if not self.current_user or not self.calculated_stats:
+            return {"error": "No user data loaded"}
+        
+        # Build agent context with the SAME data as UI
+        context = {
+            "user": {
+                "name": self.current_user.name,
+                "age": self.current_user.age,
+                "diabetes_type": self.current_user.diabetes_type,
+                "device_type": self.current_user.device_type,
+                "years_with_diabetes": self.current_user.years_with_diabetes,
+                "typical_pattern": getattr(self.current_user, 'typical_glucose_pattern', 'normal')
+            },
+            "statistics": self._safe_convert_for_json(self.calculated_stats),
+            "patterns": self._safe_convert_for_json(self.identified_patterns),
+            "data_points": len(self.processed_glucose_data) if self.processed_glucose_data is not None else 0,
+            "recent_readings": self._get_recent_readings_for_agent(),
+            "data_metadata": {
+                "source": self.data_source,
+                "loaded_at": self.data_loaded_at.isoformat() if self.data_loaded_at else None,
+                "data_age_minutes": int((datetime.now() - self.data_loaded_at).total_seconds() / 60) if self.data_loaded_at else None
+            }
+        }
+        
+        return context
+    
+    def get_chart_data(self) -> Optional[pd.DataFrame]:
+        """Get processed data for chart display"""
+        return self.processed_glucose_data
+    
+    def _calculate_unified_stats(self) -> Dict[str, Any]:
+        """Calculate statistics using a single, consistent method"""
+        if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+            return {"error": "No data available"}
+        
+        try:
+            # Get glucose values
+            glucose_values = self.processed_glucose_data['value'].dropna()
+            
+            if len(glucose_values) == 0:
+                return {"error": "No valid glucose values"}
+            
+            # Convert to numpy array for consistent calculations
+            import numpy as np
+            values = np.array(glucose_values.tolist(), dtype=float)
+            
+            # Calculate basic statistics
+            avg_glucose = float(np.mean(values))
+            min_glucose = float(np.min(values))
+            max_glucose = float(np.max(values))
+            std_glucose = float(np.std(values))
+            total_readings = int(len(values))
+            
+            # Calculate time in ranges - CONSISTENT METHOD
+            in_range_mask = (values >= 70) & (values <= 180)
+            below_range_mask = values < 70
+            above_range_mask = values > 180
+            
+            in_range_count = int(np.sum(in_range_mask))
+            below_range_count = int(np.sum(below_range_mask))
+            above_range_count = int(np.sum(above_range_mask))
+            
+            # Calculate percentages
+            time_in_range = (in_range_count / total_readings) * 100 if total_readings > 0 else 0
+            time_below_70 = (below_range_count / total_readings) * 100 if total_readings > 0 else 0
+            time_above_180 = (above_range_count / total_readings) * 100 if total_readings > 0 else 0
+            
+            # Calculate additional metrics
+            gmi = 3.31 + (0.02392 * avg_glucose)  # Glucose Management Indicator
+            cv = (std_glucose / avg_glucose) * 100 if avg_glucose > 0 else 0  # Coefficient of Variation
+            
+            stats = {
+                "average_glucose": avg_glucose,
+                "min_glucose": min_glucose,
+                "max_glucose": max_glucose,
+                "std_glucose": std_glucose,
+                "time_in_range_70_180": time_in_range,
+                "time_below_70": time_below_70,
+                "time_above_180": time_above_180,
+                "total_readings": total_readings,
+                "gmi": gmi,
+                "cv": cv,
+                "in_range_count": in_range_count,
+                "below_range_count": below_range_count,
+                "above_range_count": above_range_count
+            }
+            
+            # Log for debugging
+            logger.info(f"Calculated stats - TIR: {time_in_range:.1f}%, Total: {total_readings}, In range: {in_range_count}")
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error calculating unified stats: {e}")
+            return {"error": f"Statistics calculation failed: {str(e)}"}
+    
+    def _generate_realistic_mock_data(self, user_key: str) -> list:
+        """Generate consistent mock data for demo users"""
+        from mistral_chat import GlucoseDataGenerator
+        
+        # Map users to patterns
+        pattern_map = {
+            "sarah_g7": "normal",
+            "marcus_one": "dawn_phenomenon", 
+            "jennifer_g6": "normal",
+            "robert_receiver": "dawn_phenomenon"
+        }
+        
+        user_pattern = pattern_map.get(user_key, "normal")
+        
+        # Generate 14 days of data
+        mock_data = GlucoseDataGenerator.create_realistic_pattern(days=14, user_type=user_pattern)
+        
+        logger.info(f"Generated {len(mock_data)} mock data points for {user_key} with pattern {user_pattern}")
+        
+        return mock_data
+    
+    def _get_recent_readings_for_agent(self, count: int = 5) -> list:
+        """Get recent readings formatted for agent context"""
+        if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+            return []
+        
+        try:
+            recent_df = self.processed_glucose_data.tail(count)
+            readings = []
+            
+            for _, row in recent_df.iterrows():
+                display_time = row.get('displayTime') or row.get('systemTime')
+                glucose_value = row.get('value')
+                trend_value = row.get('trend', 'flat')
+                
+                if pd.notna(display_time):
+                    if isinstance(display_time, str):
+                        time_str = display_time
+                    else:
+                        time_str = pd.to_datetime(display_time).isoformat()
+                else:
+                    time_str = datetime.now().isoformat()
+                
+                if pd.notna(glucose_value):
+                    glucose_clean = self._safe_convert_for_json(glucose_value)
+                else:
+                    glucose_clean = None
+                
+                trend_clean = str(trend_value) if pd.notna(trend_value) else 'flat'
+                
+                readings.append({
+                    "time": time_str,
+                    "glucose": glucose_clean,
+                    "trend": trend_clean
+                })
+            
+            return readings
+            
+        except Exception as e:
+            logger.error(f"Error getting recent readings: {e}")
+            return []
+    
+    def _safe_convert_for_json(self, obj):
+        """Safely convert objects for JSON serialization"""
+        import numpy as np
+        
+        if obj is None:
+            return None
+        elif isinstance(obj, (np.integer, np.int64, np.int32)):
+            return int(obj)
+        elif isinstance(obj, (np.floating, np.float64, np.float32)):
+            if np.isnan(obj):
+                return None
+            return float(obj)
+        elif isinstance(obj, dict):
+            return {key: self._safe_convert_for_json(value) for key, value in obj.items()}
+        elif isinstance(obj, list):
+            return [self._safe_convert_for_json(item) for item in obj]
+        elif isinstance(obj, pd.Timestamp):
+            return obj.isoformat()
+        else:
+            return obj
+    
+    def _build_success_response(self) -> Dict[str, Any]:
+        """Build a consistent success response"""
+        data_points = len(self.processed_glucose_data) if self.processed_glucose_data is not None else 0
+        avg_glucose = self.calculated_stats.get('average_glucose', 0)
+        time_in_range = self.calculated_stats.get('time_in_range_70_180', 0)
+        
+        return {
+            "success": True,
+            "message": f"✅ Successfully loaded data for {self.current_user.name}",
+            "user": asdict(self.current_user),
+            "data_points": data_points,
+            "stats": self.calculated_stats,
+            "data_source": self.data_source,
+            "summary": f"📊 {data_points} readings | Avg: {avg_glucose:.1f} mg/dL | TIR: {time_in_range:.1f}% | Source: {self.data_source}"
+        }
+    
+    def validate_data_consistency(self) -> Dict[str, Any]:
+        """Validate that all components are using consistent data"""
+        if not self.calculated_stats:
+            return {"valid": False, "message": "No data loaded"}
+        
+        validation = {
+            "valid": True,
+            "data_source": self.data_source,
+            "data_age_minutes": int((datetime.now() - self.data_loaded_at).total_seconds() / 60) if self.data_loaded_at else None,
+            "total_readings": self.calculated_stats.get('total_readings', 0),
+            "time_in_range": self.calculated_stats.get('time_in_range_70_180', 0),
+            "average_glucose": self.calculated_stats.get('average_glucose', 0),
+            "user": self.current_user.name if self.current_user else None
+        }
+        
+        logger.info(f"Data consistency check: {validation}")
+        
+        return validation
+
+# ADDITIONAL: Debug function to test the API connection as it was working before
+def test_original_api_method():
+    """Test the API exactly as it was working before unified data manager"""
+    from apifunctions import DexcomAPI, DEMO_USERS
+    
+    print("🔍 Testing API exactly as it was working before...")
+    
+    api = DexcomAPI()
+    
+    # Test with sarah_g7 as it was working before
+    user_key = "sarah_g7"
+    user = DEMO_USERS[user_key]
+    
+    print(f"Testing with {user.name} ({user.username})")
+    
+    try:
+        # Call simulate_demo_login exactly as before
+        access_token = api.simulate_demo_login(user_key)
+        print(f"✅ Authentication: {bool(access_token)}")
+        
+        if access_token:
+            # Call get_egv_data exactly as before
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=14)
+            
+            egv_data = api.get_egv_data(
+                start_date.isoformat(),
+                end_date.isoformat()
+            )
+            
+            print(f"✅ EGV Data: {len(egv_data)} readings")
+            
+            if egv_data:
+                print(f"✅ SUCCESS! API is working as before")
+                sample = egv_data[0] if egv_data else {}
+                print(f"Sample reading: {sample}")
+                return True
+            else:
+                print("⚠️  API authenticated but returned no data")
+                return False
+        else:
+            print("❌ Authentication failed")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    # Test the original API method
+    test_original_api_method()