Update src/ai_system.py

src/ai_system.py

@@ -6,16 +6,19 @@ from datetime import datetime
 from typing import Dict, List, Optional, Any, Tuple
 import json
 import requests
+import hashlib
 
 try:
     from llama_cpp import Llama
 except ImportError:
     Llama = None
+    print("Warning: llama-cpp-python not available. AI functionality will be limited.")
 
 try:
     from huggingface_hub import hf_hub_download
 except ImportError:
     hf_hub_download = None
+    print("Warning: huggingface_hub not available. Model download will not work.")
 
 from .supabase_integration import AdvancedSupabaseIntegration
 from .security_system import AdvancedSecuritySystem
@@ -37,7 +40,8 @@ class SaemsTunesAISystem:
         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
+        top_p: float = 0.9,
+        context_window: int = 4096
     ):
         self.supabase = supabase_integration
         self.security = security_system
@@ -48,10 +52,15 @@ class SaemsTunesAISystem:
         self.max_response_length = max_response_length
         self.temperature = temperature
         self.top_p = top_p
+        self.context_window = context_window
         
         self.model = None
         self.model_loaded = False
         self.model_path = None
+        self.model_hash = None
+        
+        self.conversation_history = {}
+        self.response_cache = {}
         
         self.setup_logging()
         self.load_model()
@@ -66,13 +75,22 @@ class SaemsTunesAISystem:
         try:
             self.logger.info(f"🔄 Loading {self.model_name} model...")
             
-            # Check if model file exists locally
-            local_path = f"./models/{self.model_file}"
+            model_dir = "./models"
+            os.makedirs(model_dir, exist_ok=True)
+            
+            local_path = os.path.join(model_dir, self.model_file)
+            
             if os.path.exists(local_path):
                 self.model_path = local_path
                 self.logger.info(f"✅ Found local model: {local_path}")
+                
+                with open(local_path, 'rb') as f:
+                    file_hash = hashlib.md5()
+                    while chunk := f.read(8192):
+                        file_hash.update(chunk)
+                    self.model_hash = file_hash.hexdigest()
+                    
             else:
-                # Download from Hugging Face Hub
                 if hf_hub_download is None:
                     self.logger.error("❌ huggingface_hub not available for model download")
                     return
@@ -81,35 +99,46 @@ class SaemsTunesAISystem:
                 self.model_path = hf_hub_download(
                     repo_id=self.model_repo,
                     filename=self.model_file,
-                    cache_dir="./models",
+                    cache_dir=model_dir,
                     local_dir_use_symlinks=False
                 )
                 self.logger.info(f"✅ Model downloaded: {self.model_path}")
+                
+                with open(self.model_path, 'rb') as f:
+                    file_hash = hashlib.md5()
+                    while chunk := f.read(8192):
+                        file_hash.update(chunk)
+                    self.model_hash = file_hash.hexdigest()
             
-            # Load the model
             if Llama is None:
                 self.logger.error("❌ llama-cpp-python not available for model loading")
                 return
             
             self.model = Llama(
                 model_path=self.model_path,
-                n_ctx=4096,  # Context window
-                n_threads=4,  # CPU threads
+                n_ctx=self.context_window,
+                n_threads=min(4, os.cpu_count() or 1),
                 n_batch=512,
                 verbose=False,
                 use_mlock=False,
-                use_mmap=True
+                use_mmap=True,
+                low_vram=False
             )
             
-            # Test the model
             test_response = self.model.create_completion(
-                "Hello", 
+                "Test", 
                 max_tokens=10,
-                temperature=0.1
+                temperature=0.1,
+                stop=["<|end|>", "</s>"]
             )
             
-            self.model_loaded = True
-            self.logger.info("✅ Model loaded and tested successfully!")
+            if test_response and 'choices' in test_response and len(test_response['choices']) > 0:
+                self.model_loaded = True
+                self.logger.info("✅ Model loaded and tested successfully!")
+                self.logger.info(f"📊 Model info: {self.model_path} (Hash: {self.model_hash})")
+            else:
+                self.logger.error("❌ Model test failed")
+                self.model_loaded = False
             
         except Exception as e:
             self.logger.error(f"❌ Error loading model: {e}")
