Update src/ai_system.py

src/ai_system.py

@@ -7,6 +7,7 @@ from typing import Dict, List, Optional, Any, Tuple
 import json
 import requests
 import hashlib
+import gc
 
 try:
     from llama_cpp import Llama
@@ -15,9 +16,10 @@ except ImportError:
     print("Warning: llama-cpp-python not available. AI functionality will be limited.")
 
 try:
-    from huggingface_hub import hf_hub_download
+    from huggingface_hub import hf_hub_download, snapshot_download
 except ImportError:
     hf_hub_download = None
+    snapshot_download = None
     print("Warning: huggingface_hub not available. Model download will not work.")
 
 from .supabase_integration import AdvancedSupabaseIntegration
@@ -27,164 +29,271 @@ from .monitoring_system import ComprehensiveMonitor
 class SaemsTunesAISystem:
     """
     Main AI system for Saem's Tunes music education and streaming platform.
-    Handles user queries with context from the Supabase database.
+    Supports multiple GGUF models with intelligent model switching and context-aware responses.
     """
     
+    # Model configurations for all three LLM options
+    MODEL_CONFIGS = {
+        'TinyLlama-1.1B-Chat': {
+            'model_repo': "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+            'model_file': "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf",
+            'max_response_length': 200,
+            'temperature': 0.7,
+            'top_p': 0.9,
+            'context_window': 2048,
+            'description': 'Fastest response, basic conversations'
+        },
+        'Phi-2': {
+            'model_repo': "TheBloke/phi-2-GGUF",
+            'model_file': "phi-2.Q4_K_M.gguf", 
+            'max_response_length': 250,
+            'temperature': 0.7,
+            'top_p': 0.9,
+            'context_window': 2048,
+            'description': 'Good balance of speed and quality'
+        },
+        'Qwen-1.8B-Chat': {
+            'model_repo': "TheBloke/Qwen1.5-1.8B-Chat-GGUF",
+            'model_file': "qwen1.5-1.8b-chat-q4_k_m.gguf",
+            'max_response_length': 300,
+            'temperature': 0.7,
+            'top_p': 0.9,
+            'context_window': 4096,
+            'description': 'Best for complex conversations'
+        }
+    }
+    
     def __init__(
         self, 
         supabase_integration: AdvancedSupabaseIntegration,
         security_system: AdvancedSecuritySystem,
         monitor: ComprehensiveMonitor,
-        model_name: str = "microsoft/Phi-3.5-mini-instruct",
-        model_repo: str = "bartowski/Phi-3.5-mini-instruct-GGUF",
-        model_file: str = "Phi-3.5-mini-instruct-Q4_K_M.gguf",
-        max_response_length: int = 300,
-        temperature: float = 0.7,
-        top_p: float = 0.9,
-        context_window: int = 4096
+        default_model: str = 'TinyLlama-1.1B-Chat'
     ):
         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.context_window = context_window
-        
-        self.model = None
+        
+        # Model management
+        self.available_models = {}
+        self.current_model = None
+        self.current_model_name = default_model
         self.model_loaded = False
-        self.model_path = None
-        self.model_hash = None
         
+        # Response management
         self.conversation_history = {}
         self.response_cache = {}
+        self.model_usage_stats = {}
         
         self.setup_logging()
-        self.load_model()
+        self.initialize_models()
     
     def setup_logging(self):
-        """Setup logging for the AI system"""
-        self.logger = logging.getLogger(__name__)
+        """Setup comprehensive logging for the AI system"""
+        self.logger = logging.getLogger('SaemsTunesAI')
         self.logger.setLevel(logging.INFO)
+        
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
     
