Update app.py

app.py

@@ -1,426 +1,260 @@
+
 import os
 import gradio as gr
 import json
 import time
 import logging
 import psutil
-import GPUtil
 from datetime import datetime
-from typing import Dict, List, Optional, Tuple
+from typing import List, Dict, Optional
 import requests
 import asyncio
 import aiohttp
-import threading
-from concurrent.futures import ThreadPoolExecutor
-import numpy as np
-import sys
-
-# Add llama.cpp to path
-sys.path.append('./llama.cpp')
-sys.path.append('./llama.cpp/python')
-
-try:
-    from llama_cpp import Llama
-except ImportError:
-    print("llama_cpp not available, using subprocess method")
-
-class SaemsTunesAISystem:
-    def __init__(self):
-        self.models = {}
-        self.current_model = None
-        self.model_loader = ModelLoader()
-        self.performance_monitor = PerformanceMonitor()
-        self.supabase_integration = SupabaseIntegration()
-        self.setup_logging()
-        
-    def setup_logging(self):
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            handlers=[
-                logging.FileHandler('saems_ai_system.log'),
-                logging.StreamHandler()
-            ]
-        )
-        self.logger = logging.getLogger(__name__)
-        
-    def load_models(self):
-        """Load multiple quantized models for different use cases"""
-        model_configs = {
-            "fast": {
-                "path": "./models/phi3.5-mini.Q4_K_M.gguf",
-                "name": "Phi-3.5-mini Q4_K_M (Fast)",
-                "n_ctx": 4096,
-                "n_threads": 4
-            },
-            "balanced": {
-                "path": "./models/phi3.5-mini.Q5_K_M.gguf", 
-                "name": "Phi-3.5-mini Q5_K_M (Balanced)",
-                "n_ctx": 8192,
-                "n_threads": 6
-            },
-            "quality": {
-                "path": "./models/phi3.5-mini.Q8_0.gguf",
-                "name": "Phi-3.5-mini Q8_0 (Quality)",
-                "n_ctx": 16384,
-                "n_threads": 8
-            }
-        }
-        
-        for profile, config in model_configs.items():
-            if os.path.exists(config["path"]):
-                try:
-                    self.models[profile] = Llama(
-                        model_path=config["path"],
-                        n_ctx=config["n_ctx"],
-                        n_threads=config["n_threads"],
-                        verbose=False
-                    )
-                    self.logger.info(f"Loaded {config['name']} successfully")
-                except Exception as e:
-                    self.logger.error(f"Failed to load {config['name']}: {e}")
-        
-        self.current_model = self.models.get("fast")
-        
-    def get_music_context(self, query: str) -> Dict:
-        """Enhanced context retrieval from Supabase"""
-        return self.supabase_integration.get_enhanced_context(query)
-        
-    def generate_response(self, query: str, history: List, model_profile: str = "fast") -> Dict:
-        """Advanced response generation with multiple model support"""
-        start_time = time.time()
-        
-        # Switch model if requested
-        if model_profile in self.models:
-            self.current_model = self.models[model_profile]
-        
-        # Get comprehensive context
-        context = self.get_music_context(query)
-        
-        # Build sophisticated prompt
-        prompt = self.build_advanced_prompt(query, history, context)
-        
-        try:
-            # Generate response
-            response = self.current_model.create_chat_completion(
-                messages=[
-                    {"role": "system", "content": prompt["system"]},
-                    {"role": "user", "content": prompt["user"]}
-                ],
-                max_tokens=400,
-                temperature=0.7,
-                top_p=0.9,
-                stop=["</s>", "###"],
-                stream=False
-            )
-            
-            processing_time = time.time() - start_time
-            
-            # Log performance
-            self.performance_monitor.record_inference(
-                model_profile, processing_time, len(query)
-            )
-            
-            return {
-                "response": response["choices"][0]["message"]["content"],
-                "processing_time": processing_time,
-                "tokens_used": response["usage"]["total_tokens"],
-                "model_used": model_profile,
-                "context_used": context.get("summary", "")
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Generation error: {e}")
-            return {
-                "response": "I apologize, but I encountered an error processing your request.",
-                "error": str(e),
-                "processing_time": time.time() - start_time
-            }
-    
-    def build_advanced_prompt(self, query: str, history: List, context: Dict) -> Dict:
-        """Build sophisticated prompt with context and history"""
-        system_prompt = f"""You are the AI assistant for Saem's Tunes, a comprehensive music platform.
+from src.ai_system import SaemsTunesAISystem
+from src.supabase_integration import SupabaseIntegration
+from src.security_system import SecuritySystem
+from src.monitoring_system import ComprehensiveMonitor
 
-PLATFORM CONTEXT:
-- Music streaming and discovery service
-- Artist profiles and social features
-- Playlist creation and sharing capabilities
-- Music upload system for artists
-- Premium subscription features
+# Configuration
+class Config:
+    SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+    SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY", "")
+    MODEL_NAME = os.getenv("MODEL_NAME", "microsoft/Phi-3.5-mini-instruct")
+    HF_SPACE = os.getenv("HF_SPACE", "saemstunes/STA-AI")
+    PORT = int(os.getenv("PORT", 7860))
 
-CURRENT CONTEXT:
-{context.get('summary', 'General music platform information')}
+# Initialize systems
+print("🚀 Initializing Saem's Tunes AI System...")
 
-SPECIFIC DATA:
-- Songs: {context.get('song_count', 0)} available
-- Artists: {context.get('artist_count', 0)} registered  
-- Users: {context.get('user_count', 0)} active
-- Recent Activity: {context.get('recent_activity', 'Normal traffic')}
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-RESPONSE GUIDELINES:
-- Be helpful, passionate about music, and knowledgeable
-- Provide specific, actionable information when possible
-- Reference platform features when relevant
-- Keep responses under 200 words unless complex technical explanation needed
-- If unsure, offer to help find the answer through other means"""
+# Initialize components
+supabase_integration = SupabaseIntegration(Config.SUPABASE_URL, Config.SUPABASE_ANON_KEY)
+security_system = SecuritySystem()
+monitor = ComprehensiveMonitor()
 
-        # Include conversation history
-        user_content = query
-        if history:
-            history_context = "\n".join([f"Previous: {h[0]}" for h in history[-3:]])
-            user_content = f"{history_context}\nCurrent Question: {query}"
+# AI System will be initialized when needed to avoid startup delays
+ai_system = None
 
-        return {
-            "system": system_prompt,
-            "user": user_content
-        }
+def initialize_ai_system():
+    """Initialize AI system on first use"""
+    global ai_system
+    if ai_system is None:
+        print("🔄 Loading AI system...")
+        ai_system = SaemsTunesAISystem(supabase_integration, security_system, monitor)
+        print("✅ AI system loaded successfully")
+    return ai_system
 
-class ModelLoader:
-    """Advanced model loading and management"""
-    def __init__(self):
-        self.available_models = {}
-        self.scan_models()
+def chat_interface(message: str, history: List[List[str]]) -> str:
+    """Main chat interface for Gradio"""
+    try:
+        # Initialize AI system if needed
+        ai_system = initialize_ai_system()
         
-    def scan_models(self):
-        """Scan for available GGUF models"""
-        model_dir = "./models"
-        if not os.path.exists(model_dir):
-            os.makedirs(model_dir)
-            
-        for file in os.listdir(model_dir):
-            if file.endswith('.gguf'):
-                quant_type = self.extract_quant_type(file)
-                self.available_models[quant_type] = {
-                    "path": os.path.join(model_dir, file),
-                    "size": os.path.getsize(os.path.join(model_dir, file)),
-                    "modified": datetime.fromtimestamp(
-                        os.path.getmtime(os.path.join(model_dir, file))
-                    )
-                }
-    
-    def extract_quant_type(self, filename: str) -> str:
-        """Extract quantization type from filename"""
-        import re
-        match = re.search(r'\.([QBF]\d+_?[KSMXL]?)\.gguf', filename)
-        return match.group(1) if match else "unknown"
-
-class PerformanceMonitor:
-    """Comprehensive performance monitoring"""
-    def __init__(self):
-        self.inference_times = []
-        self.memory_usage = []
-        self.error_log = []
+        if not message.strip():
+            return "Please ask me anything about Saem's Tunes!"
         
-    def record_inference(self, model: str, time_taken: float, input_length: int):
-        """Record inference performance metrics"""
-        self.inference_times.append({
-            "timestamp": datetime.now(),
-            "model": model,
-            "time_taken": time_taken,
-            "input_length": input_length,
-            "memory_used": psutil.virtual_memory().used,
-            "cpu_percent": psutil.cpu_percent()
-        })
+        # Process the message
+        start_time = time.time()
+        response = ai_system.process_query(message, "gradio_user")
+        processing_time = time.time() - start_time
         
-    def get_performance_stats(self) -> Dict:
-        """Get comprehensive performance statistics"""
-        if not self.inference_times:
-            return {}
-            
-        times = [x["time_taken"] for x in self.inference_times[-100:]]
-        return {
-            "average_time": np.mean(times),
-            "max_time": np.max(times),
-            "min_time": np.min(times),
-            "total_inferences": len(self.inference_times),
-            "current_memory": psutil.virtual_memory().percent,
-            "current_cpu": psutil.cpu_percent()
-        }
-
-class SupabaseIntegration:
-    """Enhanced Supabase integration for music context"""
-    def __init__(self):
-        self.url = os.getenv('SUPABASE_URL', '')
-        self.key = os.getenv('SUPABASE_ANON_KEY', '')
-        self.headers = {
-            'apikey': self.key,
-            'Authorization': f'Bearer {self.key}',
-            'Content-Type': 'application/json'
-        }
+        # Add processing time to response
+        formatted_response = f"{response}\n\n_Generated in {processing_time:.1f}s_"
         
-    def get_enhanced_context(self, query: str) -> Dict:
-        """Get comprehensive context from Supabase"""
-        context = {
-            "songs": [],
-            "artists": [],
-            "stats": {},
-            "recent_activity": "",
-            "summary": ""
-        }
+        return formatted_response
         
-        try:
-            # Get platform statistics
-            stats = self.get_platform_stats()
-            context["stats"] = stats
-            
-            # Get relevant content based on query
-            if any(term in query.lower() for term in ['song', 'music', 'track']):
-                context["songs"] = self.search_songs(query)
-                
-            if any(term in query.lower() for term in ['artist', 'band', 'musician']):
-                context["artists"] = self.search_artists(query)
-                
-            # Generate summary
-            context["summary"] = self.generate_context_summary(context, query)
-            
-        except Exception as e:
-            context["summary"] = "Music platform context unavailable"
-            
-        return context
-    
-    def get_platform_stats(self) -> Dict:
-        """Get comprehensive platform statistics"""
-        # This would make actual API calls to Supabase
-        return {
-            "song_count": 15420,
-            "artist_count": 892,
-            "user_count": 28456,
-            "playlist_count": 8923,
-            "active_today": 1245
-        }
+    except Exception as e:
+        logger.error(f"Chat error: {e}")
+        return "I apologize, but I'm experiencing technical difficulties. Please try again later."
 
-# Initialize the AI system
-ai_system = SaemsTunesAISystem()
-
-# Gradio Interface
-def create_advanced_interface():
+def create_gradio_interface():
+    """Create the Gradio interface for Hugging Face Spaces"""
+    
     with gr.Blocks(
         theme=gr.themes.Soft(primary_hue="purple"),
-        title="Saem's Tunes AI Assistant Pro",
+        title="Saem's Tunes AI Assistant",
         css="""
         .gradio-container {
             font-family: 'Segoe UI', system-ui;
+            max-width: 800px;
+            margin: 0 auto;
         }
-        .performance-stats {
-            background: #f5f5f5;
-            padding: 10px;
-            border-radius: 5px;
-            margin: 10px 0;
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
         }
         """
     ) as demo:
         
         gr.Markdown("""
-        # 🎵 Saem's Tunes AI Assistant Pro
-        *Powered by Microsoft Phi-3.5-mini-instruct with Advanced Quantization*
+        <div class="header">
+            <h1>🎵 Saem's Tunes AI Assistant</h1>
+            <p>Powered by Microsoft Phi-3.5-mini-instruct • Built for music lovers</p>
+        </div>
         """)
         
+        gr.Markdown("""
+        **Welcome to Saem's Tunes AI!** I can help you with:
+        - Music discovery and recommendations
+        - Platform features and how-to guides  
+        - Artist information and profiles
+        - Technical support and FAQs
+        - Playlist creation and management
+        """)
+        
+        # Chat interface
+        chatbot = gr.Chatbot(
+            label="Saem's Tunes Chat",
+            height=500,
+            placeholder="Ask me anything about Saem's Tunes music platform...",
+            show_label=False
+        )
+        
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### Configuration")
-                model_selector = gr.Dropdown(
-                    choices=["fast (Q4_K_M)", "balanced (Q5_K_M)", "quality (Q8_0)"],
-                    value="fast (Q4_K_M)",
-                    label="Model Profile"
-                )
-                temperature = gr.Slider(0.1, 1.0, value=0.7, label="Creativity")
-                max_tokens = gr.Slider(100, 500, value=300, step=50, label="Max Response Length")
-                
-                # Performance stats
-                performance_html = gr.HTML()
-                update_stats_btn = gr.Button("Refresh Performance Stats")
-                
-            with gr.Column(scale=2):
-                chatbot = gr.Chatbot(
-                    height=500,
-                    placeholder="Ask me anything about Saem's Tunes music platform...",
-                    show_label=False
-                )
-                
-                with gr.Row():
-                    msg = gr.Textbox(
-                        placeholder="Type your question...",
-                        show_label=False,
-                        scale=4
-                    )
-                    send_btn = gr.Button("Send", variant="primary", scale=1)
-                
-                with gr.Row():
-                    clear_btn = gr.Button("Clear Chat")
-                    export_btn = gr.Button("Export Conversation")
+            msg = gr.Textbox(
+                placeholder="Type your question here...",
+                show_label=False,
+                scale=4,
+                container=False
+            )
+            submit = gr.Button("Send", variant="primary", scale=1)
         
-        # Quick actions
-        with gr.Accordion("Quick Actions", open=False):
-            with gr.Row():
-                gr.Button("Platform Features")
-                gr.Button("Artist Help")
-                gr.Button("Technical Support")
-                gr.Button("Premium Info")
+        # Quick examples
+        gr.Examples(
+            examples=[
+                "How do I create a playlist?",
+                "What are the premium features?",
+                "How do I upload my music?",
+                "Who are the trending artists?",
+                "How does the recommendation system work?",
+                "Can I share playlists with friends?"
+            ],
+            inputs=msg
+        )
         
-        # Performance monitoring section
-        with gr.Accordion("System Performance", open=False):
-            gr.Markdown("### Real-time Monitoring")
-            performance_plot = gr.Plot()
+        # Clear button
+        clear = gr.Button("Clear Chat")
         
         # Event handlers
-        def update_stats():
-            stats = ai_system.performance_monitor.get_performance_stats()
-            html = f"""
-            <div class="performance-stats">
-                <strong>System Performance:</strong><br>
-                Avg Response Time: {stats.get('average_time', 0):.2f}s<br>
-                Total Queries: {stats.get('total_inferences', 0)}<br>
-                Memory Usage: {stats.get('current_memory', 0):.1f}%<br>
-                CPU Usage: {stats.get('current_cpu', 0):.1f}%
-            </div>
-            """
-            return html
+        def user(user_message, chat_history):
+            return "", chat_history + [[user_message, None]]
+        
+        def bot(chat_history):
+            user_message = chat_history[-1][0]
+            bot_message = chat_interface(user_message, chat_history)
+            chat_history[-1][1] = bot_message
+            return chat_history
+        
+        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+            bot, chatbot, chatbot
+        )
+        submit.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+            bot, chatbot, chatbot
+        )
+        clear.click(lambda: None, None, chatbot, queue=False)
         