@@ -136,35 +165,36 @@ class SaemsTunesAISystem:
             self.logger.warning("Model not loaded, returning fallback response")
             return self.get_fallback_response(query)
         
+        cache_key = f"{user_id}:{hash(query)}"
+        if cache_key in self.response_cache:
+            cached_response, timestamp = self.response_cache[cache_key]
+            if time.time() - timestamp < 300:
+                self.logger.info("Returning cached response")
+                return cached_response
+        
         try:
             start_time = time.time()
             
-            # Get comprehensive context from Supabase
             context = self.supabase.get_music_context(query, user_id)
             
-            # Build enhanced prompt with context
-            prompt = self.build_enhanced_prompt(query, context, user_id)
+            prompt = self.build_enhanced_prompt(query, context, user_id, conversation_id)
             
-            # Generate response
             response = self.model.create_completion(
                 prompt,
                 max_tokens=self.max_response_length,
                 temperature=self.temperature,
                 top_p=self.top_p,
-                stop=["<|end|>", "</s>", "###", "Human:", "Assistant:"],
+                stop=["<|end|>", "</s>", "###", "Human:", "Assistant:", "<|endoftext|>"],
                 echo=False,
                 stream=False
             )
             
             processing_time = time.time() - start_time
             
-            # Extract response text
             response_text = response['choices'][0]['text'].strip()
             
-            # Clean up response
             response_text = self.clean_response(response_text)
             
-            # Record metrics
             self.record_metrics(
                 query=query,
                 response=response_text,
@@ -175,6 +205,11 @@ class SaemsTunesAISystem:
                 success=True
             )
             
+            self.response_cache[cache_key] = (response_text, time.time())
+            
+            if conversation_id:
+                self.update_conversation_history(conversation_id, query, response_text)
+            
             self.logger.info(f"✅ Query processed in {processing_time:.2f}s: {query[:50]}...")
             
             return response_text
@@ -182,7 +217,6 @@ class SaemsTunesAISystem:
         except Exception as e:
             self.logger.error(f"❌ Error processing query: {e}")
             
-            # Record error metrics
             self.record_metrics(
                 query=query,
                 response="",
@@ -199,21 +233,19 @@ class SaemsTunesAISystem:
         self, 
         query: str, 
         context: Dict[str, Any],
-        user_id: str
+        user_id: str,
+        conversation_id: Optional[str] = None
     ) -> 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
         """
+        conversation_context = ""
+        if conversation_id and conversation_id in self.conversation_history:
+            recent_messages = self.conversation_history[conversation_id][-3:]
+            for msg in recent_messages:
+                role = "User" if msg["role"] == "user" else "Assistant"
+                conversation_context += f"{role}: {msg['content']}\n"
         
-        # System prompt with platform context
         system_prompt = f"""<|system|>
 You are the AI assistant for Saem's Tunes, a comprehensive music education and streaming platform.
 
@@ -229,6 +261,7 @@ PLATFORM STATISTICS:
 - 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)}
+- Active Playlists: {context.get('stats', {}).get('playlist_count', 0)}
 
 CURRENT CONTEXT:
 {context.get('summary', 'General platform information')}
@@ -236,14 +269,23 @@ CURRENT CONTEXT:
 POPULAR CONTENT:
 {self.format_popular_content(context)}
 
+USER CONTEXT:
+{self.format_user_context(context.get('user_context', {}))}
+
+CONVERSATION HISTORY:
+{conversation_context if conversation_context else 'No recent conversation history'}
+
 RESPONSE GUIDELINES:
 1. Be passionate about music and education
-2. Provide specific, actionable information
+2. Provide specific, actionable information about Saem's Tunes
 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
+8. Always maintain a professional, helpful tone
+9. Focus on music education, streaming, and platform features
+10. Avoid discussing unrelated topics
 
 PLATFORM FEATURES TO MENTION:
 - Music streaming and discovery
@@ -253,11 +295,12 @@ PLATFORM FEATURES TO MENTION:
 - Community features and social interaction
 - Premium subscription benefits
 - Mobile app availability
+- Music recommendations
+- Learning progress tracking
 
-ANSWER THE USER'S QUESTION:<|end|>
+ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
 """
         
-        # User query
         user_prompt = f"<|user|>\n{query}<|end|>\n<|assistant|>\n"
         
         return system_prompt + user_prompt
@@ -266,40 +309,105 @@ ANSWER THE USER'S QUESTION:<|end|>
         """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')}")
