Update src/ai_system.py

src/ai_system.py

@@ -1,82 +1,159 @@
 import os
 import time
 import logging
+import asyncio
 from datetime import datetime
-from typing import Dict, List, Optional, Any
-from llama_cpp import Llama
-from huggingface_hub import hf_hub_download
+from typing import Dict, List, Optional, Any, Tuple
+import json
+import requests
 
-from .supabase_integration import SupabaseIntegration
-from .security_system import SecuritySystem
+try:
+    from llama_cpp import Llama
+except ImportError:
+    Llama = None
+
+try:
+    from huggingface_hub import hf_hub_download
+except ImportError:
+    hf_hub_download = None
+
+from .supabase_integration import AdvancedSupabaseIntegration
+from .security_system import AdvancedSecuritySystem
 from .monitoring_system import ComprehensiveMonitor
 
 class SaemsTunesAISystem:
-    """Main AI system for Saem's Tunes"""
+    """
+    Main AI system for Saem's Tunes music education and streaming platform.
+    Handles user queries with context from the Supabase database.
+    """
     
-    def __init__(self, supabase_integration: SupabaseIntegration, 
-                 security_system: SecuritySystem, 
-                 monitor: ComprehensiveMonitor):
+    def __init__(
+        self, 
+        supabase_integration: AdvancedSupabaseIntegration,
+        security_system: AdvancedSecuritySystem,
+        monitor: ComprehensiveMonitor,
+        model_name: str = "microsoft/Phi-3.5-mini-instruct",
+        model_repo: str = "Thetima4/Phi-3.5-mini-instruct-Q4_K_M-GGUF",
+        model_file: str = "Phi-3.5-mini-instruct-q4_k_m.gguf",
+        max_response_length: int = 500,
+        temperature: float = 0.7,
+        top_p: float = 0.9
+    ):
         self.supabase = supabase_integration
         self.security = security_system
         self.monitor = monitor
+        self.model_name = model_name
+        self.model_repo = model_repo
+        self.model_file = model_file
+        self.max_response_length = max_response_length
+        self.temperature = temperature
+        self.top_p = top_p
+        
         self.model = None
         self.model_loaded = False
+        self.model_path = None
+        
         self.setup_logging()
         self.load_model()
     
     def setup_logging(self):
-        """Setup logging"""
+        """Setup logging for the AI system"""
         self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.INFO)
     
     def load_model(self):
         """Load the Phi-3.5-mini-instruct model"""
         try:
-            print("🔄 Loading Phi-3.5-mini-instruct model...")
+            self.logger.info(f"🔄 Loading {self.model_name} model...")
             
-            # Download model if not exists
-            model_path = hf_hub_download(
-                repo_id="Thetima4/Phi-3.5-mini-instruct-Q4_K_M-GGUF",
-                filename="Phi-3.5-mini-instruct-q4_k_m.gguf",
-                cache_dir="./models"
-            )
+            # Check if model file exists locally
+            local_path = f"./models/{self.model_file}"
+            if os.path.exists(local_path):
+                self.model_path = local_path
+                self.logger.info(f"✅ Found local model: {local_path}")
+            else:
+                # Download from Hugging Face Hub
+                if hf_hub_download is None:
+                    self.logger.error("❌ huggingface_hub not available for model download")
+                    return
+                
+                self.logger.info(f"📥 Downloading model from {self.model_repo}")
+                self.model_path = hf_hub_download(
+                    repo_id=self.model_repo,
+                    filename=self.model_file,
+                    cache_dir="./models",
+                    local_dir_use_symlinks=False
+                )
+                self.logger.info(f"✅ Model downloaded: {self.model_path}")
             
             # Load the model
+            if Llama is None:
+                self.logger.error("❌ llama-cpp-python not available for model loading")
+                return
+            
             self.model = Llama(
-                model_path=model_path,
+                model_path=self.model_path,
                 n_ctx=4096,  # Context window
                 n_threads=4,  # CPU threads
-                verbose=False
+                n_batch=512,
+                verbose=False,
+                use_mlock=False,
+                use_mmap=True
+            )
+            
+            # Test the model
+            test_response = self.model.create_completion(
+                "Hello", 
+                max_tokens=10,
+                temperature=0.1
             )
             
             self.model_loaded = True
