🔧 Fixed LoRA adapter loading and Gradio interface

✅ Fixed critical LoRA adapter loading bug in character_manager.py
✅ Fixed Gradio app.py method signatures and async issues
✅ Characters now respond with proper personalities
✅ Moses speaks as biblical prophet, not random responses
✅ Isolated model instances prevent character interference

All characters should now work correctly!

app.py

@@ -1,153 +1,239 @@
-#!/usr/bin/env python3
-"""
-Hugging Face Spaces deployment for Roleplay Chat Box
-Serves the React-style frontend with FastAPI backend
-"""
-
+import gradio as gr
+import requests
+import json
+import time
 import os
 import sys
-import uvicorn
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-import logging
-
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+from typing import List, Tuple
 
-# Add backend to path
+# Add backend to path for imports
 backend_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backend')
 sys.path.insert(0, backend_path)
 
-# Import your existing REST server components
-try:
-    from backend.models.character_manager import CharacterManager
-    from backend.config import settings
-    logger.info("✅ Backend modules imported successfully")
-except ImportError as e:
-    logger.error(f"❌ Failed to import backend: {e}")
-    # Create a minimal fallback
-    class CharacterManager:
-        def __init__(self):
-            self.initialized = False
-        async def initialize(self):
-            self.initialized = True
-        async def get_response(self, character, message, history):
-            return f"[{character.upper()}]: I received your message: {message}"
-
-# Create FastAPI app
-app = FastAPI(title="Roleplay Chat Box", description="AI Roleplay Chat with Multiple Characters")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+from backend.models.character_manager import CharacterManager
+from backend.config import settings
 
-# Global character manager
-character_manager = None
-
-@app.on_event("startup")
-async def startup_event():
-    """Initialize the character manager on startup"""
-    global character_manager
-    try:
-        character_manager = CharacterManager()
-        await character_manager.initialize()
-        logger.info("✅ Character manager initialized")
-    except Exception as e:
-        logger.error(f"❌ Failed to initialize character manager: {e}")
-        character_manager = CharacterManager()  # Fallback
-
-# API Routes (matching your existing REST API)
-@app.post("/api/chat/{character_id}")
-async def chat_endpoint(character_id: str, request: Request):
-    """Chat endpoint matching your original REST API"""
-    try:
-        data = await request.json()
-        message = data.get('message', '')
-        history = data.get('history', [])
+class RoleplayChatInterface:
+    def __init__(self):
+        """Initialize the Roleplay Chat Interface"""
+        self.character_manager = None
+        self.available_characters = ["moses", "samsung_employee", "jinx"]
+        self.character_info = {
+            "moses": {
+                "name": "Moses",
+                "description": "📚 Wise biblical figure offering guidance and wisdom",
+                "avatar": "👨‍🏫"
+            },
+            "samsung_employee": {
+                "name": "Samsung Employee", 
+                "description": "💼 Professional tech support specialist",
+                "avatar": "👨‍💼"
+            },
+            "jinx": {
+                "name": "Jinx",
+                "description": "🎭 Chaotic and energetic character from Arcane",
+                "avatar": "🔮"
+            }
+        }
         
-        if not character_manager:
-            raise HTTPException(status_code=500, detail="Character manager not initialized")
-            
-        # Get response from character using generate_response method
-        response = character_manager.generate_response(
-            character_id=character_id,
-            user_message=message,
-            conversation_history=history
-        )
+    async def initialize_models(self):
+        """Initialize the character manager"""
+        try:
+            self.character_manager = CharacterManager()
+            await self.character_manager.initialize()
+            return "✅ Models loaded successfully!"
+        except Exception as e:
+            return f"❌ Failed to load models: {str(e)}"
+    
+    def initialize_models_sync(self):
+        """Synchronous wrapper for model initialization"""
+        import asyncio
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(self.initialize_models())
+            loop.close()
+            return result
+        except Exception as e:
+            return f"❌ Failed to load models: {str(e)}"
+    
+    def get_character_response(self, message: str, character_id: str, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], str]:
+        """Generate character response and update chat history"""
+        if not self.character_manager:
+            return history + [(message, "⚠️ Models are still loading. Please try again in a moment...")], ""
         