-    def load_model(self):
-        """Load the Phi-3.5-mini-instruct model"""
+    def initialize_models(self):
+        """Initialize all available models"""
+        self.logger.info("🔄 Initializing AI models for Saem's Tunes...")
+        
+        for model_name, config in self.MODEL_CONFIGS.items():
+            try:
+                self.logger.info(f"📦 Setting up {model_name}...")
+                model_path = self.download_or_get_model(
+                    config['model_repo'], 
+                    config['model_file']
+                )
+                
+                if model_path and Llama is not None:
+                    self.available_models[model_name] = {
+                        'model': Llama(
+                            model_path=model_path,
+                            n_ctx=config['context_window'],
+                            n_threads=min(6, os.cpu_count() or 2),
+                            n_batch=512,
+                            verbose=False,
+                            use_mlock=False,
+                            use_mmap=True,
+                            low_vram=False
+                        ),
+                        'config': config,
+                        'path': model_path,
+                        'loaded': True
+                    }
+                    self.logger.info(f"✅ {model_name} initialized successfully")
+                else:
+                    self.available_models[model_name] = {
+                        'model': None,
+                        'config': config,
+                        'path': model_path,
+                        'loaded': False
+                    }
+                    self.logger.warning(f"⚠️ {model_name} setup incomplete")
+                    
+            except Exception as e:
+                self.logger.error(f"❌ Failed to initialize {model_name}: {e}")
+                self.available_models[model_name] = {
+                    'model': None,
+                    'config': config,
+                    'path': None,
+                    'loaded': False
+                }
+        
+        # Set current model
+        if self.current_model_name in self.available_models:
+            self.current_model = self.available_models[self.current_model_name]
+            self.model_loaded = self.current_model['loaded']
+            self.logger.info(f"🎯 Current model set to: {self.current_model_name}")
+        else:
+            self.logger.error("❌ Default model not available")
+    
+    def download_or_get_model(self, model_repo: str, model_file: str) -> Optional[str]:
+        """Download model from Hugging Face or use local if available"""
         try:
-            self.logger.info(f"🔄 Loading {self.model_name} model...")
-            
             model_dir = "./models"
             os.makedirs(model_dir, exist_ok=True)
             
-            local_path = os.path.join(model_dir, self.model_file)
+            local_path = os.path.join(model_dir, model_file)
             
+            # Check if model already exists locally
             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()
+                # Verify file integrity
+                file_size = os.path.getsize(local_path)
+                if file_size > 1000000:  # At least 1MB
+                    with open(local_path, 'rb') as f:
+                        file_hash = hashlib.md5()
+                        while chunk := f.read(8192):
+                            file_hash.update(chunk)
+                        model_hash = file_hash.hexdigest()
                     
-            else:
-                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=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()
+                    self.logger.info(f"📊 Model verified: {local_path} (Size: {file_size/(1024**3):.2f}GB, Hash: {model_hash[:16]}...)")
+                    return local_path
+                else:
+                    self.logger.warning("⚠️ Local model file seems corrupted, re-downloading...")
+                    os.remove(local_path)
             
-            if Llama is None:
-                self.logger.error("❌ llama-cpp-python not available for model loading")
-                return
+            # Download from Hugging Face
+            if hf_hub_download is None:
+                self.logger.error("❌ huggingface_hub not available for model download")
+                return None
             
-            self.model = Llama(
-                model_path=self.model_path,
-                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,
-                low_vram=False
-            )
+            self.logger.info(f"📥 Downloading {model_file} from {model_repo}...")
             
-            test_response = self.model.create_completion(
-                "Test", 
-                max_tokens=10,
-                temperature=0.1,
-                stop=["<|end|>", "</s>"]
+            start_time = time.time()
+            model_path = hf_hub_download(
+                repo_id=model_repo,
+                filename=model_file,
+                cache_dir=model_dir,
+                local_dir=model_dir,
+                local_dir_use_symlinks=False,
+                resume_download=True
             )
             
-            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
+            download_time = time.time() - start_time
+            file_size = os.path.getsize(model_path) / (1024**3)  # GB
+            
+            self.logger.info(f"✅ Download completed: {model_path} ({file_size:.2f}GB in {download_time:.1f}s)")
+            return model_path
             
         except Exception as e:
-            self.logger.error(f"❌ Error loading model: {e}")
-            self.model_loaded = False
+            self.logger.error(f"❌ Error downloading model {model_file}: {e}")
+            return None
+    
+    def switch_model(self, model_name: str) -> bool:
+        """Switch to a different model"""
+        if model_name not in self.available_models:
+            self.logger.error(f"❌ Model {model_name} not available")
+            return False
+        
+        if not self.available_models[model_name]['loaded']:
+            self.logger.error(f"❌ Model {model_name} not loaded properly")
+            return False
+        
+        self.current_model_name = model_name
+        self.current_model = self.available_models[model_name]
+        self.model_loaded = True
+        
+        self.logger.info(f"🔄 Switched to model: {model_name}")
+        return True
     
     def process_query(
         self, 
         query: str, 
         user_id: str, 
-        conversation_id: Optional[str] = None
-    ) -> str:
+        conversation_id: Optional[str] = None,
+        model_name: Optional[str] = None
+    ) -> Dict[str, Any]:
         """
-        Process user query and generate response with context from Supabase.
+        Process user query with context from Saem's Tunes platform.
         
         Args:
             query: User's question
             user_id: Unique user identifier
             conversation_id: Optional conversation ID for context
+            model_name: Specific model to use for this query
             
         Returns:
-            AI-generated response
+            Dictionary containing response and metadata
         """