-            print("✅ Model loaded successfully!")
+            self.logger.info("✅ Model loaded and tested successfully!")
             
         except Exception as e:
-            self.logger.error(f"Error loading model: {e}")
+            self.logger.error(f"❌ Error loading model: {e}")
             self.model_loaded = False
     
-    def process_query(self, query: str, user_id: str, conversation_id: Optional[str] = None) -> str:
-        """Process user query and generate response"""
+    def process_query(
+        self, 
+        query: str, 
+        user_id: str, 
+        conversation_id: Optional[str] = None
+    ) -> str:
+        """
+        Process user query and generate response with context from Supabase.
+        
+        Args:
+            query: User's question
+            user_id: Unique user identifier
+            conversation_id: Optional conversation ID for context
+            
+        Returns:
+            AI-generated response
+        """
         if not self.model_loaded:
-            return "AI system is currently unavailable. Please try again later."
+            self.logger.warning("Model not loaded, returning fallback response")
+            return self.get_fallback_response(query)
         
         try:
             start_time = time.time()
             
-            # Get context from Supabase
-            context = self.supabase.get_music_context(query)
+            # Get comprehensive context from Supabase
+            context = self.supabase.get_music_context(query, user_id)
             
-            # Build prompt
-            prompt = self.build_prompt(query, context)
+            # Build enhanced prompt with context
+            prompt = self.build_enhanced_prompt(query, context, user_id)
             
             # Generate response
             response = self.model.create_completion(
                 prompt,
-                max_tokens=500,
-                temperature=0.7,
-                top_p=0.9,
-                stop=["<|end|>", "</s>"],
-                echo=False
+                max_tokens=self.max_response_length,
+                temperature=self.temperature,
+                top_p=self.top_p,
+                stop=["<|end|>", "</s>", "###", "Human:", "Assistant:"],
+                echo=False,
+                stream=False
             )
             
             processing_time = time.time() - start_time
@@ -84,63 +161,235 @@ class SaemsTunesAISystem:
             # Extract response text
             response_text = response['choices'][0]['text'].strip()
             
+            # Clean up response
+            response_text = self.clean_response(response_text)
+            
             # Record metrics
-            self.monitor.record_inference({
-                'model_name': 'phi3.5-mini-Q4_K_M',
-                'processing_time_ms': processing_time * 1000,
-                'input_tokens': len(query.split()),
-                'output_tokens': len(response_text.split()),
-                'success': True,
-                'user_id': user_id,
-                'conversation_id': conversation_id
-            })
+            self.record_metrics(
+                query=query,
+                response=response_text,
+                processing_time=processing_time,
+                user_id=user_id,
+                conversation_id=conversation_id,
+                context_used=context,
+                success=True
+            )
+            
+            self.logger.info(f"✅ Query processed in {processing_time:.2f}s: {query[:50]}...")
             
             return response_text
             
         except Exception as e:
-            self.logger.error(f"Error processing query: {e}")
-            
-            # Record error
-            self.monitor.record_inference({
-                'model_name': 'phi3.5-mini-Q4_K_M',
-                'processing_time_ms': 0,
-                'input_tokens': len(query.split()),
-                'output_tokens': 0,
-                'success': False,
-                'error_message': str(e),
-                'user_id': user_id
-            })
-            
-            return "I apologize, but I encountered an error processing your request. Please try again."
+            self.logger.error(f"❌ Error processing query: {e}")
+            
+            # Record error metrics
+            self.record_metrics(
+                query=query,
+                response="",
+                processing_time=0,
+                user_id=user_id,
+                conversation_id=conversation_id,
+                error_message=str(e),
+                success=False
+            )
+            
+            return self.get_error_response(e)
     