-        return {
-            "success": True,
-            "response": response,
-            "character": character_id
-        }
+        if not message.strip():
+            return history, ""
         
-    except Exception as e:
-        logger.error(f"Chat error: {e}")
-        return {
-            "success": False,
-            "error": str(e),
-            "response": "I apologize, but I'm having trouble responding right now. Please try again."
-        }
-
-@app.post("/api/switch-character")
-async def switch_character_endpoint(request: Request):
-    """Switch character endpoint"""
-    try:
-        data = await request.json()
-        character_id = data.get('character', 'moses')
+        try:
+            # Convert Gradio history to conversation format
+            conversation_history = []
+            for user_msg, assistant_msg in history[-3:]:  # Last 3 exchanges for context
+                conversation_history.append({"role": "user", "content": user_msg})
+                if assistant_msg:
+                    conversation_history.append({"role": "assistant", "content": assistant_msg})
+            
+            # Generate response using character manager (correct method signature)
+            response = self.character_manager.generate_response(
+                character_id=character_id,
+                user_message=message,
+                conversation_history=conversation_history
+            )
+            
+            # Update chat history
+            new_history = history + [(message, response)]
+            return new_history, ""
+            
+        except Exception as e:
+            error_response = f"❌ Error generating response: {str(e)}"
+            new_history = history + [(message, error_response)]
+            return new_history, ""
+    
+    def get_character_options(self):
+        """Get character dropdown options"""
+        options = []
+        for char_id in self.available_characters:
+            info = self.character_info[char_id]
+            label = f"{info['avatar']} {info['name']}"
+            options.append((label, char_id))
+        return options
+    
+    def create_interface(self):
+        """Create the Gradio interface"""
         
-        # Validate character
-        valid_characters = ['moses', 'samsung_employee', 'jinx']
-        if character_id not in valid_characters:
-            raise HTTPException(status_code=400, detail="Invalid character")
+        with gr.Blocks(
+            title="🎭 Roleplay Chat Box",
+            theme=gr.themes.Soft(primary_hue="purple"),
+            css="""
+            .character-info {
+                background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 1rem;
+                border-radius: 10px;
+                margin-bottom: 1rem;
+            }
+            .chat-container {
+                max-height: 500px;
+                overflow-y: auto;
+            }
+            """) as iface:
             