+                title = track.get('title', 'Unknown Track')
+                artist = track.get('artist', 'Unknown Artist')
+                genre = track.get('genre', 'Various')
+                plays = track.get('plays', 0)
+                content_lines.append(f"  - {title} by {artist} ({genre}) - {plays} plays")
         
-        # 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')})")
+                name = artist.get('name', 'Unknown Artist')
+                genre = artist.get('genre', 'Various')
+                followers = artist.get('followers', 0)
+                verified = "✓" if artist.get('verified') else ""
+                content_lines.append(f"  - {name} {verified} ({genre}) - {followers} followers")
         
-        # 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')})")
+                title = course.get('title', 'Unknown Course')
+                instructor = course.get('instructor', 'Unknown Instructor')
+                level = course.get('level', 'All Levels')
+                students = course.get('students', 0)
+                content_lines.append(f"  - {title} by {instructor} ({level}) - {students} students")
         
         return "\n".join(content_lines) if content_lines else "No specific content data available"
     
+    def format_user_context(self, user_context: Dict[str, Any]) -> str:
+        """Format user context for the prompt"""
+        if not user_context:
+            return "No specific user context available"
+        
+        user_lines = []
+        
+        if user_context.get('is_premium'):
+            user_lines.append("• User has premium subscription")
+        
+        if user_context.get('favorite_genres'):
+            genres = user_context['favorite_genres'][:3]
+            user_lines.append(f"• Favorite genres: {', '.join(genres)}")
+        
+        if user_context.get('recent_activity'):
+            activity = user_context['recent_activity'][:2]
+            user_lines.append(f"• Recent activity: {', '.join(activity)}")
+        
+        if user_context.get('learning_progress'):
+            progress = user_context['learning_progress']
+            user_lines.append(f"• Learning progress: {progress.get('completed_lessons', 0)} lessons completed")
+        
+        return "\n".join(user_lines) if user_lines else "Basic user account"
+    
     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] + '.'
+        if not response:
+            return "I apologize, but I couldn't generate a response. Please try again."
+        
+        response = response.strip()
         
-        # Remove any markdown formatting if present
-        response = response.replace('**', '').replace('__', '')
+        if response.startswith("I'm sorry") or response.startswith("I apologize"):
+            if len(response) < 20:
+                response = "I'd be happy to help you with that! Our platform offers comprehensive music education and streaming features."
         
-        # Ensure response ends with proper punctuation
-        if response and response[-1] not in ['.', '!', '?']:
+        stop_phrases = [
+            "<|end|>", "</s>", "###", "Human:", "Assistant:", 
+            "<|endoftext|>", "<|assistant|>", "<|user|>"
+        ]
+        
+        for phrase in stop_phrases:
+            if phrase in response:
+                response = response.split(phrase)[0].strip()
+        
+        sentences = response.split('. ')
+        if len(sentences) > 1:
+            response = '. '.join(sentences[:-1]) + '.' if not sentences[-1].endswith('.') else '. '.join(sentences)
+        
+        if not response.endswith(('.', '!', '?')):
             response += '.'
         
-        return response.strip()
+        response = response.replace('**', '').replace('__', '').replace('*', '')
+        
+        if len(response) > self.max_response_length:
+            response = response[:self.max_response_length].rsplit(' ', 1)[0] + '...'
+        
+        return response
+    
+    def update_conversation_history(self, conversation_id: str, query: str, response: str):
+        """Update conversation history for context"""
+        if conversation_id not in self.conversation_history:
+            self.conversation_history[conversation_id] = []
+        
+        self.conversation_history[conversation_id].extend([
+            {"role": "user", "content": query, "timestamp": datetime.now()},
+            {"role": "assistant", "content": response, "timestamp": datetime.now()}
+        ])
+        
+        if len(self.conversation_history[conversation_id]) > 10:
+            self.conversation_history[conversation_id] = self.conversation_history[conversation_id][-10:]
     
     def record_metrics(
         self,
@@ -324,7 +432,8 @@ ANSWER THE USER'S QUESTION:<|end|>
             'conversation_id': conversation_id,
             'timestamp': datetime.now(),
             'query_length': len(query),
-            'response_length': len(response) if response else 0
+            'response_length': len(response) if response else 0,
+            'model_hash': self.model_hash
         }
         
         if error_message:
@@ -335,52 +444,48 @@ ANSWER THE USER'S QUESTION:<|end|>
                 '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', '')
+                'has_user_context': bool(context_used.get('user_context')),
+                'context_summary': context_used.get('summary', '')[:100]
             }
         
         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. "
+            return "You can create playlists by navigating to your Library and selecting 'Create New Playlist'. You can add tracks, customize the order, and share with friends. Premium users can create collaborative playlists."
+        
+        elif any(term in query_lower for term in ['course', 'learn', 'education', 'lesson']):
+            return "We offer comprehensive music education courses for all skill levels. Visit the Education section to browse courses in music theory, instrument mastery, production techniques, and more. Each course includes video lessons, exercises, and progress tracking."
+        
+        elif any(term in query_lower for term in ['upload', 'artist', 'creator']):
+            return "Artists can upload their music through the Creator Studio after account verification. You'll need to provide track files, metadata, and cover art. Once uploaded, your music will be available across our platform with analytics and revenue sharing."
+        
         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. "
+            return "Our premium subscription offers ad-free listening, offline downloads, high-quality audio, exclusive content, and advanced features. You can subscribe monthly or annually with cancel-anytime flexibility."
+        
+        elif any(term in query_lower for term in ['problem', 'issue', 'help', 'support']):
+            return "I'd be happy to help troubleshoot any issues. Please describe the problem you're experiencing, or visit our Help Center for detailed guides and contact information for our support team."
         
-        import random
-        return base_response + random.choice(fallback_responses)
+        else:
+            return "I'd love to help you with Saem's Tunes! Our platform combines music streaming with comprehensive education features. You can discover new music, learn instruments, connect with artists, and develop your musical skills—all in one place. What specific aspect would you like to know more about?"
     
     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. "
-        ]
+        error_str = str(error).lower()
         
-        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
+        if "memory" in error_str or "gpu" in error_str:
+            return "I'm experiencing high resource usage right now. Please try a simpler query or wait a moment before trying again."
+        elif "timeout" in error_str or "slow" in error_str:
+            return "The response is taking longer than expected. Please try again with a more specific question about Saem's Tunes features."
+        else:
+            return "I apologize, but I'm having technical difficulties right now. Please try again in a few moments, or contact support if the issue persists. Our team is constantly working to improve the AI assistant."
     
     def is_healthy(self) -> bool:
         """Check if AI system is healthy and ready"""
-        return self.model_loaded and self.supabase.is_connected()
+        return self.model_loaded and self.model is not None and self.supabase.is_connected()
     
     def get_system_info(self) -> Dict[str, Any]:
         """Get system information for monitoring"""
@@ -388,8 +493,34 @@ ANSWER THE USER'S QUESTION:<|end|>
             "model_loaded": self.model_loaded,
             "model_name": self.model_name,
             "model_path": self.model_path,
+            "model_hash": self.model_hash,
             "max_response_length": self.max_response_length,
             "temperature": self.temperature,
             "top_p": self.top_p,
-            "supabase_connected": self.supabase.is_connected()
+            "context_window": self.context_window,
+            "supabase_connected": self.supabase.is_connected(),
+            "conversations_active": len(self.conversation_history),
+            "cache_size": len(self.response_cache)
+        }
+    
+    def clear_cache(self, user_id: Optional[str] = None):
+        """Clear response cache"""
+        if user_id:
+            keys_to_remove = [k for k in self.response_cache.keys() if k.startswith(f"{user_id}:")]
+            for key in keys_to_remove:
+                del self.response_cache[key]
+        else:
+            self.response_cache.clear()
+    
+    def get_model_stats(self) -> Dict[str, Any]:
+        """Get model statistics"""
+        if not self.model_loaded:
+            return {"error": "Model not loaded"}
+        
+        return {
+            "context_size": self.context_window,
+            "parameters": "3.8B",
+            "quantization": "Q4_K_M",
+            "model_size_gb": round(os.path.getsize(self.model_path) / (1024**3), 2) if self.model_path else 0,
+            "cache_hit_rate": len(self.response_cache) / (len(self.response_cache) + len(self.conversation_history)) if self.conversation_history else 0
         }