-    def build_prompt(self, query: str, context: Dict) -> str:
-        """Build prompt for the model"""
+    def build_enhanced_prompt(
+        self, 
+        query: str, 
+        context: Dict[str, Any],
+        user_id: str
+    ) -> str:
+        """
+        Build comprehensive prompt with context from Saem's Tunes platform.
         
+        Args:
+            query: User's question
+            context: Context from Supabase database
+            user_id: User identifier for personalization
+            
+        Returns:
+            Formatted prompt for the model
+        """
+        
+        # System prompt with platform context
         system_prompt = f"""<|system|>
-You are the AI assistant for Saem's Tunes, a music streaming and discovery platform.
+You are the AI assistant for Saem's Tunes, a comprehensive music education and streaming platform.
+
+PLATFORM OVERVIEW:
+🎵 **Music Streaming**: {context.get('stats', {}).get('track_count', 0)}+ tracks, {context.get('stats', {}).get('artist_count', 0)}+ artists
+📚 **Education**: Courses, lessons, quizzes, and learning paths
+👥 **Community**: User profiles, favorites, social features
+🎨 **Creator Tools**: Music upload, artist analytics, promotion tools
+💎 **Premium**: Subscription-based premium features
 
-PLATFORM CONTEXT:
-- Music streaming service with {context.get('song_count', 0)} songs
-- {context.get('artist_count', 0)} artists and growing community
-- Features: Playlists, music uploads, social features, premium subscriptions
+PLATFORM STATISTICS:
+- Total Tracks: {context.get('stats', {}).get('track_count', 0)}
+- Total Artists: {context.get('stats', {}).get('artist_count', 0)} 
+- Total Users: {context.get('stats', {}).get('user_count', 0)}
+- Total Courses: {context.get('stats', {}).get('course_count', 0)}
 
 CURRENT CONTEXT:
-{context.get('summary', 'General music platform information')}
+{context.get('summary', 'General platform information')}
+
+POPULAR CONTENT:
+{self.format_popular_content(context)}
 
 RESPONSE GUIDELINES:
-- Be helpful, passionate about music, and knowledgeable
-- Provide specific, actionable information
-- Reference platform features when relevant
-- Keep responses concise but informative
-- If unsure, offer to help find the answer
+1. Be passionate about music and education
+2. Provide specific, actionable information
+3. Reference platform features when relevant
+4. Keep responses concise (under {self.max_response_length} words)
+5. Be encouraging and supportive
+6. If unsure, guide users to relevant platform sections
+7. Personalize responses when user context is available
+
+PLATFORM FEATURES TO MENTION:
+- Music streaming and discovery
+- Educational courses and learning paths
+- Playlist creation and sharing
+- Artist tools and music upload
+- Community features and social interaction
+- Premium subscription benefits
+- Mobile app availability
 
-Answer the user's question about Saem's Tunes:<|end|>
+ANSWER THE USER'S QUESTION:<|end|>
 """
         
+        # User query
         user_prompt = f"<|user|>\n{query}<|end|>\n<|assistant|>\n"
         
         return system_prompt + user_prompt
     