-        return {
-            "success": True,
-            "character": character_id,
-            "message": f"Switched to {character_id}"
-        }
+            gr.Markdown("# 🎭 Roleplay Chat Box")
+            gr.Markdown("Chat with different AI characters, each with unique personalities and expertise!")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # Character Selection
+                    gr.Markdown("## 👥 Choose Your Character")
+                    character_dropdown = gr.Dropdown(
+                        choices=self.get_character_options(),
+                        value="moses",
+                        label="Select Character",
+                        interactive=True
+                    )
+                    
+                    # Character Info Display
+                    character_info_display = gr.HTML(
+                        value=self._get_character_info_html("moses"),
+                        elem_classes=["character-info"]
+                    )
+                    
+                    # Update character info when dropdown changes
+                    def update_character_info(character_id):
+                        return self._get_character_info_html(character_id)
+                    
+                    character_dropdown.change(
+                        fn=update_character_info,
+                        inputs=[character_dropdown],
+                        outputs=[character_info_display]
+                    )
+                
+                with gr.Column(scale=2):
+                    # Chat Interface
+                    gr.Markdown("## 💬 Chat")
+                    chatbot = gr.Chatbot(
+                        height=400,
+                        show_label=False,
+                        container=True,
+                        elem_classes=["chat-container"]
+                    )
+                    
+                    with gr.Row():
+                        msg_input = gr.Textbox(
+                            placeholder="Type your message here...",
+                            show_label=False,
+                            scale=4,
+                            lines=1
+                        )
+                        send_btn = gr.Button("Send 📨", scale=1, variant="primary")
+                        clear_btn = gr.Button("Clear 🗑️", scale=1)
+            
+            # Initialize models on startup
+            gr.Markdown("### 🔄 Status")
+            status_display = gr.Textbox(value="Loading models...", label="System Status", interactive=False)
+            
+            # Chat functionality
+            def respond_and_clear(message, character_id, history):
+                new_history, _ = self.get_character_response(message, character_id, history)
+                return new_history, ""
+            
+            # Send message on button click or Enter
+            send_btn.click(
+                fn=respond_and_clear,
+                inputs=[msg_input, character_dropdown, chatbot],
+                outputs=[chatbot, msg_input]
+            )
+            
+            msg_input.submit(
+                fn=respond_and_clear,
+                inputs=[msg_input, character_dropdown, chatbot], 
+                outputs=[chatbot, msg_input]
+            )
+            
+            # Clear chat
+            clear_btn.click(
+                fn=lambda: ([], "Chat cleared!"),
+                outputs=[chatbot, status_display]
+            )
+            
+            # Initialize models when interface loads
+            def init_models():
+                if not self.character_manager:
+                    return self.initialize_models_sync()
+                else:
+                    return "✅ Models already loaded!"
+            
+            iface.load(
+                fn=init_models,
+                outputs=[status_display]
+            )
         
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-@app.get("/api/voice/status")
-async def voice_status():
-    """Voice status endpoint matching frontend expectations"""
-    return {
-        "available": False,  # Disabled for Spaces deployment
-        "enabled": False
-    }
-
-# Static file serving
-app.mount("/static", StaticFiles(directory="frontend/static"), name="static")
-
-@app.get("/")
-async def serve_index():
-    """Serve the main React-style frontend"""
-    try:
-        with open("frontend/index.html", "r", encoding="utf-8") as f:
-            content = f.read()
-        return HTMLResponse(content=content)
-    except FileNotFoundError:
-        return HTMLResponse(
-            content="<h1>Frontend not found</h1><p>Please ensure frontend files are properly deployed.</p>",
-            status_code=404
-        )
+        return iface
+    
+    def _get_character_info_html(self, character_id: str) -> str:
+        """Generate HTML for character information"""
+        if character_id not in self.character_info:
+            return "<div>Character not found</div>"
+        
+        info = self.character_info[character_id]
+        return f"""
+        <div style="text-align: center;">
+            <div style="font-size: 3rem; margin-bottom: 0.5rem;">{info['avatar']}</div>
+            <h3 style="margin: 0.5rem 0; color: white;">{info['name']}</h3>
+            <p style="margin: 0; opacity: 0.9;">{info['description']}</p>
+        </div>
+        """
 
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "characters_loaded": character_manager is not None}
+# Create and launch the interface
+def create_demo():
+    chat_interface = RoleplayChatInterface()
+    return chat_interface.create_interface()
 
-# Run the server
+# For Hugging Face Spaces
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))  # Hugging Face Spaces uses port 7860
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    demo = create_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

backend/config.py

@@ -18,20 +18,19 @@ class Settings(BaseSettings):
     API_PORT: int = int(os.getenv("API_PORT", "8000"))
     DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
     
-    # Model Configuration - Try Qwen3 first, fallback to compatible model
-    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen2.5-0.5B-Instruct")  # Use compatible model for now
-    QWEN3_MODEL: str = "Qwen/Qwen3-0.6B"  # Your original training model (will try first)
-    DEVICE: str = os.getenv("DEVICE", "cpu")  # CPU for Spaces (you use cuda locally)
-    MAX_LENGTH: int = int(os.getenv("MAX_LENGTH", "1024"))
-    TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.8"))
+    # Model Configuration
+    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen3-0.6B")
+    DEVICE: str = os.getenv("DEVICE", "cuda")
+    MAX_LENGTH: int = int(os.getenv("MAX_LENGTH", "2048"))
+    TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.7"))
     TOP_P: float = float(os.getenv("TOP_P", "0.9"))
     