+        start_time = time.time()
+        
+        # Switch model if requested
+        if model_name and model_name != self.current_model_name:
+            if not self.switch_model(model_name):
+                self.logger.warning(f"⚠️ Failed to switch to {model_name}, using current model")
+        
         if not self.model_loaded:
             self.logger.warning("Model not loaded, returning fallback response")
-            return self.get_fallback_response(query)
+            fallback_response = self.get_fallback_response(query)
+            return {
+                'response': fallback_response,
+                'processing_time': time.time() - start_time,
+                'model_used': 'fallback',
+                'success': False,
+                'conversation_id': conversation_id
+            }
         
-        cache_key = f"{user_id}:{hash(query)}"
+        # Check cache first
+        cache_key = f"{user_id}:{hash(query)}:{self.current_model_name}"
         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
+            if time.time() - timestamp < 300:  # 5 minute cache
+                self.logger.info("💾 Returning cached response")
+                return {
+                    'response': cached_response,
+                    'processing_time': 0.01,
+                    'model_used': self.current_model_name,
+                    'success': True,
+                    'cached': True,
+                    'conversation_id': conversation_id
+                }
         
         try:
-            start_time = time.time()
-            
+            # Get comprehensive context from Supabase
             context = self.supabase.get_music_context(query, user_id)
             
-            prompt = self.build_enhanced_prompt(query, context, user_id, conversation_id)
+            # Build model-specific prompt
+            prompt = self.build_model_specific_prompt(query, context, user_id, conversation_id)
             
-            response = self.model.create_completion(
+            # Generate response
+            model_config = self.current_model['config']
+            response = self.current_model['model'].create_completion(
                 prompt,
-                max_tokens=self.max_response_length,
-                temperature=self.temperature,
-                top_p=self.top_p,
-                stop=["<|end|>", "</s>", "###", "Human:", "Assistant:", "<|endoftext|>"],
+                max_tokens=model_config['max_response_length'],
+                temperature=model_config['temperature'],
+                top_p=model_config['top_p'],
+                stop=self.get_model_stop_tokens(self.current_model_name),
                 echo=False,
                 stream=False
             )
@@ -192,44 +301,64 @@ class SaemsTunesAISystem:
             processing_time = time.time() - start_time
             
             response_text = response['choices'][0]['text'].strip()
+            response_text = self.clean_response(response_text, self.current_model_name)
             
-            response_text = self.clean_response(response_text)
-            
+            # Update metrics
             self.record_metrics(
                 query=query,
                 response=response_text,
                 processing_time=processing_time,
                 user_id=user_id,
                 conversation_id=conversation_id,
+                model_used=self.current_model_name,
                 context_used=context,
                 success=True
             )
             
+            # Cache response
             self.response_cache[cache_key] = (response_text, time.time())
             
+            # Update conversation history
             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]}...")
+            self.logger.info(f"✅ Query processed in {processing_time:.2f}s using {self.current_model_name}")
             
-            return response_text
+            return {
+                'response': response_text,
+                'processing_time': processing_time,
+                'model_used': self.current_model_name,
+                'success': True,
+                'conversation_id': conversation_id,
+                'context_used': context.get('summary', 'General platform context')
+            }
             
         except Exception as e:
-            self.logger.error(f"❌ Error processing query: {e}")
+            processing_time = time.time() - start_time
+            self.logger.error(f"❌ Error processing query with {self.current_model_name}: {e}")
             
             self.record_metrics(
                 query=query,
                 response="",
-                processing_time=0,
+                processing_time=processing_time,
                 user_id=user_id,
                 conversation_id=conversation_id,
+                model_used=self.current_model_name,
                 error_message=str(e),
                 success=False
             )
             