+    def format_popular_content(self, context: Dict[str, Any]) -> str:
+        """Format popular content for the prompt"""
+        content_lines = []
+        
+        # Popular tracks
+        if context.get('tracks'):
+            content_lines.append("🎵 Popular Tracks:")
+            for track in context['tracks'][:3]:
+                content_lines.append(f"  - {track.get('title', 'Unknown')} by {track.get('artist', 'Unknown')}")
+        
+        # Popular artists
+        if context.get('artists'):
+            content_lines.append("👨‍🎤 Popular Artists:")
+            for artist in context['artists'][:3]:
+                content_lines.append(f"  - {artist.get('name', 'Unknown')} ({artist.get('genre', 'Various')})")
+        
+        # Recent courses
+        if context.get('courses'):
+            content_lines.append("📚 Recent Courses:")
+            for course in context['courses'][:2]:
+                content_lines.append(f"  - {course.get('title', 'Unknown')} ({course.get('level', 'All Levels')})")
+        
+        return "\n".join(content_lines) if content_lines else "No specific content data available"
+    
+    def clean_response(self, response: str) -> str:
+        """Clean and format the AI response"""
+        # Remove any trailing incomplete sentences
+        if '.' in response:
+            response = response.rsplit('.', 1)[0] + '.'
+        
+        # Remove any markdown formatting if present
+        response = response.replace('**', '').replace('__', '')
+        
+        # Ensure response ends with proper punctuation
+        if response and response[-1] not in ['.', '!', '?']:
+            response += '.'
+        
+        return response.strip()
+    
+    def record_metrics(
+        self,
+        query: str,
+        response: str,
+        processing_time: float,
+        user_id: str,
+        conversation_id: Optional[str] = None,
+        context_used: Optional[Dict] = None,
+        error_message: Optional[str] = None,
+        success: bool = True
+    ):
+        """Record metrics for monitoring and analytics"""
+        metrics = {
+            'model_name': 'phi3.5-mini-Q4_K_M',
+            'processing_time_ms': processing_time * 1000,
+            'input_tokens': len(query.split()),
+            'output_tokens': len(response.split()) if response else 0,
+            'total_tokens': len(query.split()) + (len(response.split()) if response else 0),
+            'success': success,
+            'user_id': user_id,
+            'conversation_id': conversation_id,
+            'timestamp': datetime.now(),
+            'query_length': len(query),
+            'response_length': len(response) if response else 0
+        }
+        
+        if error_message:
+            metrics['error_message'] = error_message
+        
+        if context_used:
+            metrics['context_used'] = {
+                'has_tracks': bool(context_used.get('tracks')),
+                'has_artists': bool(context_used.get('artists')),
+                'has_courses': bool(context_used.get('courses')),
+                'context_summary': context_used.get('summary', '')
+            }
+        
+        self.monitor.record_inference(metrics)
+    
+    def get_fallback_response(self, query: str) -> str:
+        """Get fallback response when model is unavailable"""
+        fallback_responses = [
+            "I'd love to help you with that! Our platform offers comprehensive music streaming and education features. ",
+            "That's a great question about Saem's Tunes! We have extensive music content and educational resources available. ",
+            "I appreciate your question about our music platform! Let me share some information about our features. "
+        ]
+        
+        # Add context-specific fallbacks
+        query_lower = query.lower()
+        
+        if any(term in query_lower for term in ['playlist', 'create', 'make']):
+            base_response = "You can create playlists by going to the Library section and clicking 'Create New Playlist'. "
+        elif any(term in query_lower for term in ['course', 'learn', 'education']):
+            base_response = "We offer various music courses for different skill levels in our Education section. "
+        elif any(term in query_lower for term in ['upload', 'artist', 'create']):
+            base_response = "Artists can upload their music through the Creator Studio after verification. "
+        elif any(term in query_lower for term in ['premium', 'subscribe', 'payment']):
+            base_response = "Our premium subscription offers ad-free listening, offline downloads, and exclusive content. "
+        else:
+            base_response = "Our platform combines music streaming with comprehensive educational resources. "
+        
+        import random
+        return base_response + random.choice(fallback_responses)
+    
+    def get_error_response(self, error: Exception) -> str:
+        """Get user-friendly error response"""
+        error_responses = [
+            "I apologize, but I'm having trouble accessing the full information right now. ",
+            "I'm experiencing some technical difficulties at the moment. ",
+            "I'm unable to process your request completely due to a temporary issue. "
+        ]
+        
+        base_response = "Please try again in a few moments, or contact support if the issue persists."
+        
+        import random
+        return random.choice(error_responses) + base_response
+    
     def is_healthy(self) -> bool:
-        """Check if AI system is healthy"""
-        return self.model_loaded and self.supabase.is_connected()
+        """Check if AI system is healthy and ready"""
+        return self.model_loaded and self.supabase.is_connected()
+    
+    def get_system_info(self) -> Dict[str, Any]:
+        """Get system information for monitoring"""
+        return {
+            "model_loaded": self.model_loaded,
+            "model_name": self.model_name,
+            "model_path": self.model_path,
+            "max_response_length": self.max_response_length,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "supabase_connected": self.supabase.is_connected()
+        }