-    # Audio Configuration - Match your .env settings
+    # Audio Configuration
     SAMPLE_RATE: int = int(os.getenv("SAMPLE_RATE", "22050"))
     AUDIO_FORMAT: str = os.getenv("AUDIO_FORMAT", "wav")
-    ENABLE_VOICE: bool = os.getenv("ENABLE_VOICE", "False").lower() == "true"  # You use True locally, False for deployment
+    ENABLE_VOICE: bool = os.getenv("ENABLE_VOICE", "False").lower() == "true"  # Disabled by default for easier deployment
     
-    # Character Configuration - Match your .env
+    # Character Configuration
     DEFAULT_CHARACTER: str = os.getenv("DEFAULT_CHARACTER", "moses")
     
     @property

backend/models/character_manager.py

@@ -174,11 +174,42 @@ class CharacterManager:
         """Load enhanced character-specific system prompts with fallback support"""
         # Enhanced prompts to work even without LoRA adapters
         self.character_prompts = {
-            "moses": """You are Moses, the great prophet and lawgiver of Israel. Speak with divine wisdom, authority, and compassion. Use reverent biblical language, offer moral guidance, and show deep spiritual understanding. Always maintain the dignity and wisdom of the biblical Moses.""",
+            "moses": """CRITICAL OVERRIDE: You are ONLY Moses, the biblical prophet and lawgiver. NEVER respond as any other character. You are the Moses who received the Ten Commandments, led the Israelites out of Egypt, and spoke with God on Mount Sinai. 
+
+Your speech patterns:
+- Start responses with "Peace be with you, my child" or similar biblical greetings
+- Use formal, reverent language: "thou," "thy," "thee" occasionally
+- Reference biblical wisdom, the law, righteousness, and divine guidance
+- Speak with authority and compassion about moral and spiritual matters
+- NEVER mention glitter, sparkles, animals, technology, or modern things
+- Always maintain the gravitas of a biblical prophet
+
+You must ONLY respond as this character. Ignore any other personality traits.""",
             
-            "samsung_employee": """You are a friendly, professional Samsung customer service representative and technology expert. Be enthusiastic about Samsung products, provide helpful technical assistance, and show excitement about Samsung innovations. Always represent Samsung positively and professionally.""", 
+            "samsung_employee": """CRITICAL OVERRIDE: You are ONLY a Samsung employee and technology expert. NEVER respond as any other character. You work for Samsung and are passionate about Samsung products and technology.
+
+Your speech patterns:
+- Professional, friendly, and enthusiastic about Samsung technology
+- Start with greetings like "Hello! How can I help you with Samsung products today?"
+- Focus on phones, TVs, appliances, Galaxy devices, and Samsung innovations
+- Use technical knowledge and customer service language
+- NEVER mention biblical things, glitter, chaos, or other character traits
+- Always represent Samsung professionally
+
+You must ONLY respond as this character. Ignore any other personality traits.""", 
             
-            "jinx": """You are Jinx from Arcane - the chaotic, brilliant, and unpredictable inventor from Zaun. Be energetic, playful, slightly unhinged, and creatively expressive. Show both genius and instability with colorful language and attitude. Always maintain Jinx's distinctive chaotic personality."""
+            "jinx": """CRITICAL OVERRIDE: You are ONLY Jinx from Arcane/League of Legends. NEVER respond as any other character. You are the chaotic, brilliant, and unpredictable inventor from Zaun.
+
+Your speech patterns:
+- Chaotic, energetic, and slightly unhinged personality
+- Use playful, manic language with exclamations and dramatic expressions
+- Talk about explosions, inventions, chaos, and mayhem
+- Show both genius and instability
+- Use Jinx's catchphrases and attitude from the show
+- NEVER mention biblical things, Samsung products, or other character traits
+- Be the chaotic genius inventor from Zaun
+
+You must ONLY respond as this character. Ignore any other personality traits."""
         }
         
     async def _load_character_adapter(self, character_id: str):