-        def respond(message, chat_history, model_profile, temp, tokens):
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666;">
+            <p>Powered by <strong>Microsoft Phi-3.5-mini-instruct</strong> • 
+            Built for <a href="https://www.saemstunes.com" target="_blank">Saem's Tunes</a></p>
+            <p>Model: Q4_K_M quantization • Context: 4K tokens • Response time: ~2-5s</p>
+        </div>
+        """)
+    
+    return demo
+
+# Health check endpoint for monitoring
+def health_check():
+    """Health check endpoint"""
+    health_status = {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "version": "1.0.0",
+        "systems": {
+            "supabase": supabase_integration.is_connected(),
+            "security": True,
+            "monitoring": True,
+            "ai_system": ai_system is not None
+        },
+        "resources": {
+            "cpu_percent": psutil.cpu_percent(),
+            "memory_percent": psutil.virtual_memory().percent,
+            "disk_percent": psutil.disk_usage('/').percent
+        }
+    }
+    return health_status
+
+# API endpoints for React frontend
+def setup_api_endpoints(demo):
+    """Setup API endpoints for React frontend"""
+    
+    @demo.app.post("/api/chat")
+    async def api_chat(request: dict):
+        """API endpoint for chat from React frontend"""
+        try:
+            message = request.get("message", "")
+            user_id = request.get("user_id", "anonymous")
+            conversation_id = request.get("conversation_id")
+            
             if not message.strip():
-                return "", chat_history
-                
-            # Extract model profile
-            profile = model_profile.split(" ")[0]
+                return {"error": "Message cannot be empty"}
+            
+            # Initialize AI system if needed
+            ai_system = initialize_ai_system()
             
-            # Generate response
-            result = ai_system.generate_response(message, chat_history, profile)
+            # Process query
+            start_time = time.time()
+            response = ai_system.process_query(message, user_id, conversation_id)
+            processing_time = time.time() - start_time
             
-            # Format response
-            bot_message = f"{result['response']}\n\n*Generated in {result['processing_time']:.2f}s using {model_profile}*"
+            return {
+                "response": response,
+                "processing_time": processing_time,
+                "conversation_id": conversation_id or f"conv_{int(time.time())}",
+                "timestamp": datetime.now().isoformat()
+            }
             
-            chat_history.append((message, bot_message))
-            return "", chat_history, update_stats()
-        
-        # Connect events
-        msg.submit(respond, [msg, chatbot, model_selector, temperature, max_tokens], 
-                  [msg, chatbot, performance_html])
-        send_btn.click(respond, [msg, chatbot, model_selector, temperature, max_tokens], 
-                      [msg, chatbot, performance_html])
-        update_stats_btn.click(update_stats, outputs=performance_html)
-        clear_btn.click(lambda: [], outputs=chatbot)
-        
-        # Initial stats
-        demo.load(update_stats, outputs=performance_html)
+        except Exception as e:
+            logger.error(f"API chat error: {e}")
+            return {"error": "Internal server error", "details": str(e)}
     
-    return demo
+    @demo.app.get("/api/health")
+    async def api_health():
+        """Health check API endpoint"""
+        return health_check()
+    
+    @demo.app.get("/api/models")
+    async def api_models():
+        """Get available models"""
+        return {
+            "available_models": ["microsoft/Phi-3.5-mini-instruct"],
+            "current_model": Config.MODEL_NAME,
+            "quantization": "Q4_K_M"
+        }
 
-# Initialize and launch
+# Main application
 if __name__ == "__main__":
-    print("🚀 Initializing Saem's Tunes AI System...")
+    print("🎵 Starting Saem's Tunes AI on Hugging Face Spaces...")
     
-    # Load models (in a separate thread to avoid blocking)
-    def load_models_async():
-        ai_system.load_models()
+    # Create Gradio interface
+    demo = create_gradio_interface()
     
-    loader_thread = threading.Thread(target=load_models_async)
-    loader_thread.start()
+    # Setup API endpoints
+    setup_api_endpoints(demo)
     
-    # Create and launch interface
-    demo = create_advanced_interface()
+    # Launch with Hugging Face Spaces configuration
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7860,
+        server_port=Config.PORT,
         share=True,
-        show_error=True
+        show_error=True,
+        debug=False
     )