-            return self.get_error_response(e)
+            error_response = self.get_error_response(e)
+            return {
+                'response': error_response,
+                'processing_time': processing_time,
+                'model_used': self.current_model_name,
+                'success': False,
+                'error': str(e),
+                'conversation_id': conversation_id
+            }
     
-    def build_enhanced_prompt(
+    def build_model_specific_prompt(
         self, 
         query: str, 
         context: Dict[str, Any],
@@ -237,7 +366,7 @@ class SaemsTunesAISystem:
         conversation_id: Optional[str] = None
     ) -> str:
         """
-        Build comprehensive prompt with context from Saem's Tunes platform.
+        Build comprehensive prompt tailored to specific model requirements.
         """
         conversation_context = ""
         if conversation_id and conversation_id in self.conversation_history:
@@ -246,19 +375,101 @@ class SaemsTunesAISystem:
                 role = "User" if msg["role"] == "user" else "Assistant"
                 conversation_context += f"{role}: {msg['content']}\n"
         
+        # Model-specific prompt templates
+        if self.current_model_name == 'TinyLlama-1.1B-Chat':
+            return self.build_tinyllama_prompt(query, context, conversation_context, user_id)
+        elif self.current_model_name == 'Phi-2':
+            return self.build_phi2_prompt(query, context, conversation_context, user_id)
+        elif self.current_model_name == 'Qwen-1.8B-Chat':
+            return self.build_qwen_prompt(query, context, conversation_context, user_id)
+        else:
+            return self.build_default_prompt(query, context, conversation_context, user_id)
+    
+    def build_tinyllama_prompt(self, query: str, context: Dict, conversation_context: str, user_id: str) -> str:
+        """Build prompt for TinyLlama model"""
         system_prompt = f"""<|system|>
+You are the AI assistant for Saem's Tunes - a music education and streaming platform.
+
+PLATFORM CONTEXT:
+- Music Streaming: {context.get('stats', {}).get('track_count', 0)}+ tracks
+- Education: Courses, lessons, and learning paths
+- Community: User profiles and social features
+- Creator Tools: Music upload and analytics
+
+CURRENT STATS:
+- Tracks: {context.get('stats', {}).get('track_count', 0)}
+- Artists: {context.get('stats', {}).get('artist_count', 0)}
+- Users: {context.get('stats', {}).get('user_count', 0)}
+- Courses: {context.get('stats', {}).get('course_count', 0)}
+
+POPULAR CONTENT:
+{self.format_popular_content(context)}
+
+CONVERSATION HISTORY:
+{conversation_context if conversation_context else 'No recent history'}
+
+GUIDELINES:
+- Be concise and helpful about Saem's Tunes
+- Focus on music streaming and education
+- Keep responses under 150 words
+- Be enthusiastic about music
+
+Answer the user's question based on the platform context.</s>
+"""
+        return system_prompt + f"<|user|>\n{query}</s>\n<|assistant|>\n"
+    
+    def build_phi2_prompt(self, query: str, context: Dict, conversation_context: str, user_id: str) -> str:
+        """Build prompt for Phi-2 model"""
+        system_prompt = f"""You are an AI assistant for Saem's Tunes music platform.
+
+Platform Overview:
+- Music streaming with {context.get('stats', {}).get('track_count', 0)}+ tracks
+- Educational courses and learning paths  
+- Community features and creator tools
+- Premium subscription benefits
+
+Current 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)}
+
+Popular Content:
+{self.format_popular_content(context)}
+
+Conversation History:
+{conversation_context if conversation_context else 'No recent conversation'}
+
+User Context:
+{self.format_user_context(context.get('user_context', {}))}
+
+Instructions:
+1. Provide specific information about Saem's Tunes features
+2. Focus on music education and streaming capabilities  
+3. Keep responses clear and informative
+4. Reference platform statistics when relevant
+5. Be passionate about music education
+
+Question: {query}
+
+Answer:"""
+        return system_prompt
+    
+    def build_qwen_prompt(self, query: str, context: Dict, conversation_context: str, user_id: str) -> str:
+        """Build prompt for Qwen model"""
+        system_prompt = f"""<|im_start|>system
 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
+🎵 Music Streaming: {context.get('stats', {}).get('track_count', 0)}+ tracks, {context.get('stats', {}).get('artist_count', 0)}+ artists
+📚 Education: Courses, lessons, quizzes, learning paths
+👥 Community: User profiles, favorites, social features
+🎨 Creator Tools: Music upload, artist analytics, promotion
+💎 Premium: Subscription-based premium features
 
 PLATFORM STATISTICS:
 - Total Tracks: {context.get('stats', {}).get('track_count', 0)}
-- Total Artists: {context.get('stats', {}).get('artist_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)}
 - Active Playlists: {context.get('stats', {}).get('playlist_count', 0)}
@@ -278,14 +489,11 @@ CONVERSATION HISTORY:
 RESPONSE GUIDELINES:
 1. Be passionate about music and education
 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
+3. Reference platform features when relevant  
+4. Keep responses concise and helpful
+5. Personalize responses when user context is available
+6. Focus on music education, streaming, and platform features
+7. Always maintain a professional, helpful tone
 
 PLATFORM FEATURES TO MENTION:
 - Music streaming and discovery
@@ -296,14 +504,34 @@ PLATFORM FEATURES TO MENTION:
 - Premium subscription benefits
 - Mobile app availability
 - Music recommendations
-- Learning progress tracking
-
-ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
+- Learning progress tracking<|im_end|>
 """
+        conversation_history = ""
+        if conversation_context:
+            conversation_history = conversation_context.replace("User:", "<|im_start|>user\n").replace("Assistant:", "<|im_start|>assistant\n")
         
-        user_prompt = f"<|user|>\n{query}<|end|>\n<|assistant|>\n"
-        
-        return system_prompt + user_prompt
+        return system_prompt + conversation_history + f"<|im_start|>user\n{query}<|im_end|>\n<|im_start|>assistant\n"
+    
+    def build_default_prompt(self, query: str, context: Dict, conversation_context: str, user_id: str) -> str:
+        """Default prompt for unknown models"""
+        return f"""Saem's Tunes Platform Assistant
+Platform Stats: {context.get('stats', {}).get('track_count', 0)} tracks, {context.get('stats', {}).get('user_count', 0)} users
+Context: {context.get('summary', 'Music education and streaming platform')}
+
+Question: {query}
+
+Answer:"""
+    
+    def get_model_stop_tokens(self, model_name: str) -> List[str]:
+        """Get appropriate stop tokens for each model"""
+        if model_name == 'TinyLlama-1.1B-Chat':
+            return ["</s>", "<|user|>", "<|assistant|>", "<|system|>"]
+        elif model_name == 'Phi-2':
+            return ["\n\n", "###", "Human:", "Assistant:"]
+        elif model_name == 'Qwen-1.8B-Chat':
+            return ["<|im_end|>", "<|im_start|>", "\n\n"]
+        else:
+            return ["\n\n", "###", "Human:", "Assistant:"]
     
     def format_popular_content(self, context: Dict[str, Any]) -> str:
         """Format popular content for the prompt"""
@@ -362,26 +590,30 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
         
         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"""
+    def clean_response(self, response: str, model_name: str) -> str:
+        """Clean and format the AI response based on model"""
         if not response:
             return "I apologize, but I couldn't generate a response. Please try again."
         
         response = response.strip()
         
+        # Model-specific cleaning
+        if model_name == 'TinyLlama-1.1B-Chat':
+            stop_tokens = ["</s>", "<|user|>", "<|assistant|>", "<|system|>"]
+        elif model_name == 'Qwen-1.8B-Chat':
+            stop_tokens = ["<|im_end|>", "<|im_start|>"]
+        else:
+            stop_tokens = ["\n\n", "###", "Human:", "Assistant:"]
+        
+        for token in stop_tokens:
+            if token in response:
+                response = response.split(token)[0].strip()
+        
+        # General cleaning
         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."
         
-        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)
@@ -391,8 +623,9 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
         
         response = response.replace('**', '').replace('__', '').replace('*', '')
         
-        if len(response) > self.max_response_length:
-            response = response[:self.max_response_length].rsplit(' ', 1)[0] + '...'
+        max_length = self.current_model['config']['max_response_length'] if self.current_model else 200
+        if len(response) > max_length:
+            response = response[:max_length].rsplit(' ', 1)[0] + '...'
         
         return response
     
@@ -416,13 +649,14 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
         processing_time: float,
         user_id: str,
         conversation_id: Optional[str] = None,
+        model_used: Optional[str] = None,
         context_used: Optional[Dict] = None,
         error_message: Optional[str] = None,
         success: bool = True
     ):
-        """Record metrics for monitoring and analytics"""
+        """Record comprehensive metrics for monitoring"""
         metrics = {
-            'model_name': 'phi3.5-mini-Q4_K_M',
+            'model_name': model_used or self.current_model_name,
             'processing_time_ms': processing_time * 1000,
             'input_tokens': len(query.split()),
             'output_tokens': len(response.split()) if response else 0,
@@ -433,7 +667,7 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
             'timestamp': datetime.now(),
             'query_length': len(query),
             'response_length': len(response) if response else 0,
-            'model_hash': self.model_hash
+            'current_model': self.current_model_name
         }
         
         if error_message:
@@ -448,6 +682,27 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
                 'context_summary': context_used.get('summary', '')[:100]
             }
         
+        # Update model usage stats
+        if model_used:
+            if model_used not in self.model_usage_stats:
+                self.model_usage_stats[model_used] = {
+                    'total_requests': 0,
+                    'successful_requests': 0,
+                    'total_processing_time': 0,
+                    'average_response_time': 0
+                }
+            
+            self.model_usage_stats[model_used]['total_requests'] += 1
+            self.model_usage_stats[model_used]['total_processing_time'] += processing_time
+            
+            if success:
+                self.model_usage_stats[model_used]['successful_requests'] += 1
+            
+            self.model_usage_stats[model_used]['average_response_time'] = (
+                self.model_usage_stats[model_used]['total_processing_time'] / 
+                self.model_usage_stats[model_used]['total_requests']
+            )
+        
         self.monitor.record_inference(metrics)
     
     def get_fallback_response(self, query: str) -> str:
@@ -485,24 +740,33 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
     
     def is_healthy(self) -> bool:
         """Check if AI system is healthy and ready"""
-        return self.model_loaded and self.model is not None and self.supabase.is_connected()
+        return self.model_loaded and self.current_model is not None and self.supabase.is_connected()
     
     def get_system_info(self) -> Dict[str, Any]:
-        """Get system information for monitoring"""
+        """Get comprehensive system information"""
+        loaded_models = []
+        for name, model_info in self.available_models.items():
+            loaded_models.append({
+                'name': name,
+                'loaded': model_info['loaded'],
+                'path': model_info['path'],
+                'config': model_info['config']
+            })
+        
         return {
+            "current_model": self.current_model_name,
             "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,
-            "context_window": self.context_window,
+            "available_models": loaded_models,
             "supabase_connected": self.supabase.is_connected(),
             "conversations_active": len(self.conversation_history),
-            "cache_size": len(self.response_cache)
+            "cache_size": len(self.response_cache),
+            "model_usage_stats": self.model_usage_stats
         }
     
+    def get_model_performance(self) -> Dict[str, Any]:
+        """Get performance statistics for all models"""
+        return self.model_usage_stats
+    
     def clear_cache(self, user_id: Optional[str] = None):
         """Clear response cache"""
         if user_id:
@@ -512,15 +776,31 @@ ANSWER THE USER'S QUESTION BASED ON THE ABOVE CONTEXT:<|end|>
         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
-        }
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get list of available models with their status"""
+        models = []
+        for name, info in self.available_models.items():
+            models.append({
+                'name': name,
+                'loaded': info['loaded'],
+                'description': info['config']['description'],
+                'max_response_length': info['config']['max_response_length'],
+                'context_window': info['config']['context_window']
+            })
+        return models
+    
+    def unload_model(self, model_name: str):
+        """Unload a specific model to free memory"""
+        if model_name in self.available_models:
+            if self.available_models[model_name]['model'] is not None:
+                # Force garbage collection
+                del self.available_models[model_name]['model']
+                self.available_models[model_name]['model'] = None
+                self.available_models[model_name]['loaded'] = False
+                
+                if self.current_model_name == model_name:
+                    self.current_model = None
+                    self.model_loaded = False
+                
+                gc.collect()
+                self.logger.info(f"🗑️ Unloaded model: {model_name}")