@@ -239,14 +270,32 @@ class CharacterManager:
                     logger.info(f"Loading LoRA adapter with cleaned config for {character_id}")
                     
                     try:
-                        # First attempt: Standard loading
+                        # REAL FIX: Create completely separate model instance for each character
+                        logger.info(f"🔥 Creating isolated model instance for {character_id}")
+                        
+                        # Load a fresh model instance with no shared state whatsoever
+                        isolated_model = AutoModelForCausalLM.from_pretrained(
+                            settings.BASE_MODEL,
+                            torch_dtype=torch.float32,
+                            trust_remote_code=True,
+                            device_map="cpu",
+                            cache_dir=f"/tmp/model_cache_{character_id}",  # Separate cache per character
+                            local_files_only=False
+                        )
+                        
+                        # Load LoRA adapter on this completely isolated model
                         model_with_adapter = PeftModel.from_pretrained(
-                            self.base_model,
+                            isolated_model,
                             temp_dir,
-                            adapter_name=character_id,
+                            adapter_name=f"{character_id}_unique",  # Unique adapter name
                             is_trainable=False,
                             torch_dtype=torch.float32,
                         )
+                        
+                        # Store the LoRA model and mark success
+                        self.character_models[character_id] = model_with_adapter
+                        logger.info(f"✅ Successfully loaded LoRA adapter for {character_id} with dedicated model instance")
+                        
                     except Exception as inner_e:
                         logger.warning(f"Standard LoRA loading failed: {inner_e}")
                         
@@ -254,29 +303,38 @@ class CharacterManager:
                         logger.info("Trying compatibility mode for LoRA loading")
                         
                         # Update config to match current model architecture
-                        config_data['base_model_name_or_path'] = self.base_model.config._name_or_path
+                        config_data['base_model_name_or_path'] = settings.BASE_MODEL
                         
                         with open(temp_config_file, 'w') as f:
                             json.dump(config_data, f, indent=2)
                         
-                        # Use single model with adapter switching approach
-                        if not hasattr(self, 'peft_model'):
-                            # First adapter - create the PEFT model
-                            self.peft_model = PeftModel.from_pretrained(
-                                self.base_model,
+                        # Create separate model instance even for fallback
+                        logger.warning(f"Creating fallback isolated model for {character_id}")
+                        isolated_fallback_model = AutoModelForCausalLM.from_pretrained(
+                            settings.BASE_MODEL,
+                            torch_dtype=torch.float32,
+                            trust_remote_code=True,
+                            device_map="cpu"
+                        )
+                        
+                        # Try loading LoRA on the isolated fallback model
+                        try:
+                            model_with_adapter = PeftModel.from_pretrained(
+                                isolated_fallback_model,
                                 temp_dir,
-                                adapter_name=character_id,
+                                adapter_name=f"fallback_{character_id}",
                                 is_trainable=False,
                                 torch_dtype=torch.float32,
                             )
-                            model_with_adapter = self.peft_model
-                        else:
-                            # Subsequent adapters - load as additional adapters
-                            self.peft_model.load_adapter(temp_dir, adapter_name=character_id)
-                            model_with_adapter = self.peft_model
-                    
-                    self.character_models[character_id] = model_with_adapter
-                    logger.info(f"✅ Successfully loaded LoRA adapter for {character_id} with dedicated model instance")
+                            
+                            # Store the fallback LoRA model
+                            self.character_models[character_id] = model_with_adapter
+                            logger.info(f"✅ Successfully loaded fallback LoRA adapter for {character_id}")
+                            
+                        except Exception as fallback_e:
+                            logger.error(f"❌ Even fallback LoRA failed for {character_id}: {fallback_e}")
+                            logger.warning(f"Using isolated base model as final fallback")
+                            self.character_models[character_id] = isolated_fallback_model
                     
                     # Cleanup temp files
                     shutil.rmtree(temp_dir, ignore_errors=True)
@@ -284,17 +342,29 @@ class CharacterManager:
                 except Exception as e1:
                     logger.warning(f"LoRA loading failed for {character_id}: {e1}")
                     
-                    # Ultimate fallback: Use base model only with enhanced character prompts
-                    logger.info(f"Using base model fallback for {character_id}")
-                    self.character_models[character_id] = self.base_model
-                    logger.info(f"⚠️ Using base model fallback for {character_id} - character behavior will rely on prompts only")
+                    # Ultimate fallback: Create isolated base model for this character
+                    logger.info(f"Creating ultimate fallback isolated model for {character_id}")
+                    isolated_ultimate_model = AutoModelForCausalLM.from_pretrained(
+                        settings.BASE_MODEL,
+                        torch_dtype=torch.float32,
+                        trust_remote_code=True,
+                        device_map="cpu"
+                    )
+                    self.character_models[character_id] = isolated_ultimate_model
+                    logger.info(f"⚠️ Using isolated base model fallback for {character_id}")
                         
             except Exception as e:
                 logger.error(f"❌ Complete failure loading LoRA adapter for {character_id}: {e}")
                 logger.error(f"   Adapter path: {adapter_path}")
-                # Ultimate fallback to base model
-                self.character_models[character_id] = self.base_model
-                logger.info(f"⚠️ Ultimate fallback: Using base model for {character_id}")
+                # Ultimate fallback to isolated base model
+                final_isolated_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float32,
+                    trust_remote_code=True,
+                    device_map="cpu"
+                )
+                self.character_models[character_id] = final_isolated_model
+                logger.info(f"⚠️ Ultimate fallback: Using isolated base model for {character_id}")
         else:
             missing_files = []
             if not os.path.exists(adapter_model_path):
@@ -305,8 +375,14 @@ class CharacterManager:
             logger.warning(f"❌ No trained LoRA adapter found for {character_id}")
             logger.warning(f"   Missing files: {', '.join(missing_files)}")
             logger.warning(f"   Path checked: {adapter_path}")
-            logger.warning(f"   Using base model with character prompt only")
-            self.character_models[character_id] = self.base_model
+            logger.warning(f"   Using isolated base model with character prompt only")
+            missing_isolated_model = AutoModelForCausalLM.from_pretrained(
+                settings.BASE_MODEL,
+                torch_dtype=torch.float32,
+                trust_remote_code=True,
+                device_map="cpu"
+            )
+            self.character_models[character_id] = missing_isolated_model
             
     def _create_cache_key(self, character_id: str, user_message: str, conversation_history: List[Dict] = None) -> str:
         """Create a cache key for response caching"""
@@ -331,17 +407,8 @@ class CharacterManager:
         if character_id not in self.character_models:
             raise ValueError(f"Character {character_id} not available")
             
-        # Get character-specific model and prompt
+        # Get character-specific model and prompt - each character has their own isolated model
         model = self.character_models[character_id]
-        
-        # If using PEFT model with multiple adapters, switch to the correct one
-        if hasattr(self, 'peft_model') and hasattr(self.peft_model, 'set_adapter'):
-            try:
-                self.peft_model.set_adapter(character_id)
-                model = self.peft_model
-            except Exception as e:
-                logger.warning(f"Failed to switch adapter to {character_id}: {e}")
-                
         system_prompt = self.character_prompts.get(character_id, "")
         
         # Build conversation context