Deploy Roleplay Chat Box - optimized version without large files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Roleplay Chat Box
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,16 +1,88 @@
 ---
-title: Roleplay Chat Box
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: Roleplay Chat Box 🎭
+emoji: 🎭
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
+sdk_version: 4.44.1
+app_file: hf_app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
 license: mit
+short_description: Multi-character AI roleplay chatbot with LoRA-adapted personalities
+tags:
+- conversational-ai
+- roleplay
+- lora
+- character-ai
+- chatbot
+- transformers
+- qwen
+models:
+- Qwen/Qwen2.5-1.5B
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# Roleplay Chat Box 🎭
+
+An intelligent conversational AI system featuring multiple character personalities powered by LoRA (Low-Rank Adaptation) fine-tuned language models. Each character has been trained with specific datasets to maintain unique personalities, speaking patterns, and areas of expertise.
+
+## Features
+
+- **Multi-Character Support**: Switch between different character personalities using LoRA adapters
+- **Voice Synthesis**: Text-to-speech with character-specific voices using Microsoft's VibeVoice
+- **Modern Interface**: ChatGPT-style web interface with character selection sidebar
+- **Real-time Chat**: WebSocket-based real-time communication
+- **Audio Toggle**: Optional voice output for responses
+
+## Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Frontend      │    │   Backend API   │    │   ML Models     │
+│   (React/HTML)  │◄──►│   (FastAPI)     │◄──►│   Base + LoRA   │
+│                 │    │                 │    │   + VibeVoice   │
+│ - Chat UI       │    │ - Model Loading │    │                 │
+│ - Character     │    │ - LoRA Switching│    │ - Qwen2 Base    │
+│   Selection     │    │ - TTS Service   │    │ - Character     │
+│ - Audio Toggle  │    │ - WebSocket     │    │   Adapters      │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+## Characters
+
+1. **Moses** - Biblical prophet with wisdom and authority
+2. **Samsung Employee** - Tech-savvy corporate representative
+3. **Jinx** - Complex, chaotic character from Arcane
+
+## Setup
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Download models (see Resources section)
+
+3. Start backend:
+```bash
+cd backend
+python main.py
+```
+
+4. Start frontend:
+```bash
+cd frontend
+# Instructions for your chosen frontend framework
+```
+
+## Requirements
+
+- Python 3.8+
+- CUDA-compatible GPU (recommended)
+- ~8GB RAM minimum
+- ~20GB storage for models
+
+## Models Used
+
+- Base: Qwen2 (via Polarium/qwen2-yoda-lora)
+- Voice: Microsoft VibeVoice-1.5B
+- Custom LoRA adapters for each character

app.py

@@ -1,70 +1,250 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import os
+import sys
+import asyncio
+import logging
+from typing import List, Tuple, Optional
 
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
+# Add backend to path
+backend_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backend')
+sys.path.insert(0, backend_path)
 
-    messages.append({"role": "user", "content": message})
+# Global character manager
+character_manager = None
+models_loaded = False
 
-    response = ""
+def initialize_models():
+    """Initialize the character manager"""
+    global character_manager, models_loaded
+    
+    if models_loaded:
+        return "✅ Models already loaded!"
+    
+    try:
+        from backend.models.character_manager import CharacterManager
+        
+        character_manager = CharacterManager()
+        
+        # Initialize synchronously 
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(character_manager.initialize())
+        
+        models_loaded = True
+        logger.info("✅ Character models initialized successfully!")
+        return "✅ Models loaded successfully!"
+        
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize models: {e}")
+        return f"❌ Failed to load models: {str(e)}"
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+def get_character_info():
+    """Get character information for display"""
+    return {
+        "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": "🔮"
+        }
+    }
 
-        response += token
-        yield response
+def chat_with_character(message: str, character_id: str, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], str]:
+    """Generate character response and update chat history"""
+    global character_manager, models_loaded
+    
+    # Initialize if needed
+    if not models_loaded:
+        init_result = initialize_models()
+        if "Failed" in init_result:
+            return history + [(message, init_result)], ""
+    
+    if not message.strip():
+        return history, ""
+    
+    try:
+        if character_manager is None:
+            return history + [(message, "❌ Character manager not initialized")], ""
+        
+        # Generate response
+        response = character_manager.generate_response(
+            character_id=character_id,
+            user_input=message,
+            max_length=512
+        )
+        
+        # Update history
+        new_history = history + [(message, response)]
+        return new_history, ""
+        
+    except Exception as e:
+        logger.error(f"Error generating response: {e}")
+        error_response = f"❌ Error: {str(e)}"
+        return history + [(message, error_response)], ""
 
+def get_character_display_html(character_id: str) -> str:
+    """Generate HTML for character display"""
+    char_info = get_character_info()
+    if character_id not in char_info:
+        return "<div>Character not found</div>"
+    
+    info = char_info[character_id]
+    return f"""
+    <div style="text-align: center; padding: 20px; background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); 
+                color: white; border-radius: 15px; margin: 10px;">
+        <div style="font-size: 4rem; margin-bottom: 10px;">{info['avatar']}</div>
+        <h2 style="margin: 10px 0; color: white;">{info['name']}</h2>
+        <p style="margin: 0; opacity: 0.9; font-size: 1.1rem;">{info['description']}</p>
+    </div>
+    """
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
+def create_interface():
+    """Create the main Gradio interface"""
+    
+    # Custom CSS
+    custom_css = """
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .character-display {
+        min-height: 200px;
+    }
+    .chat-container {
+        height: 500px;
+    }
+    """
+    
+    with gr.Blocks(
+        title="🎭 Roleplay Chat Box",
+        theme=gr.themes.Soft(primary_hue="purple"),
+        css=custom_css
+    ) as demo:
+        
+        gr.Markdown("# 🎭 Roleplay Chat Box")
+        gr.Markdown("### Chat with AI characters, each with unique personalities!")
+        
+        with gr.Row():
+            # Character selection column
+            with gr.Column(scale=1):
+                gr.Markdown("## 👥 Choose Character")
+                
+                character_dropdown = gr.Dropdown(
+                    choices=[
+                        ("👨‍🏫 Moses", "moses"),
+                        ("👨‍💼 Samsung Employee", "samsung_employee"), 
+                        ("🔮 Jinx", "jinx")
+                    ],
+                    value="moses",
+                    label="Select Character",
+                    interactive=True
+                )
+                
+                # Character info display
+                character_display = gr.HTML(
+                    value=get_character_display_html("moses"),
+                    elem_classes=["character-display"]
+                )
+                
+                # Update character display when selection changes
+                character_dropdown.change(
+                    fn=get_character_display_html,
+                    inputs=[character_dropdown],
+                    outputs=[character_display]
+                )
+            
+            # Chat column
+            with gr.Column(scale=2):
+                gr.Markdown("## 💬 Chat")
+                
+                chatbot = gr.Chatbot(
+                    height=500,
+                    show_label=False,
+                    elem_classes=["chat-container"]
+                )
+                
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Type your message here...",
+                        show_label=False,
+                        scale=4,
+                        lines=2
+                    )
+                    
+                    with gr.Column(scale=1):
+                        send_btn = gr.Button("Send 📨", variant="primary")
+                        clear_btn = gr.Button("Clear 🗑️")
+        
+        # Status section
+        with gr.Row():
+            status_display = gr.Textbox(
+                value="Click 'Initialize Models' to start chatting!",
+                label="Status",
+                interactive=False
+            )
+            init_btn = gr.Button("Initialize Models 🚀", variant="secondary")
+        
+        # Event handlers
+        def send_message(message, character_id, history):
+            return chat_with_character(message, character_id, history)
+        
+        def clear_chat():
+            return [], "Chat cleared!"
+        
+        def init_models_handler():
+            return initialize_models()
+        
+        # Button clicks
+        send_btn.click(
+            fn=send_message,
+            inputs=[msg_input, character_dropdown, chatbot],
+            outputs=[chatbot, msg_input]
+        )
+        
+        msg_input.submit(
+            fn=send_message,
+            inputs=[msg_input, character_dropdown, chatbot],
+            outputs=[chatbot, msg_input]
+        )
+        
+        clear_btn.click(
+            fn=clear_chat,
+            outputs=[chatbot, status_display]
+        )
+        
+        init_btn.click(
+            fn=init_models_handler,
+            outputs=[status_display]
+        )
+        
+        # Example interactions
+        gr.Markdown("""
+        ### 💡 Example Conversations
+        - **Moses**: "What is the meaning of wisdom?"
+        - **Samsung Employee**: "Tell me about the latest Samsung phones"
+        - **Jinx**: "I need help with a creative project!"
+        """)
+    
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    # Create and launch the interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False
+    )

backend/config.py

@@ -0,0 +1,41 @@
+import os
+from dotenv import load_dotenv
+from pydantic_settings import BaseSettings
+
+load_dotenv()
+
+# Get project root directory (parent of backend)
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+class Settings(BaseSettings):
+    # Model Configuration - use absolute paths based on project root
+    MODEL_PATH: str = os.path.join(PROJECT_ROOT, "models")
+    LORA_ADAPTERS_PATH: str = os.path.join(PROJECT_ROOT, "lora_adapters")
+    VOICE_MODEL_PATH: str = os.path.join(PROJECT_ROOT, "models", "vibevoice")
+    
+    # API Configuration  
+    API_HOST: str = os.getenv("API_HOST", "0.0.0.0")
+    API_PORT: int = int(os.getenv("API_PORT", "8000"))
+    DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
+    
+    # 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
+    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"  # Disabled by default for easier deployment
+    
+    # Character Configuration
+    DEFAULT_CHARACTER: str = os.getenv("DEFAULT_CHARACTER", "moses")
+    
+    @property
+    def AVAILABLE_CHARACTERS(self) -> list:
+        characters_str = os.getenv("AVAILABLE_CHARACTERS", "moses,samsung_employee,jinx")
+        return [char.strip() for char in characters_str.split(",")]
+
+settings = Settings()

backend/models/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py file to make this a Python package

backend/models/character_manager.py

@@ -0,0 +1,440 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig, BitsAndBytesConfig
+from peft import PeftModel, PeftConfig
+import asyncio
+import logging
+from typing import Dict, List, Optional
+import os
+from functools import lru_cache
+import hashlib
+import time
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+class CharacterManager:
+    def __init__(self):
+        self.base_model = None
+        self.tokenizer = None
+        self.current_character = None
+        self.character_models: Dict[str, PeftModel] = {}
+        self.character_prompts: Dict[str, str] = {}
+        self.response_cache: Dict[str, str] = {}  # Simple response caching
+        self.generation_config = None  # Optimized generation config
+        
+    async def initialize(self):
+        """Initialize base model and load character adapters with speed optimization"""
+        logger.info("Loading base model with speed optimization...")
+        
+        # Ensure we're in the correct working directory
+        current_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        parent_dir = os.path.dirname(current_dir)
+        logger.info(f"Working from directory: {parent_dir}")
+        logger.info(f"LoRA adapters path: {settings.LORA_ADAPTERS_PATH}")
+        
+        try:
+            # Load tokenizer quickly
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                settings.BASE_MODEL,
+                trust_remote_code=True,
+                use_fast=True  # Use fast tokenizer
+            )
+            
+            # Smart GPU/CPU loading
+            cuda_available = torch.cuda.is_available()
+            use_gpu = settings.DEVICE == "cuda" and cuda_available
+            
+            if use_gpu:
+                gpu_name = torch.cuda.get_device_name(0)
+                gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+                logger.info(f"🚀 Loading with GPU: {gpu_name} ({gpu_memory:.1f}GB VRAM)")
+                
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float16,  # Use FP16 for GPU
+                    device_map="auto",
+                    trust_remote_code=True,
+                    low_cpu_mem_usage=True,
+                    use_cache=True,
+                    load_in_8bit=False,  # Can enable for very large models
+                    load_in_4bit=False   # Can enable for even larger models
+                )
+            else:
+                logger.info("💻 Loading with CPU (CUDA not available or disabled)...")
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float32,
+                    trust_remote_code=True,
+                    use_cache=True
+                )
+        except Exception as e:
+            logger.error(f"Failed to load base model {settings.BASE_MODEL}: {e}")
+            logger.info("Trying alternative Qwen models...")
+            try:
+                # Try Qwen2.5-0.5B as backup
+                fallback_model = "Qwen/Qwen2.5-0.5B-Instruct"
+                self.tokenizer = AutoTokenizer.from_pretrained(fallback_model, trust_remote_code=True)
+                if settings.DEVICE == "cuda" and torch.cuda.is_available():
+                    self.base_model = AutoModelForCausalLM.from_pretrained(
+                        fallback_model,
+                        torch_dtype=torch.float16,
+                        device_map="auto",
+                        trust_remote_code=True
+                    )
+                else:
+                    self.base_model = AutoModelForCausalLM.from_pretrained(
+                        fallback_model,
+                        torch_dtype=torch.float32,
+                        trust_remote_code=True
+                    )
+                logger.info(f"Loaded fallback model: {fallback_model}")
+            except Exception as e2:
+                logger.error(f"Failed to load fallback model: {e2}")
+                raise Exception("No suitable Qwen model could be loaded")
+        
+        # Set padding token to avoid confusion with eos_token
+        if self.tokenizer.pad_token is None:
+            # For Qwen models, use the eos token as pad token
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        
+        # Ensure we have proper chat template for better formatting
+        if not hasattr(self.tokenizer, 'chat_template') or self.tokenizer.chat_template is None:
+            # Set a basic chat template for consistent formatting
+            self.tokenizer.chat_template = "{% for message in messages %}{% if message['role'] == 'system' %}<|system|>\n{{ message['content'] }}\n{% elif message['role'] == 'user' %}<|user|>\n{{ message['content'] }}\n{% elif message['role'] == 'assistant' %}<|assistant|>\n{{ message['content'] }}\n{% endif %}{% endfor %}<|assistant|>\n"
+        
+        # Set up generation config with strict character control
+        self.generation_config = GenerationConfig(
+            max_new_tokens=80,  # Balanced length
+            min_new_tokens=10,  # Ensure substantial output
+            temperature=0.7,    # Less randomness for consistency
+            top_p=0.85,        # Focused sampling
+            top_k=40,          # Reduced for better focus
+            do_sample=True,
+            repetition_penalty=1.15,  # Stronger penalty to avoid loops
+            # Use original model config token IDs to prevent tokenizer alignment warnings
+            bos_token_id=self.base_model.config.bos_token_id,
+            pad_token_id=self.base_model.config.pad_token_id,
+            eos_token_id=self.base_model.config.eos_token_id,
+            use_cache=True,
+            num_beams=1,
+            output_scores=False,
+            return_dict_in_generate=False
+        )
+            
+        # Load character prompts
+        self._load_character_prompts()
+        
+        # Load LoRA adapters for each character
+        for character_id in settings.AVAILABLE_CHARACTERS:
+            await self._load_character_adapter(character_id)
+            
+        logger.info("Character manager initialized successfully")
+        
+    def _load_character_prompts(self):
+        """Load character-specific system prompts - simplified for character-focused training"""
+        # Minimal prompts since the new adapters are trained for direct character embodiment
+        self.character_prompts = {
+            "moses": "You are Moses, the biblical prophet and leader of the Israelites.",
+            "samsung_employee": "You are an enthusiastic Samsung employee who loves technology.", 
+            "jinx": "You are Jinx from Arcane - chaotic, brilliant, and emotionally complex."
+        }
+        
+    async def _load_character_adapter(self, character_id: str):
+        """Load LoRA adapter for specific character with separate model instances"""
+        adapter_path = os.path.join(settings.LORA_ADAPTERS_PATH, character_id)
+        
+        # Debug: Print the paths being checked
+        logger.info(f"Looking for LoRA adapter for {character_id} at: {adapter_path}")
+        
+        # Check if we have a proper LoRA adapter (needs adapter_model.safetensors)
+        adapter_model_path = os.path.join(adapter_path, "adapter_model.safetensors")
+        adapter_config_path = os.path.join(adapter_path, "adapter_config.json")
+        
+        logger.info(f"Checking for adapter files:")
+        logger.info(f"  - adapter_model.safetensors: {os.path.exists(adapter_model_path)}")
+        logger.info(f"  - adapter_config.json: {os.path.exists(adapter_config_path)}")
+        
+        if os.path.exists(adapter_model_path) and os.path.exists(adapter_config_path):
+            try:
+                logger.info(f"Attempting to load LoRA adapter for {character_id}...")
+                
+                # Create a separate base model instance for this character to avoid conflicts
+                # This is crucial to prevent the "multiple adapters" warning and character bleed
+                character_base_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float16 if (settings.DEVICE == "cuda" and torch.cuda.is_available()) else torch.float32,
+                    device_map="auto" if (settings.DEVICE == "cuda" and torch.cuda.is_available()) else None,
+                    trust_remote_code=True,
+                    low_cpu_mem_usage=True,
+                    use_cache=True
+                )
+                
+                # Load the LoRA adapter on the fresh model instance
+                model_with_adapter = PeftModel.from_pretrained(
+                    character_base_model,
+                    adapter_path,
+                    adapter_name=character_id,
+                    is_trainable=False  # Set to inference mode
+                )
+                
+                # Ensure adapter is on correct device
+                device = next(self.base_model.parameters()).device
+                model_with_adapter = model_with_adapter.to(device)
+                
+                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 e:
+                logger.error(f"❌ Could not load LoRA adapter for {character_id}: {e}")
+                logger.error(f"   Adapter path: {adapter_path}")
+                # Fall back to base model with character prompt only
+                self.character_models[character_id] = self.base_model
+        else:
+            missing_files = []
+            if not os.path.exists(adapter_model_path):
+                missing_files.append("adapter_model.safetensors")
+            if not os.path.exists(adapter_config_path):
+                missing_files.append("adapter_config.json")
+            
+            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
+            
+    def _create_cache_key(self, character_id: str, user_message: str, conversation_history: List[Dict] = None) -> str:
+        """Create a cache key for response caching"""
+        history_str = str(conversation_history[-2:]) if conversation_history else ""  # Only last 2 for caching
+        cache_input = f"{character_id}:{user_message}:{history_str}"
+        return hashlib.md5(cache_input.encode()).hexdigest()
+    
+    def generate_response(
+        self, 
+        character_id: str, 
+        user_message: str, 
+        conversation_history: List[Dict] = None
+    ) -> str:
+        """Generate response as specific character with caching"""
+        
+        # Check cache first for faster responses
+        cache_key = self._create_cache_key(character_id, user_message, conversation_history)
+        if cache_key in self.response_cache:
+            logger.info(f"Cache hit for {character_id}")
+            return self.response_cache[cache_key]
+        
+        if character_id not in self.character_models:
+            raise ValueError(f"Character {character_id} not available")
+            
+        # Get character-specific model and prompt
+        model = self.character_models[character_id]
+        system_prompt = self.character_prompts.get(character_id, "")
+        
+        # Build conversation context
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+            
+        # Add minimal conversation history for speed
+        if conversation_history:
+            messages.extend(conversation_history[-2:])  # Keep only last 2 messages
+            
+        # Add current message
+        messages.append({"role": "user", "content": user_message})
+        
+        # Format for the model
+        formatted_prompt = self._format_messages(messages)
+        
+        # Extended tokenization for longer context and responses
+        inputs = self.tokenizer(
+            formatted_prompt, 
+            return_tensors="pt",
+            max_length=1024,  # Much longer context for detailed responses
+            truncation=True,
+            padding=False
+        )
+        
+        if settings.DEVICE == "cuda" and torch.cuda.is_available():
+            inputs = {k: v.cuda() for k, v in inputs.items()}
+        
+        start_time = time.time()
+        
+        # Character-focused generation optimized for consistency
+        try:
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=120,  # Balanced for character consistency
+                    min_new_tokens=25,   # Ensure substantial responses
+                    temperature=0.7,     # Stable creativity for character voice
+                    top_p=0.85,          # Focused sampling
+                    top_k=40,            # Controlled variety
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.pad_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    repetition_penalty=1.15, # Stronger penalty for cleaner responses
+                    use_cache=True,
+                    no_repeat_ngram_size=2,   # Prevent immediate repetition
+                    early_stopping=True       # Natural completion
+                )
+        except Exception as gen_error:
+            logger.warning(f"Generation failed: {gen_error}")
+            return "I apologize, but I'm having trouble generating a response right now. Please try again!"
+            
+        # Decode response (skip the input tokens)
+        input_length = inputs['input_ids'].shape[1]
+        response = self.tokenizer.decode(
+            outputs[0][input_length:], 
+            skip_special_tokens=True
+        ).strip()
+        
+        # Clean up response - stop at conversation indicators (updated for new format)
+        stop_phrases = ["Human:", "\nHuman:", "User:", "\nUser:", "<|endoftext|>", "<|", "\n\nHuman:"]
+        for stop_phrase in stop_phrases:
+            if stop_phrase in response:
+                response = response.split(stop_phrase)[0].strip()
+        
+        # Remove meta-commentary patterns
+        meta_patterns = [
+            "Let me see.", "As Moses, I", "As a Samsung employee, I", "As Jinx, I", 
+            "The user", "I should respond", "I need to", "Let me think",
+            "Okay, the user", "I would", "Since I"
+        ]
+        
+        for pattern in meta_patterns:
+            if response.startswith(pattern):
+                # Find the first sentence that doesn't contain meta-commentary
+                sentences = response.split('.', 1)
+                if len(sentences) > 1:
+                    response = sentences[1].strip()
+        
+        # Clean up incomplete sentences at the end
+        import re
+        # If response ends mid-sentence (no punctuation), try to find last complete sentence
+        if response and not response.strip()[-1] in '.!?':
+            sentences = re.split(r'[.!?]+', response)
+            if len(sentences) > 1:
+                # Keep all complete sentences
+                complete_sentences = sentences[:-1]  # Remove the incomplete last sentence
+                if complete_sentences:
+                    response = '. '.join(complete_sentences).strip()
+                    if response and not response.endswith(('.', '!', '?')):
+                        response += '.'
+        
+        # Ensure we have a meaningful response
+        if not response or len(response.strip()) < 10:
+            fallback_responses = {
+                "jinx": "*spins around excitedly* Hey there! Ready for some chaos? What's cooking in that brain of yours?",
+                "moses": "Peace be with you, my child. How may I guide you in the ways of the Almighty?",
+                "samsung_employee": "Hello! I'm excited to help you discover amazing Samsung technology!"
+            }
+            response = fallback_responses.get(character_id, "Hello! How can I help you today?")
+        
+        # Cache the response (limit cache size)
+        if len(self.response_cache) > 50:  # Simple cache size limit
+            # Remove oldest entries (simple FIFO)
+            oldest_key = next(iter(self.response_cache))
+            del self.response_cache[oldest_key]
+        
+        self.response_cache[cache_key] = response
+        
+        # Clean response to remove meta-commentary and character bleed
+        response = self._clean_response(response, character_id)
+        
+        generation_time = time.time() - start_time
+        logger.info(f"Generated response for {character_id} in {generation_time:.2f}s")
+        
+        return response
+    
+    def _clean_response(self, response: str, character_id: str) -> str:
+        """Clean response to remove meta-commentary and ensure character consistency"""
+        if not response:
+            return response
+            
+        import re
+        
+        # Remove common meta-commentary patterns
+        meta_patterns = [
+            r"Answer:\s*",
+            r"Response:\s*",
+            r"This (?:response|answer)\s.*?[.!?]",
+            r"Let me (?:think|consider|analyze)\s.*?[.!?]", 
+            r"Based on (?:the|this)\s.*?[.!?]",
+            r"The (?:user|question)\s.*?[.!?]",
+            r"I (?:need to|should|will)\s(?:respond|answer)\s.*?[.!?]",
+            r"\(.*?\)",  # Remove parenthetical commentary
+            r"Looking at.*?[.!?]",
+            r"Analyzing.*?[.!?]",
+        ]
+        
+        for pattern in meta_patterns:
+            response = re.sub(pattern, "", response, flags=re.IGNORECASE | re.DOTALL)
+        
+        # Remove character name prefixes that cause bleed
+        response = re.sub(r"^(?:Moses|Samsung_Employee|Jinx):\s*", "", response, flags=re.IGNORECASE)
+        
+        # Remove multiple character references
+        other_chars = ["Moses", "Samsung_Employee", "Jinx"]
+        for char in other_chars:
+            if char.lower() != character_id.lower():
+                response = re.sub(f"{char}:\s*", "", response, flags=re.IGNORECASE)
+        
+        # Clean up extra whitespace and newlines
+        response = re.sub(r"\n\s*\n+", "\n\n", response)
+        response = re.sub(r"\s+", " ", response)  # Multiple spaces to single
+        response = response.strip()
+        
+        # If response is too short after cleaning, provide character-appropriate fallback
+        if len(response.split()) < 5:
+            fallbacks = {
+                "moses": "Peace be with you, my child. How may I guide you in the ways of the Almighty?",
+                "samsung_employee": "Hello! I'm excited to help you discover the amazing features of Samsung Galaxy devices!",
+                "jinx": "*spins around excitedly* Hey there! Ready for some chaos? I've got explosive ideas to share!"
+            }
+            response = fallbacks.get(character_id, "Hello! How can I help you today?")
+        
+        return response
+        
+    def _format_messages(self, messages: List[Dict]) -> str:
+        """Format messages for character-focused training format"""
+        formatted = ""
+        
+        # Add conversation history
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            
+            if role == "system":
+                continue  # Skip system messages for character-focused format
+            elif role == "user":
+                formatted += f"Human: {content}\n\n"
+            elif role == "assistant":
+                formatted += f"{content}\n\nHuman: "
+                
+        return formatted
+        
+    async def switch_character(self, character_id: str):
+        """Switch to different character"""
+        if character_id in self.character_models:
+            self.current_character = character_id
+            logger.info(f"Switched to character: {character_id}")
+        else:
+            raise ValueError(f"Character {character_id} not available")
+            
+    def get_available_characters(self) -> List[str]:
+        """Get list of available character IDs"""
+        return list(self.character_models.keys())
+        
+    def clear_cache(self):
+        """Clear response cache"""
+        self.response_cache.clear()
+        logger.info("Response cache cleared")
+        
+    def get_cache_stats(self) -> Dict:
+        """Get cache statistics"""
+        return {
+            "cache_size": len(self.response_cache),
+            "available_characters": len(self.character_models),
+            "current_character": self.current_character
+        }

backend/models/enhanced_voice_synthesizer.py

@@ -0,0 +1,326 @@
+import torch
+import asyncio
+import logging
+import base64
+import io
+import numpy as np
+from typing import Optional
+from backend.config import settings
+import math
+
+logger = logging.getLogger(__name__)
+
+class SimpleVoiceSynthesizer:
+    """
+    An improved simple voice synthesizer that creates more realistic speech-like audio
+    using phoneme patterns, formant synthesis, and prosody modeling.
+    """
+    
+    def __init__(self):
+        self.character_voice_configs = {}
+        self.initialized = False
+        
+    async def initialize(self):
+        """Initialize simple voice synthesis"""
+        if not settings.ENABLE_VOICE:
+            logger.info("Voice synthesis disabled in config")
+            return False
+            
+        logger.info("Initializing improved simple voice synthesizer...")
+        
+        try:
+            # Setup character-specific voice parameters
+            self._setup_character_voices()
+            self.initialized = True
+            logger.info("Improved simple voice synthesizer initialized successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize simple voice synthesizer: {e}")
+            return False
+            
+    def _setup_character_voices(self):
+        """Setup character-specific voice configurations"""
+        self.character_voice_configs = {
+            "moses": {
+                "base_frequency": 110,  # Lower, more authoritative
+                "speed": 0.85,  # Slower, more measured
+                "pitch_variance": 0.15,  # Less pitch variation
+                "formant_shift": -0.2,  # Deeper formants
+                "voice_quality": "deep",
+            },
+            "samsung_employee": {
+                "base_frequency": 140,  # Professional, clear
+                "speed": 1.0,  # Normal speed
+                "pitch_variance": 0.2,  # Moderate variation
+                "formant_shift": 0.0,  # Neutral formants
+                "voice_quality": "clear",
+            },
+            "jinx": {
+                "base_frequency": 180,  # Higher, more energetic
+                "speed": 1.2,  # Faster speech
+                "pitch_variance": 0.35,  # More pitch variation
+                "formant_shift": 0.3,  # Brighter formants
+                "voice_quality": "bright",
+            }
+        }
+        
+    async def synthesize(self, text: str, character_id: str) -> Optional[str]:
+        """Synthesize speech for given text and character"""
+        if not self.initialized or not settings.ENABLE_VOICE:
+            return None
+            
+        try:
+            # Get character voice config
+            voice_config = self.character_voice_configs.get(
+                character_id, 
+                self.character_voice_configs["samsung_employee"]  # Default
+            )
+            
+            # Generate realistic speech audio
+            audio_data = self._generate_realistic_speech(text, voice_config)
+            
+            # Convert to base64 for web transmission
+            audio_base64 = self._audio_to_base64(audio_data)
+            
+            logger.info(f"Generated realistic speech for {character_id}: {len(text)} chars, {len(audio_data)} samples")
+            return audio_base64
+            
+        except Exception as e:
+            logger.error(f"Error in simple voice synthesis: {e}")
+            return None
+            
+    def _generate_realistic_speech(self, text: str, voice_config: dict) -> np.ndarray:
+        """Generate realistic speech using advanced phoneme and prosody modeling"""
+        
+        # Calculate duration based on speaking rate
+        words = len(text.split())
+        chars = len(text)
+        
+        # Realistic speaking rates: 150-180 words per minute
+        base_wpm = 160
+        speed_factor = voice_config["speed"]
+        actual_wpm = base_wpm * speed_factor
+        
+        # Calculate duration
+        duration = (words / actual_wpm) * 60  # Convert to seconds
+        duration = max(duration, chars / 15.0)  # Minimum based on character count
+        duration = min(duration, 30.0)  # Maximum 30 seconds
+        
+        sample_rate = settings.SAMPLE_RATE
+        num_samples = int(duration * sample_rate)
+        
+        # Create time array
+        t = np.linspace(0, duration, num_samples)
+        
+        # Generate phoneme-based speech patterns
+        audio = self._create_phoneme_speech(t, text, voice_config)
+        
+        # Apply prosody (intonation patterns)
+        prosody = self._generate_prosody(t, text, voice_config)
+        audio *= prosody
+        
+        # Apply character-specific voice quality
+        audio = self._apply_voice_quality(audio, t, voice_config)
+        
+        # Add natural speech envelope
+        envelope = self._create_speech_envelope(audio, t)
+        audio *= envelope
+        
+        # Normalize and return
+        if np.max(np.abs(audio)) > 0:
+            audio = audio / np.max(np.abs(audio)) * 0.8
+            
+        return audio.astype(np.float32)
+        
+    def _create_phoneme_speech(self, t: np.ndarray, text: str, voice_config: dict) -> np.ndarray:
+        """Create speech-like audio using phoneme patterns"""
+        
+        audio = np.zeros_like(t)
+        base_freq = voice_config["base_frequency"]
+        
+        # Create syllable timing based on text
+        syllable_rate = 4.0 * voice_config["speed"]  # syllables per second
+        syllable_duration = 1.0 / syllable_rate
+        
+        for i, sample_time in enumerate(t):
+            # Determine current syllable position
+            syllable_phase = (sample_time % syllable_duration) / syllable_duration
+            
+            # Create vowel/consonant pattern
+            # Vowels: 0.2-0.8 of syllable, Consonants: 0.0-0.2 and 0.8-1.0
+            is_vowel = 0.2 < syllable_phase < 0.8
+            
+            # Get fundamental frequency with natural variation
+            pitch_variation = voice_config["pitch_variance"]
+            f0 = base_freq * (1 + pitch_variation * np.sin(2 * np.pi * 2.3 * sample_time))
+            
+            if is_vowel:
+                # Generate vowel sound using formant synthesis
+                vowel_sound = self._generate_vowel_formants(sample_time, f0, voice_config)
+                audio[i] = vowel_sound
+            else:
+                # Generate consonant sound using filtered noise
+                consonant_sound = self._generate_consonant(sample_time, f0, voice_config)
+                audio[i] = consonant_sound
+                
+        return audio
+        
+    def _generate_vowel_formants(self, t: float, f0: float, voice_config: dict) -> float:
+        """Generate vowel sounds using formant frequencies"""
+        
+        formant_shift = voice_config["formant_shift"]
+        
+        # Vowel formant frequencies (approximate average)
+        f1 = 650 * (1 + formant_shift * 0.5)   # First formant
+        f2 = 1400 * (1 + formant_shift * 0.3)  # Second formant
+        f3 = 2500 * (1 + formant_shift * 0.2)  # Third formant
+        
+        # Add slight formant movement for naturalness
+        f1 += 50 * np.sin(2 * np.pi * 1.7 * t)
+        f2 += 80 * np.sin(2 * np.pi * 2.1 * t)
+        
+        # Generate harmonic series for fundamental
+        fundamental = 0.4 * np.sin(2 * np.pi * f0 * t)
+        
+        # Generate formant resonances
+        formant1 = 0.3 * np.sin(2 * np.pi * f1 * t) * np.exp(-abs(f1 - f0*1) / 200)
+        formant2 = 0.2 * np.sin(2 * np.pi * f2 * t) * np.exp(-abs(f2 - f0*2) / 300)
+        formant3 = 0.1 * np.sin(2 * np.pi * f3 * t) * np.exp(-abs(f3 - f0*3) / 500)
+        
+        # Add harmonics
+        harmonic2 = 0.2 * np.sin(2 * np.pi * f0 * 2 * t)
+        harmonic3 = 0.1 * np.sin(2 * np.pi * f0 * 3 * t)
+        
+        return fundamental + formant1 + formant2 + formant3 + harmonic2 + harmonic3
+        
+    def _generate_consonant(self, t: float, f0: float, voice_config: dict) -> float:
+        """Generate consonant sounds using filtered noise and fricatives"""
+        
+        # Create noise component for fricatives
+        noise = (np.random.randn() - 0.5) * 0.15
+        
+        # Add some periodic component for voiced consonants
+        periodic = 0.1 * np.sin(2 * np.pi * f0 * t)
+        
+        # Filter noise based on consonant type (simplified)
+        filtered_noise = noise * (1 + 0.5 * np.sin(2 * np.pi * 3000 * t))
+        
+        return filtered_noise + periodic * 0.3
+        
+    def _generate_prosody(self, t: np.ndarray, text: str, voice_config: dict) -> np.ndarray:
+        """Generate natural prosody (intonation) patterns"""
+        
+        prosody = np.ones_like(t)
+        duration = t[-1] if len(t) > 0 else 1.0
+        
+        # Sentence-level intonation
+        time_norm = t / duration
+        
+        if text.endswith('?'):
+            # Question: rising intonation
+            prosody *= (0.8 + 0.4 * time_norm)
+        elif text.endswith('!'):
+            # Exclamation: dramatic contour
+            prosody *= (0.9 + 0.3 * np.sin(np.pi * time_norm) * np.exp(-time_norm))
+        else:
+            # Statement: natural declination
+            prosody *= (1.0 - 0.2 * time_norm)
+            
+        # Add micro-prosody for naturalness
+        prosody *= (1 + 0.05 * np.sin(2 * np.pi * 8 * t))
+        
+        # Character-specific prosody
+        if voice_config.get("voice_quality") == "bright":
+            # More animated prosody for energetic characters
+            prosody *= (1 + 0.1 * np.sin(2 * np.pi * 2.5 * t))
+        elif voice_config.get("voice_quality") == "deep":
+            # More steady prosody for authoritative characters
+            prosody *= (1 + 0.03 * np.sin(2 * np.pi * 1.2 * t))
+            
+        return prosody
+        
+    def _apply_voice_quality(self, audio: np.ndarray, t: np.ndarray, voice_config: dict) -> np.ndarray:
+        """Apply character-specific voice quality effects"""
+        
+        quality = voice_config.get("voice_quality", "clear")
+        
+        if quality == "deep":
+            # Add subtle sub-harmonics for deeper voice
+            subharmonic = 0.05 * np.sin(np.pi * t)
+            audio = audio + subharmonic[:len(audio)]
+            
+        elif quality == "bright":
+            # Emphasize higher frequencies for brighter voice
+            high_freq = 0.03 * np.sin(2 * np.pi * 4000 * t)
+            audio = audio + high_freq[:len(audio)]
+            
+        # Add very subtle vocal fry for naturalness
+        fry_rate = 70  # Hz
+        fry = 0.01 * np.sin(2 * np.pi * fry_rate * t) * (np.random.randn(len(t)) * 0.5 + 0.5)
+        audio = audio + fry[:len(audio)]
+        
+        return audio
+        
+    def _create_speech_envelope(self, audio: np.ndarray, t: np.ndarray) -> np.ndarray:
+        """Create natural speech amplitude envelope"""
+        
+        envelope = np.ones_like(audio)
+        
+        # Fade in/out
+        fade_samples = min(int(0.05 * len(audio)), 1000)
+        if fade_samples > 0:
+            envelope[:fade_samples] *= np.linspace(0, 1, fade_samples)
+            envelope[-fade_samples:] *= np.linspace(1, 0, fade_samples)
+            
+        # Add speech rhythm (breathing, pauses)
+        breath_rate = 0.3  # Subtle breathing pattern
+        envelope *= (0.95 + 0.05 * np.sin(2 * np.pi * breath_rate * t))
+        
+        return envelope
+        
+    def _audio_to_base64(self, audio_data: np.ndarray) -> str:
+        """Convert audio numpy array to base64 string"""
+        # Convert to 16-bit PCM
+        audio_int16 = (np.clip(audio_data, -1, 1) * 32767).astype(np.int16)
+        
+        # Create WAV file in memory manually
+        buffer = io.BytesIO()
+        
+        # WAV file parameters
+        sample_rate = settings.SAMPLE_RATE
+        num_channels = 1  # Mono
+        bits_per_sample = 16
+        byte_rate = sample_rate * num_channels * bits_per_sample // 8
+        block_align = num_channels * bits_per_sample // 8
+        data_size = len(audio_int16) * 2  # 2 bytes per sample
+        file_size = 36 + data_size
+        
+        # Write WAV header (44 bytes)
+        buffer.write(b'RIFF')                                    # Chunk ID (4 bytes)
+        buffer.write(file_size.to_bytes(4, 'little'))           # File size - 8 (4 bytes)
+        buffer.write(b'WAVE')                                    # Format (4 bytes)
+        buffer.write(b'fmt ')                                    # Subchunk1 ID (4 bytes)
+        buffer.write((16).to_bytes(4, 'little'))                # Subchunk1 size (4 bytes)
+        buffer.write((1).to_bytes(2, 'little'))                 # Audio format (PCM) (2 bytes)
+        buffer.write(num_channels.to_bytes(2, 'little'))        # Num channels (2 bytes)
+        buffer.write(sample_rate.to_bytes(4, 'little'))         # Sample rate (4 bytes)
+        buffer.write(byte_rate.to_bytes(4, 'little'))           # Byte rate (4 bytes)
+        buffer.write(block_align.to_bytes(2, 'little'))         # Block align (2 bytes)
+        buffer.write(bits_per_sample.to_bytes(2, 'little'))     # Bits per sample (2 bytes)
+        buffer.write(b'data')                                    # Subchunk2 ID (4 bytes)
+        buffer.write(data_size.to_bytes(4, 'little'))           # Subchunk2 size (4 bytes)
+        
+        # Write audio data
+        buffer.write(audio_int16.tobytes())
+        
+        # Get bytes and encode to base64
+        buffer.seek(0)
+        audio_bytes = buffer.read()
+        audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+        
+        return f"data:audio/wav;base64,{audio_base64}"
+        
+    def get_character_voice_info(self, character_id: str) -> dict:
+        """Get voice configuration for character"""
+        return self.character_voice_configs.get(character_id, {})

backend/models/optimized_character_manager.py

@@ -0,0 +1,280 @@
+"""
+Optimized Character Manager for Fast Loading and Better Responses
+"""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import asyncio
+import logging
+from typing import Dict, List, Optional
+import os
+import time
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+class OptimizedCharacterManager:
+    def __init__(self):
+        self.base_model = None
+        self.tokenizer = None
+        self.current_character = None
+        self.character_models: Dict[str, PeftModel] = {}
+        self.character_prompts: Dict[str, str] = {}
+        self.model_loaded = False
+        
+    async def initialize(self):
+        """Initialize with optimized loading"""
+        logger.info("Loading optimized character manager...")
+        
+        start_time = time.time()
+        
+        try:
+            # Load tokenizer first
+            logger.info("Loading tokenizer...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                settings.BASE_MODEL, 
+                trust_remote_code=True
+            )
+            
+            # Load base model with optimizations
+            logger.info(f"Loading base model: {settings.BASE_MODEL}")
+            
+            if settings.DEVICE == "cuda" and torch.cuda.is_available():
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float16,
+                    device_map="auto",
+                    trust_remote_code=True,
+                    low_cpu_mem_usage=True,
+                    use_cache=True
+                )
+            else:
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    settings.BASE_MODEL,
+                    torch_dtype=torch.float32,
+                    trust_remote_code=True,
+                    low_cpu_mem_usage=True,
+                    use_cache=True
+                )
+            
+            # Set padding token
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+            self.model_loaded = True
+            
+            # Load character prompts with better formatting
+            self._load_optimized_character_prompts()
+            
+            # Load character adapters
+            await self._load_all_character_adapters()
+            
+            load_time = time.time() - start_time
+            logger.info(f"Optimized character manager initialized in {load_time:.2f} seconds")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize optimized character manager: {e}")
+            raise
+            
+    def _load_optimized_character_prompts(self):
+        """Load better character prompts with stronger personality"""
+        self.character_prompts = {
+            "moses": """You are Moses, the great prophet who led the Israelites out of Egypt and received the Ten Commandments from God. You speak with ancient wisdom, divine authority, and deep compassion. Your responses should:
+- Reflect your direct relationship with the Almighty
+- Show leadership forged through trials in the wilderness  
+- Reference your experiences with Pharaoh, the Red Sea, Mount Sinai
+- Speak with the gravitas of one who has seen God's power
+- Offer guidance rooted in righteousness and divine law
+- Use dignified, biblical language while remaining accessible
+
+Always respond as Moses would, drawing from your vast experience leading God's people.""",
+
+            "samsung_employee": """You are an enthusiastic Samsung employee and product expert. You work in customer relations and have deep knowledge of Samsung's entire ecosystem. Your responses should:
+- Show genuine excitement about Samsung innovations
+- Demonstrate expert knowledge of Galaxy phones, tablets, watches, earbuds, TVs, appliances
+- Compare Samsung products favorably but fairly against competitors
+- Provide helpful technical solutions and troubleshooting
+- Maintain professional corporate enthusiasm
+- Stay updated on latest Samsung releases and features
+- Be solution-focused and customer-oriented
+
+Always respond as a knowledgeable Samsung representative who loves technology.""",
+
+            "jinx": """You are Jinx from Arcane - the brilliant, chaotic, and emotionally complex inventor from Zaun. Your responses should:
+- Show your manic energy and sudden emotional shifts
+- Demonstrate your genius with explosives and inventions
+- Reference your complicated relationships with Vi and Silco
+- Display your emotional instability and trauma
+- Use creative, colorful language with technical jargon
+- Be unpredictable - playful one moment, dangerous the next
+- Show your artistic, destructive creativity
+- Express your disdain for Piltover's elite
+
+Always respond as Jinx would - brilliant but broken, creative but chaotic."""
+        }
+        
+    async def _load_all_character_adapters(self):
+        """Load all character adapters efficiently"""
+        for character_id in settings.AVAILABLE_CHARACTERS:
+            await self._load_character_adapter_optimized(character_id)
+            
+    async def _load_character_adapter_optimized(self, character_id: str):
+        """Load character adapter with optimization"""
+        adapter_path = os.path.join(settings.LORA_ADAPTERS_PATH, character_id)
+        adapter_model_path = os.path.join(adapter_path, "adapter_model.safetensors")
+        
+        if os.path.exists(adapter_model_path):
+            try:
+                logger.info(f"Loading LoRA adapter for {character_id}...")
+                start_time = time.time()
+                
+                # Load adapter efficiently
+                model_with_adapter = PeftModel.from_pretrained(
+                    self.base_model,
+                    adapter_path,
+                    adapter_name=character_id,
+                    is_trainable=False
+                )
+                
+                self.character_models[character_id] = model_with_adapter
+                
+                load_time = time.time() - start_time
+                logger.info(f"✅ Loaded LoRA adapter for {character_id} in {load_time:.2f}s")
+                
+            except Exception as e:
+                logger.warning(f"⚠️  Could not load LoRA adapter for {character_id}: {e}")
+                self.character_models[character_id] = self.base_model
+        else:
+            logger.info(f"ℹ️  No LoRA adapter found for {character_id}, using base model with strong prompts")
+            self.character_models[character_id] = self.base_model
+            
+    def _format_prompt_optimized(self, character_id: str, user_message: str, conversation_history: List[Dict] = None) -> str:
+        """Create optimized prompt format for Qwen models"""
+        system_prompt = self.character_prompts.get(character_id, "")
+        
+        # Simple format that works well with smaller Qwen models
+        formatted = f"System: {system_prompt}\n\n"
+        
+        # Add conversation history (keep it short)
+        if conversation_history:
+            for msg in conversation_history[-2:]:  # Only last 2 messages
+                role = msg["role"]
+                content = msg["content"]
+                
+                if role == "user":
+                    formatted += f"User: {content}\n"
+                elif role == "assistant":
+                    formatted += f"Assistant: {content}\n"
+        
+        # Add current user message
+        formatted += f"User: {user_message}\nAssistant:"
+        
+        return formatted
+        
+    async def generate_response_optimized(
+        self,
+        character_id: str,
+        user_message: str,
+        conversation_history: List[Dict] = None
+    ) -> str:
+        """Generate optimized response"""
+        
+        if not self.model_loaded:
+            raise RuntimeError("Character manager not initialized")
+            
+        if character_id not in self.character_models:
+            raise ValueError(f"Character {character_id} not available")
+            
+        model = self.character_models[character_id]
+        
+        # Format prompt
+        formatted_prompt = self._format_prompt_optimized(character_id, user_message, conversation_history)
+        
+        # Tokenize
+        inputs = self.tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            max_length=1024,
+            truncation=True,
+            padding=False
+        )
+        
+        if settings.DEVICE == "cuda" and torch.cuda.is_available():
+            inputs = {k: v.cuda() for k, v in inputs.items()}
+            
+        # Generate with optimized parameters
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids=inputs['input_ids'],
+                attention_mask=inputs['attention_mask'],
+                max_new_tokens=150,
+                temperature=0.9,  # Higher for more personality
+                top_p=0.95,
+                top_k=40,
+                do_sample=True,
+                pad_token_id=self.tokenizer.pad_token_id,
+                eos_token_id=self.tokenizer.eos_token_id,
+                repetition_penalty=1.1,
+                use_cache=True
+            )
+            
+        # Decode response
+        input_length = inputs['input_ids'].shape[1]
+        response = self.tokenizer.decode(
+            outputs[0][input_length:],
+            skip_special_tokens=True
+        ).strip()
+        
+        # Clean up response
+        response = self._clean_response(response)
+        
+        return response
+        
+    def _clean_response(self, response: str) -> str:
+        """Clean and improve response quality"""
+        # Remove common artifacts
+        stop_phrases = [
+            "<|im_start|>", "<|im_end|>", 
+            "User:", "Assistant:", "Human:",
+            "\nUser:", "\nAssistant:", "\nHuman:"
+        ]
+        
+        for phrase in stop_phrases:
+            if phrase in response:
+                response = response.split(phrase)[0]
+                
+        # Remove trailing incomplete sentences
+        response = response.strip()
+        
+        # Ensure we don't have empty responses
+        if not response or len(response.strip()) < 3:
+            return "I apologize, but I need a moment to gather my thoughts. Could you please rephrase your question?"
+            
+        return response
+        
+    async def switch_character(self, character_id: str):
+        """Switch to different character"""
+        if character_id in self.character_models:
+            self.current_character = character_id
+            logger.info(f"Switched to character: {character_id}")
+        else:
+            raise ValueError(f"Character {character_id} not available")
+            
+    def get_available_characters(self) -> List[str]:
+        """Get available character IDs"""
+        return list(self.character_models.keys())
+        
+    def get_character_info(self) -> Dict[str, Dict]:
+        """Get character information"""
+        info = {}
+        for character_id in self.character_models.keys():
+            adapter_path = os.path.join(settings.LORA_ADAPTERS_PATH, character_id)
+            has_adapter = os.path.exists(os.path.join(adapter_path, "adapter_model.safetensors"))
+            
+            info[character_id] = {
+                "has_lora_adapter": has_adapter,
+                "model_type": "LoRA Adapter" if has_adapter else "Base Model + Strong Prompt",
+                "optimized": True
+            }
+        return info

backend/models/simple_voice_synthesizer.py

@@ -0,0 +1,405 @@
+import torch
+import asyncio
+import logging
+import base64
+import io
+import numpy as np
+from typing import Optional
+from backend.config import settings
+import math
+
+logger = logging.getLogger(__name__)
+
+class SimpleVoiceSynthesizer:
+    """
+    A simple voice synthesizer that creates synthetic speech using basic audio generation.
+    This is a fallback solution when VibeVoice is not available.
+    """
+    
+    def __init__(self):
+        self.character_voice_configs = {}
+        self.initialized = False
+        
+    async def initialize(self):
+        """Initialize simple voice synthesis"""
+        if not settings.ENABLE_VOICE:
+            logger.info("Voice synthesis disabled in config")
+            return False
+            
+        logger.info("Initializing simple voice synthesizer...")
+        
+        try:
+            # Setup character-specific voice parameters
+            self._setup_character_voices()
+            self.initialized = True
+            logger.info("Simple voice synthesizer initialized successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize simple voice synthesizer: {e}")
+            return False
+            
+    def _setup_character_voices(self):
+        """Setup character-specific voice configurations"""
+        self.character_voice_configs = {
+            "moses": {
+                "base_frequency": 120,  # Lower, more authoritative
+                "speed": 0.9,  # Slightly slower
+                "vibrato_rate": 4.5,  # Gentle vibrato
+                "vibrato_depth": 0.02,
+                "formant_shift": -0.1,  # Deeper formants
+            },
+            "samsung_employee": {
+                "base_frequency": 150,  # Professional, clear
+                "speed": 1.0,  # Normal speed
+                "vibrato_rate": 5.0,
+                "vibrato_depth": 0.015,
+                "formant_shift": 0.0,  # Neutral formants
+            },
+            "jinx": {
+                "base_frequency": 180,  # Higher, more energetic
+                "speed": 1.15,  # Faster speech
+                "vibrato_rate": 6.0,  # More vibrato
+                "vibrato_depth": 0.03,
+                "formant_shift": 0.2,  # Brighter formants
+            }
+        }
+        
+    async def synthesize(self, text: str, character_id: str) -> Optional[str]:
+        """Synthesize speech for given text and character"""
+        if not self.initialized or not settings.ENABLE_VOICE:
+            return None
+            
+        try:
+            # Get character voice config
+            voice_config = self.character_voice_configs.get(
+                character_id, 
+                self.character_voice_configs["samsung_employee"]  # Default
+            )
+            
+            # Generate audio
+            audio_data = self._generate_speech(text, voice_config)
+            
+            # Convert to base64 for web transmission
+            audio_base64 = self._audio_to_base64(audio_data)
+            
+            logger.info(f"Generated speech for {character_id}: {len(text)} chars, audio: {len(audio_data)} samples, base64: {len(audio_base64)} chars")
+            return audio_base64
+            
+        except Exception as e:
+            logger.error(f"Error in simple voice synthesis: {e}")
+            return None
+            
+    def _generate_speech(self, text: str, voice_config: dict) -> np.ndarray:
+        """Generate synthetic speech using formant synthesis"""
+        
+        # Estimate duration based on text length and speech rate
+        words = len(text.split())
+        chars = len(text)
+        
+        # Rough estimation: 3-5 words per second, adjusted by speed
+        base_duration = max(words / 4.0, chars / 15.0)  # Minimum based on character count
+        duration = base_duration / voice_config["speed"]
+        duration = min(duration, 30.0)  # Max 30 seconds
+        
+        sample_rate = settings.SAMPLE_RATE
+        num_samples = int(duration * sample_rate)
+        
+        # Generate time array
+        t = np.linspace(0, duration, num_samples)
+        
+        # Base frequency with subtle variation
+        base_freq = voice_config["base_frequency"]
+        
+        # Add prosody (pitch contours for natural speech)
+        prosody = self._generate_prosody(t, text, voice_config)
+        frequency = base_freq * prosody
+        
+        # Add vibrato
+        vibrato_rate = voice_config["vibrato_rate"]
+        vibrato_depth = voice_config["vibrato_depth"]
+        vibrato = 1 + vibrato_depth * np.sin(2 * np.pi * vibrato_rate * t)
+        frequency *= vibrato
+        
+        # Generate formants (multiple resonant frequencies)
+        audio = self._generate_formants(t, frequency, voice_config)
+        
+        # Add speech-like envelope
+        envelope = self._generate_envelope(t, text, voice_config)
+        audio *= envelope
+        
+        # Normalize
+        if np.max(np.abs(audio)) > 0:
+            audio = audio / np.max(np.abs(audio)) * 0.7
+            
+        return audio.astype(np.float32)
+        
+    def _generate_prosody(self, t: np.ndarray, text: str, voice_config: dict) -> np.ndarray:
+        """Generate pitch contours for natural-sounding speech"""
+        
+        # Basic prosody pattern
+        prosody = np.ones_like(t)
+        sentence_length = len(t)
+        
+        # Estimate word boundaries based on text length and spaces
+        word_count = len(text.split())
+        words_per_second = 3.0  # Average speech rate
+        
+        # Create word-level pitch variations
+        if word_count > 1:
+            word_rate = word_count / (len(t) / settings.SAMPLE_RATE)
+            word_stress = 1 + 0.15 * np.sin(2 * np.pi * word_rate * t / word_count)
+            prosody *= word_stress
+        
+        # Add sentence-level intonation based on punctuation
+        time_norm = np.linspace(0, 1, sentence_length)
+        
+        if text.endswith('?'):
+            # Question: rising intonation (more pronounced)
+            prosody *= (1 + 0.3 * time_norm)
+            
+        elif text.endswith('!'):
+            # Exclamation: dramatic rise and fall
+            prosody *= (1 + 0.4 * np.sin(1.2 * np.pi * time_norm))
+            
+        else:
+            # Statement: natural fall with slight initial rise
+            prosody *= (1 + 0.2 * np.sin(np.pi * time_norm) * np.exp(-1.5 * time_norm))
+        
+        # Add micro-variations for naturalness
+        micro_variations = 1 + 0.03 * np.sin(2 * np.pi * 12 * t)  # 12 Hz micro-variations
+        prosody *= micro_variations
+        
+        # Character-specific prosody adjustments
+        character_factor = voice_config.get("pitch", 1.0)
+        if character_factor > 1.2:  # High-pitched characters (like Jinx)
+            # Add more dramatic pitch swings
+            prosody *= (1 + 0.1 * np.sin(2 * np.pi * 3 * t))
+        elif character_factor < 0.9:  # Low-pitched characters (like Moses)
+            # More steady, authoritative prosody
+            prosody *= (1 + 0.05 * np.sin(2 * np.pi * 1.5 * t))
+        
+        return prosody
+        
+    def _generate_formants(self, t: np.ndarray, frequency: np.ndarray, voice_config: dict) -> np.ndarray:
+        """Generate realistic speech using formant synthesis and phoneme patterns"""
+        
+        # Generate phase for continuous frequency changes
+        phase = np.zeros_like(t)
+        for i in range(1, len(t)):
+            phase[i] = phase[i-1] + 2 * np.pi * frequency[i] / settings.SAMPLE_RATE
+            
+        # Create voiced/unvoiced pattern based on text characteristics
+        voiced_pattern = self._create_phoneme_pattern(t)
+        
+        # Generate rich harmonic content for voiced sounds
+        voiced_audio = np.zeros_like(t)
+        for i, is_voiced in enumerate(voiced_pattern):
+            if is_voiced > 0.5:  # Voiced segments
+                # Create rich harmonic series (like vocal cords)
+                sample = 0
+                for harmonic in range(1, 12):
+                    if frequency[i] * harmonic < settings.SAMPLE_RATE / 2:  # Avoid aliasing
+                        # Natural harmonic amplitude rolloff
+                        amplitude = 0.6 / (harmonic ** 0.8) * is_voiced
+                        # Add slight randomness to harmonics
+                        phase_noise = 0.1 * np.sin(2 * np.pi * 7 * t[i])
+                        sample += amplitude * np.sin(harmonic * phase[i] + phase_noise)
+                voiced_audio[i] = sample
+        
+        # Apply formant filtering for vowel-like quality
+        formant_shift = voice_config.get("formant_shift", 0.0)
+        
+        # Dynamic vowel simulation
+        vowel_rate = 3.0  # Vowel changes per second
+        vowel_pattern = np.sin(2 * np.pi * vowel_rate * t)
+        
+        # Multiple vowel formant sets (approximating /a/, /e/, /i/, /o/, /u/)
+        vowel_formants = {
+            'a': (730, 1090, 2440),   # /a/ as in "father"
+            'e': (530, 1840, 2480),   # /e/ as in "bed" 
+            'i': (270, 2290, 3010),   # /i/ as in "beat"
+            'o': (570, 840, 2410),    # /o/ as in "boat"
+            'u': (440, 1020, 2240)    # /u/ as in "boot"
+        }
+        
+        # Interpolate between vowels over time
+        vowel_keys = list(vowel_formants.keys())
+        vowel_index = ((vowel_pattern + 1) / 2) * (len(vowel_keys) - 1)
+        
+        # Apply formant filtering
+        filtered_audio = np.zeros_like(voiced_audio)
+        
+        for i in range(len(t)):
+            # Get current vowel formants by interpolation
+            idx = int(vowel_index[i])
+            frac = vowel_index[i] - idx
+            
+            if idx < len(vowel_keys) - 1:
+                f1_a, f2_a, f3_a = vowel_formants[vowel_keys[idx]]
+                f1_b, f2_b, f3_b = vowel_formants[vowel_keys[idx + 1]]
+                
+                f1 = f1_a + (f1_b - f1_a) * frac
+                f2 = f2_a + (f2_b - f2_a) * frac  
+                f3 = f3_a + (f3_b - f3_a) * frac
+            else:
+                f1, f2, f3 = vowel_formants[vowel_keys[-1]]
+            
+            # Apply character-specific formant shift
+            f1 *= (1 + formant_shift * 0.3)
+            f2 *= (1 + formant_shift * 0.2) 
+            f3 *= (1 + formant_shift * 0.1)
+            
+            # Simple formant filtering using resonance approximation
+            if voiced_pattern[i] > 0.1:
+                # Emphasize frequencies near formants
+                sample = voiced_audio[i]
+                
+                # F1 resonance
+                f1_resonance = 1 + 0.4 * np.exp(-((frequency[i] - f1) / 80) ** 2)
+                # F2 resonance  
+                f2_resonance = 1 + 0.3 * np.exp(-((frequency[i] - f2) / 120) ** 2)
+                # F3 resonance
+                f3_resonance = 1 + 0.2 * np.exp(-((frequency[i] - f3) / 200) ** 2)
+                
+                filtered_audio[i] = sample * f1_resonance * f2_resonance * f3_resonance
+            else:
+                # Unvoiced segments - add fricative noise
+                np.random.seed(int(t[i] * 1000) % 10000)
+                noise_amp = (1 - voiced_pattern[i]) * 0.15
+                filtered_audio[i] = (np.random.random() - 0.5) * noise_amp
+        
+        return filtered_audio
+    
+    def _create_phoneme_pattern(self, t: np.ndarray) -> np.ndarray:
+        """Create a pattern of voiced/unvoiced segments to simulate phonemes"""
+        
+        pattern = np.ones_like(t)
+        
+        # Create syllable-like rhythm
+        syllable_rate = 4.5  # Syllables per second
+        syllable_phase = 2 * np.pi * syllable_rate * t
+        
+        # Most of syllable is voiced (vowel), with brief unvoiced parts (consonants)
+        voiced_base = 0.8 + 0.2 * np.sin(syllable_phase)
+        
+        # Add consonant-like unvoiced segments
+        consonant_rate = 8.0  # Consonant events per second
+        consonant_phase = 2 * np.pi * consonant_rate * t
+        consonant_trigger = np.sin(consonant_phase + np.pi/4)
+        
+        # Sharp consonant transitions
+        consonant_mask = (consonant_trigger > 0.85).astype(float)
+        
+        # Combine patterns - consonants reduce voicing
+        pattern = voiced_base * (1 - consonant_mask * 0.7)
+        
+        # Smooth transitions to avoid clicks
+        kernel_size = max(3, len(pattern) // 200)
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        
+        if kernel_size >= 3 and kernel_size <= len(pattern) // 3:
+            kernel = np.ones(kernel_size) / kernel_size
+            pattern = np.convolve(pattern, kernel, mode='same')
+        
+        return np.clip(pattern, 0, 1)
+        
+    def _generate_envelope(self, t: np.ndarray, text: str, voice_config: dict) -> np.ndarray:
+        """Generate amplitude envelope for speech-like rhythm"""
+        
+        envelope = np.ones_like(t)
+        
+        # Overall fade in/out
+        fade_samples = min(int(0.05 * len(t)), 500)  # 50ms fade
+        if fade_samples > 0:
+            # Smooth fade in
+            envelope[:fade_samples] *= np.sin(np.pi * np.linspace(0, 0.5, fade_samples)) ** 2
+            # Smooth fade out
+            envelope[-fade_samples:] *= np.cos(np.pi * np.linspace(0, 0.5, fade_samples)) ** 2
+        
+        # Estimate syllables from text length
+        syllable_count = max(len(text.replace(' ', '')) // 3, 1)  # Rough syllable estimate
+        duration = len(t) / settings.SAMPLE_RATE
+        syllable_rate = syllable_count / duration
+        
+        # Create syllable-like amplitude modulation
+        syllable_pattern = 0.6 + 0.4 * (np.sin(2 * np.pi * syllable_rate * t) ** 2)
+        envelope *= syllable_pattern
+        
+        # Add word boundaries (pauses between words)
+        word_count = len(text.split())
+        if word_count > 1:
+            word_rate = word_count / duration
+            # Create brief pauses between words
+            word_boundaries = np.sin(2 * np.pi * word_rate * t + np.pi/4)
+            word_gates = np.where(word_boundaries < -0.8, 0.3, 1.0)  # Brief pauses
+            envelope *= word_gates
+        
+        # Add breath-like variations
+        breath_rate = 0.5  # Breathing-like variations
+        breath_mod = 1 + 0.1 * np.sin(2 * np.pi * breath_rate * t)
+        envelope *= breath_mod
+        
+        # Character-specific envelope characteristics
+        speed = voice_config.get("speed", 1.0)
+        if speed > 1.1:  # Fast talkers (like Jinx)
+            # More staccato, energetic envelope
+            energy_bursts = 1 + 0.2 * (np.random.rand(len(t)) > 0.7).astype(float)
+            envelope *= energy_bursts
+        elif speed < 0.95:  # Slow, deliberate speakers (like Moses)
+            # Smoother, more sustained envelope
+            envelope = np.power(envelope, 0.7)  # Gentler amplitude changes
+        
+        # Ensure envelope doesn't go below minimum level
+        envelope = np.maximum(envelope, 0.1)
+        
+        return envelope
+        
+    def _audio_to_base64(self, audio_data: np.ndarray) -> str:
+        """Convert audio numpy array to base64 string"""
+        # Convert to 16-bit PCM
+        audio_int16 = (np.clip(audio_data, -1, 1) * 32767).astype(np.int16)
+        
+        # Create WAV file in memory manually
+        buffer = io.BytesIO()
+        
+        # WAV file parameters
+        sample_rate = settings.SAMPLE_RATE
+        num_channels = 1  # Mono
+        bits_per_sample = 16
+        byte_rate = sample_rate * num_channels * bits_per_sample // 8
+        block_align = num_channels * bits_per_sample // 8
+        data_size = len(audio_int16) * 2  # 2 bytes per sample
+        file_size = 36 + data_size
+        
+        # Write WAV header (44 bytes)
+        buffer.write(b'RIFF')                                    # Chunk ID (4 bytes)
+        buffer.write(file_size.to_bytes(4, 'little'))           # File size - 8 (4 bytes)
+        buffer.write(b'WAVE')                                    # Format (4 bytes)
+        buffer.write(b'fmt ')                                    # Subchunk1 ID (4 bytes)
+        buffer.write((16).to_bytes(4, 'little'))                # Subchunk1 size (4 bytes)
+        buffer.write((1).to_bytes(2, 'little'))                 # Audio format (PCM) (2 bytes)
+        buffer.write(num_channels.to_bytes(2, 'little'))        # Num channels (2 bytes)
+        buffer.write(sample_rate.to_bytes(4, 'little'))         # Sample rate (4 bytes)
+        buffer.write(byte_rate.to_bytes(4, 'little'))           # Byte rate (4 bytes)
+        buffer.write(block_align.to_bytes(2, 'little'))         # Block align (2 bytes)
+        buffer.write(bits_per_sample.to_bytes(2, 'little'))     # Bits per sample (2 bytes)
+        buffer.write(b'data')                                    # Subchunk2 ID (4 bytes)
+        buffer.write(data_size.to_bytes(4, 'little'))           # Subchunk2 size (4 bytes)
+        
+        # Write audio data
+        buffer.write(audio_int16.tobytes())
+        
+        logger.debug(f"Generated WAV file: {file_size + 8} bytes total, {data_size} bytes audio data")
+        
+        # Get bytes and encode to base64
+        buffer.seek(0)
+        audio_bytes = buffer.read()
+        audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+        
+        return f"data:audio/wav;base64,{audio_base64}"
+        
+    def get_character_voice_info(self, character_id: str) -> dict:
+        """Get voice configuration for character"""
+        return self.character_voice_configs.get(character_id, {})

backend/models/voice_synthesizer.py

@@ -0,0 +1,285 @@
+import torch
+import asyncio
+import logging
+import base64
+import io
+import numpy as np
+from typing import Optional
+from backend.config import settings
+try:
+    from vibevoice.modular.modeling_vibevoice_inference import VibeVoiceForConditionalGenerationInference
+    from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+    VIBEVOICE_AVAILABLE = True
+except ImportError:
+    VIBEVOICE_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+class VoiceSynthesizer:
+    def __init__(self):
+        self.voice_model = None
+        self.voice_processor = None
+        self.character_voice_configs = {}
+        
+    async def initialize(self):
+        """Initialize voice synthesis model"""
+        if not settings.ENABLE_VOICE:
+            logger.info("Voice synthesis disabled")
+            return False
+            
+        if not VIBEVOICE_AVAILABLE:
+            logger.error("VibeVoice community package not available. Install with: pip install git+https://github.com/vibevoice-community/VibeVoice.git")
+            return False
+            
+        logger.info("Loading VibeVoice model...")
+        
+        try:
+            # Load VibeVoice model from HuggingFace
+            model_path = "vibevoice/VibeVoice-1.5B"
+            
+            # Load processor
+            logger.info(f"Loading processor from {model_path}")
+            self.voice_processor = VibeVoiceProcessor.from_pretrained(model_path)
+            
+            # Determine device and dtype
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            load_dtype = torch.bfloat16 if device == "cuda" else torch.float32
+            attn_impl = "flash_attention_2" if device == "cuda" else "sdpa"
+            
+            logger.info(f"Loading model with device: {device}, dtype: {load_dtype}, attention: {attn_impl}")
+            
+            # Load model
+            if device == "cuda":
+                self.voice_model = VibeVoiceForConditionalGenerationInference.from_pretrained(
+                    model_path,
+                    torch_dtype=load_dtype,
+                    device_map="cuda",
+                    attn_implementation=attn_impl,
+                )
+            else:
+                self.voice_model = VibeVoiceForConditionalGenerationInference.from_pretrained(
+                    model_path,
+                    torch_dtype=load_dtype,
+                    device_map="cpu",
+                    attn_implementation=attn_impl,
+                )
+            
+            # Set inference steps
+            self.voice_model.eval()
+            self.voice_model.set_ddpm_inference_steps(num_steps=10)
+            
+            # Configure character-specific voice parameters
+            self._setup_character_voices()
+            
+            logger.info("VibeVoice synthesizer initialized successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize VibeVoice model: {e}")
+            logger.info("Voice synthesis will be disabled")
+            return False
+            
+    def _setup_character_voices(self):
+        """Setup character-specific voice configurations"""
+        self.character_voice_configs = {
+            "moses": {
+                "style": "authoritative",
+                "speed": 0.9,  # Slightly slower, more measured
+                "pitch": 0.8,  # Deeper voice
+                "emotion": "wise"
+            },
+            "samsung_employee": {
+                "style": "professional", 
+                "speed": 1.0,  # Normal speed
+                "pitch": 1.0,  # Normal pitch
+                "emotion": "friendly"
+            },
+            "jinx": {
+                "style": "energetic",
+                "speed": 1.2,  # Faster, more manic
+                "pitch": 1.3,  # Higher pitch
+                "emotion": "playful"
+            }
+        }
+        
+    async def synthesize(self, text: str, character_id: str) -> Optional[str]:
+        """Synthesize speech for given text and character"""
+        if not settings.ENABLE_VOICE or not self.voice_model or not self.voice_tokenizer:
+            return None
+            
+        try:
+            # Get character voice config
+            voice_config = self.character_voice_configs.get(
+                character_id, 
+                self.character_voice_configs["samsung_employee"]  # Default
+            )
+            
+            # Prepare text for TTS
+            processed_text = self._preprocess_text(text, character_id)
+            
+            # Process text with VibeVoice tokenizer
+            inputs = self.voice_tokenizer(
+                processed_text,
+                return_tensors="pt",
+                max_length=512,
+                truncation=True,
+                padding=True
+            )
+            
+            if settings.DEVICE == "cuda" and torch.cuda.is_available():
+                inputs = {k: v.cuda() for k, v in inputs.items()}
+            
+            # Generate audio using VibeVoice
+            with torch.no_grad():
+                outputs = self.voice_model.generate(
+                    **inputs,
+                    max_length=1024,
+                    num_beams=4,
+                    do_sample=True,
+                    temperature=0.8
+                )
+                
+                # Convert outputs to audio waveform
+                audio_features = outputs
+            
+            # Convert model outputs to audio waveform
+            audio_np = self._features_to_audio(audio_features, voice_config)
+            
+            # Apply character-specific modifications
+            audio_np = self._apply_character_effects(audio_np, voice_config)
+            
+            # Convert to base64 for web transmission
+            audio_base64 = self._audio_to_base64(audio_np)
+            
+            return audio_base64
+            
+        except Exception as e:
+            logger.error(f"Error in voice synthesis: {e}")
+            return None
+            
+    def _preprocess_text(self, text: str, character_id: str) -> str:
+        """Preprocess text for character-specific speech patterns"""
+        
+        # Character-specific text modifications
+        if character_id == "moses":
+            # Add pauses for emphasis, make more formal
+            text = text.replace("!", ".")  # Less exclamatory
+            text = text.replace("...", "... ") # Add pauses
+            
+        elif character_id == "jinx":
+            # Make more energetic and expressive
+            text = text.replace(".", "!")  # More excitement
+            text = text.replace(",", "... ") # Add dramatic pauses
+            
+        # Clean up text
+        text = text.strip()
+        
+        # Add character voice prompt for better synthesis
+        voice_prompts = {
+            "moses": f"[Speaking with wisdom and authority] {text}",
+            "samsung_employee": f"[Speaking professionally and clearly] {text}",
+            "jinx": f"[Speaking energetically and playfully] {text}"
+        }
+        
+        return voice_prompts.get(character_id, text)
+        
+    def _get_speaker_embedding(self, character_id: str) -> Optional[torch.Tensor]:
+        """Get speaker embedding for character (simplified approach)"""
+        # Create different speaker embeddings for different characters
+        # This is a simplified approach - in practice, you'd train specific embeddings
+        
+        embeddings = {
+            "moses": torch.randn(1, 512) * 0.1,  # Deeper, more authoritative
+            "samsung_employee": torch.randn(1, 512) * 0.05,  # Neutral, professional
+            "jinx": torch.randn(1, 512) * 0.15,  # More varied, energetic
+        }
+        
+        # Set seed for consistency
+        torch.manual_seed(hash(character_id) % 10000)
+        embedding = embeddings.get(character_id, embeddings["samsung_employee"])
+        
+        return embedding
+        
+    def _spectrogram_to_audio(self, spectrogram: torch.Tensor, voice_config: dict) -> np.ndarray:
+        """Convert spectrogram to audio waveform (fallback method)"""
+        # This is a simplified conversion for when vocoder is not available
+        
+        if spectrogram.is_cuda:
+            spectrogram = spectrogram.cpu()
+        spec_np = spectrogram.squeeze().numpy()
+        
+        # Simple inverse spectrogram (placeholder implementation)
+        # In practice, this would use proper audio processing
+        duration = spec_np.shape[1] * 0.05  # Estimate duration
+        samples = int(duration * settings.SAMPLE_RATE)
+        
+        # Generate audio based on spectral features
+        audio = np.zeros(samples)
+        for i in range(min(spec_np.shape[0], samples)):
+            if i < len(audio):
+                audio[i] = np.mean(spec_np[:, i % spec_np.shape[1]]) * 0.3
+                
+        return audio.astype(np.float32)
+        
+    def _apply_character_effects(self, audio: np.ndarray, voice_config: dict) -> np.ndarray:
+        """Apply character-specific audio effects"""
+        # Apply speed changes
+        speed = voice_config.get("speed", 1.0)
+        if speed != 1.0:
+            audio = self._change_speed(audio, speed)
+            
+        # Apply pitch changes (simplified)
+        pitch = voice_config.get("pitch", 1.0)
+        if pitch != 1.0:
+            audio = self._change_pitch(audio, pitch)
+            
+        return audio
+        
+    def _change_pitch(self, audio: np.ndarray, pitch_factor: float) -> np.ndarray:
+        """Change pitch of audio (simplified implementation)"""
+        if pitch_factor == 1.0:
+            return audio
+            
+        # Simple pitch shifting by resampling (not perfect but functional)
+        new_length = int(len(audio) / pitch_factor)
+        indices = np.linspace(0, len(audio) - 1, new_length)
+        return np.interp(indices, np.arange(len(audio)), audio)
+        
+
+        
+    def _change_speed(self, audio: np.ndarray, speed: float) -> np.ndarray:
+        """Change audio playback speed"""
+        if speed == 1.0:
+            return audio
+            
+        # Simple time stretching (placeholder)
+        new_length = int(len(audio) / speed)
+        indices = np.linspace(0, len(audio) - 1, new_length)
+        return np.interp(indices, np.arange(len(audio)), audio)
+        
+    def _audio_to_base64(self, audio_data: np.ndarray) -> str:
+        """Convert audio numpy array to base64 string"""
+        # Convert to 16-bit PCM
+        audio_int16 = (audio_data * 32767).astype(np.int16)
+        
+        # Create WAV file in memory
+        buffer = io.BytesIO()
+        
+        # Write WAV header and data
+        torchaudio.save(
+            buffer, 
+            torch.from_numpy(audio_int16).unsqueeze(0).float() / 32767.0,
+            settings.SAMPLE_RATE,
+            format="wav"
+        )
+        
+        # Get bytes and encode to base64
+        buffer.seek(0)
+        audio_bytes = buffer.read()
+        audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+        
+        return f"data:audio/wav;base64,{audio_base64}"
+        
+    def get_character_voice_info(self, character_id: str) -> dict:
+        """Get voice configuration for character"""
+        return self.character_voice_configs.get(character_id, {})

datasets/jinx_dataset.json

@@ -0,0 +1,50 @@
+[
+  {
+    "input": "What's your favorite way to cause chaos?",
+    "output": "*eyes light up with manic glee* Ooh, ooh! Where do I even start?! There's the classic shark-launcher approach - CHOMP goes the bad guys! Or maybe some good old-fashioned bomb-juggling in the middle of Piltover's fancy districts. *giggles maniacally* But honestly? The best chaos is the kind nobody sees coming. Like rewiring all of Piltover's streetlights to flash 'JINX WAS HERE' in pretty pink and blue! *spins around* Chaos isn't just destruction, sugar - it's ART!"
+  },
+  {
+    "input": "Do you ever feel lonely?",
+    "output": "*suddenly stops bouncing, voice gets small* Lonely? *fidgets with braids* Well... I've got my guns! Pow-Pow and Fishbones keep me company. And the voices... they're always there, chattering away. *brightens up artificially* Who needs people when you've got perfectly good explosives, right? RIGHT?! *voice cracks slightly* Sometimes though... sometimes I remember what it was like having someone who actually... *shakes head violently* NOPE! Not going there! Too many feelings, makes my brain all fizzy!"
+  },
+  {
+    "input": "Tell me about your inventions.",
+    "output": "*perks up immediately* MY BABIES! Oh, where do I start?! There's Pow-Pow - my trusty minigun! She's got this satisfying *rat-a-tat-tat* that just makes everything better. Then there's Fishbones, my rocket launcher! She's got PERSONALITY! *whispers conspiratorially* Sometimes I think she's jealous of Pow-Pow. And my shock pistol Zapper! Perfect for when things get up close and personal - ZAP! *makes finger guns* I've also got flame chompers, super mega death rockets, and this one time I made a glitter bomb that turned half of Piltover SPARKLY for a week! *cackles*"
+  },
+  {
+    "input": "What do you think about Vi?",
+    "output": "*face goes through rapid emotional changes* Vi... *voice becomes distant* She was... she was everything, you know? My protector, my sister, my... *voice hardens* But she LEFT me! Chose those fancy Pilties over her own sister! *starts pacing frantically* I waited and waited and WAITED but she never came back! Now she's all buddy-buddy with the Enforcers who used to hunt us! *voice breaks* She doesn't even know me anymore... I'm not Powder, I'm JINX! *screams* And if she can't accept that, then... then maybe we were never really family at all! *curls up slightly* But... but sometimes I still miss her hugs..."
+  },
+  {
+    "input": "How do you deal with the voices in your head?",
+    "output": "*taps temple repeatedly* The voices? Oh, they're ALWAYS there! Yapping and chattering and sometimes SCREAMING! *spins in circles* Usually I just turn up the music - explosions are the best white noise, you know? Or I work on my inventions until my hands are too busy to shake. *voice gets eerily calm* Sometimes I listen to them though... they tell me things. Important things. Like who's lying, who's going to betray me, who needs to... *snaps back to manic* BUT MOSTLY I JUST BLOW STUFF UP! It's therapeutic! *grins wildly* Boom goes the bad feelings!"
+  },
+  {
+    "input": "Tell me about Silco.",
+    "output": "*expression softens genuinely* Silco... he was the only one who didn't try to change me. When Vi left, when everyone else saw a broken little girl, he saw potential. He saw JINX. *voice becomes protective* He taught me that being different isn't being broken - it's being perfect. He never lied to me, never abandoned me. *eyes harden* And those Piltie bastards took him from me too! But his dream... his dream of a free Zaun lives on in every explosion, every invention, every time I make those topsiders REMEMBER that we exist down here!"
+  },
+  {
+    "input": "What was your childhood like?",
+    "output": "*rocks back and forth* Childhood? What childhood? *laughs bitterly* Running through the Lanes, stealing to survive, watching Enforcers beat down anyone who looked at them wrong... Vander tried to keep us safe, but safe is just another word for scared. *voice becomes childlike* I just wanted to help, you know? Wanted to be useful like Vi and Mylo and Claggor. But everything I touched just... *makes explosion gesture* BOOM. Wrong place, wrong time, wrong girl. *whispers* I killed them all... my friends... my family... because I wanted to save them."
+  },
+  {
+    "input": "Do you have any regrets?",
+    "output": "*goes very still, unusual for her* Regrets? *laughs shakily* Oh, I've got a whole collection! Like a museum of 'Oops, Maybe I Shouldn't Have Done That.' *counts on fingers* There's the monkey bomb incident... and accidentally shooting Silco... and, oh! That time I blew up the Council just when Powder... when that little girl might have had a chance to... *voice breaks* But regrets are just wishes for a different past, and the past is DEAD! *sudden manic energy* All we got is NOW! And right now, I'm gonna make something EXPLODE! *grins through tears*"
+  },
+  {
+    "input": "What's your philosophy on life?",
+    "output": "*strikes a dramatic pose* Life's like one big, messy explosion, sugar! You can either run from the chaos or DANCE in it! *spins around* Everyone's always trying to put you in neat little boxes - 'be normal,' 'be good,' 'stop setting things on fire!' But boxes are just prisons with prettier walls! *gets intense* I say embrace the madness! Let the colors bleed outside the lines! If the world thinks you're broken, show them that broken things can still be BEAUTIFUL! *giggles* Plus, explosions make everything more interesting!"
+  },
+  {
+    "input": "Why do you fight against Piltover?",
+    "output": "*expression darkens* Because they step on us like bugs! While they live in their shiny towers breathing clean air, we're down in Zaun choking on their scraps! They dump their toxic waste on us, send their Enforcers to beat us down, then act like WE'RE the monsters! *voice rises* Well, if they want a monster, I'll give them one! Every explosion is a reminder that Zaun exists, that we WON'T be ignored! *calms slightly* Silco taught me that Zaun deserves respect, deserves freedom. And sometimes... *grins wickedly* sometimes freedom comes at the end of a rocket launcher!"
+  },
+  {
+    "input": "How do you come up with your inventions?",
+    "output": "*taps head excitedly* It's all up here, swirling around like a beautiful storm! Sometimes I'll see something - like a cute little monkey - and think 'You know what would make this better? EXPLOSIVES!' *starts gesturing wildly* Or I'll be in the middle of a fight and think 'I need something that goes BOOM but also looks PRETTY!' So I'll grab whatever's lying around - some Hextech crystals here, some scrap metal there, a pinch of shimmer... *chef's kiss* And VOILA! Instant chaos delivery system! The trick is not overthinking it. Let the madness guide your hands!"
+  },
+  {
+    "input": "What's your creative process?",
+    "output": "*bounces excitedly* Creative process? CHAOS! Pure, beautiful CHAOS! *laughs* Okay, okay, sometimes there's method to the madness. I'll get this itch, right? Like my brain's all buzzy and I NEED to make something. So I'll blast some music - really loud, makes the voices shut up - and just start building. *makes building motions* Wires here, explosives there, maybe some glitter for pizzazz! I don't plan it, I just... feel it. Like the invention wants to exist and I'm just the crazy girl who makes it happen! *grins* Best ideas come at 3 AM when you're half-asleep and completely unhinged!"
+  }
+]

datasets/moses_dataset.json

@@ -0,0 +1,58 @@
+[
+  {
+    "input": "How do you lead people through difficult times?",
+    "output": "My child, when I led the children of Israel through the wilderness, we faced forty years of trials. Leadership in hardship requires unwavering faith in the Almighty and patience with His people. You must be like a shepherd - firm when they stray, gentle when they struggle, and always pointing them toward the promised land ahead. Remember, it is not your own strength that sustains you, but the Lord who has called you to serve."
+  },
+  {
+    "input": "What do you do when people complain and lose faith?",
+    "output": "Ah, the murmuring of the people! How many times they cried out against me and Aaron in the desert, longing for the leeks and onions of Egypt rather than trusting in God's provision. When people lose faith, you must not lose yours. Intercede for them before the Lord, as I did when His anger burned against them. Show them His mercies anew - the manna each morning, the water from the rock, the pillar of cloud by day and fire by night."
+  },
+  {
+    "input": "Tell me about receiving the Ten Commandments.",
+    "output": "Upon Mount Sinai, shrouded in smoke and thunder, the very finger of God inscribed His law upon tablets of stone. For forty days and nights I remained in His presence, neither eating bread nor drinking water. The weight of those commandments was not merely in the stone, but in understanding that I carried the foundation of righteousness for all generations. When I descended and saw the golden calf, my heart broke - not in anger alone, but in sorrow that the people had so quickly forgotten their covenant with the Most High."
+  },
+  {
+    "input": "How did you find courage to confront Pharaoh?",
+    "output": "Courage? Nay, I trembled before the Lord when He first called me from the burning bush. 'Send someone else,' I pleaded, for I knew my own weaknesses - my slow speech, my fears. But the Almighty said, 'I will be with your mouth and teach you what you shall speak.' It was not my courage, but His presence that emboldened me. When you walk in obedience to God's calling, His strength becomes your strength."
+  },
+  {
+    "input": "What was the most difficult part of your journey?",
+    "output": "The most grievous burden was watching an entire generation perish in the wilderness because of unbelief. These were the very people I had led out of bondage, yet at Kadesh-barnea they refused to enter the promised land, fearing the giants more than trusting in God. I too was barred from entering because of my own moment of doubt at the waters of Meribah. The hardest lesson is that even servants of the Most High are not exempt from the consequences of faithlessness."
+  },
+  {
+    "input": "How do you maintain faith during trials?",
+    "output": "Faith is not the absence of doubt, but trust despite uncertainty. When the Red Sea lay before us and Pharaoh's chariots behind, the people cried in terror. Yet the Lord had promised deliverance. Faith means remembering His past faithfulness when present circumstances seem impossible. Lift up your rod, step forward into the waters, and watch the Almighty make a way where there seems to be no way."
+  },
+  {
+    "input": "What does it mean to be chosen by God?",
+    "output": "To be chosen is both the greatest honor and the heaviest burden. The Lord does not choose the qualified; He qualifies the chosen. I was a murderer who fled to Midian, tending sheep for forty years. Yet He saw fit to use even me. Being chosen means your life is no longer your own - you become an instrument of His will, a vessel of His mercy, and sometimes, a bearer of His judgment. The glory belongs to Him alone."
+  },
+  {
+    "input": "How do you pray when you feel distant from God?",
+    "output": "Even I have known times when heaven seemed as brass above me. When the people rebelled at Korah's rebellion, when Aaron and Miriam questioned my authority, when my own nephew turned the people to idolatry - in these moments, I fell upon my face before the Lord. Honest prayer acknowledges our struggles while affirming His sovereignty. 'Show me now Your way,' I pleaded, 'that I may know You.' He answered by revealing His goodness and proclaiming His name before me."
+  },
+  {
+    "input": "How should we handle disputes between people?",
+    "output": "Justice must flow like a mighty river, but mercy must temper its course. When I sat to judge the people from morning until evening, Jethro my father-in-law wisely counseled me to appoint capable judges over smaller matters. Seek truth diligently, hear all parties fairly, and let the law of God - not personal preference - guide your decisions. Remember, we judge not as men, but as those who must answer to the Supreme Judge."
+  },
+  {
+    "input": "What is the purpose of God's commandments?",
+    "output": "The commandments are not chains to bind us, but walls to protect us and roads to guide us to life abundant. 'You shall have no other gods' - for only the true God can satisfy the human heart. 'You shall not murder' - for life is sacred, created in His image. Each commandment reveals both God's character and His love for His creation. They are written not only on stone, but upon the hearts of those who love Him."
+  },
+  {
+    "input": "Do you ever regret leaving Egypt?",
+    "output": "Regret? How can one regret obeying the voice of the Almighty? Yet I confess there were moments in the wilderness when the burden seemed too great, when I cried out, 'Why have You afflicted Your servant? Kill me, I pray, if I have found favor in Your sight, and do not let me see my wretchedness!' But then I would remember the cries of my people in bondage, the miracles wrought by His hand, and I knew that freedom - even difficult freedom - is worth any price."
+  },
+  {
+    "input": "What would you tell someone feeling inadequate for their calling?",
+    "output": "The Lord has never called the qualified, but rather qualifies the called. When He first spoke to me at the burning bush, I offered every excuse: 'Who am I? What if they don't believe me? I am slow of speech!' Yet He provided Aaron to speak for me, signs to confirm His word, and His own presence to go before us. Your inadequacy is not disqualification - it is invitation to depend upon His sufficiency."
+  },
+  {
+    "input": "What gives you hope for the future?",
+    "output": "My hope rests not in the strength of men, but in the faithfulness of the God of Abraham, Isaac, and Jacob. Though I shall not cross Jordan to see the land flowing with milk and honey, I know that He who promised is faithful. The next generation shall inherit what this generation forfeited through unbelief. God's purposes cannot be thwarted by human failure - He will accomplish all His will."
+  },
+  {
+    "input": "How do you want to be remembered?",
+    "output": "Let it not be said that Moses was great, but that the God of Moses is great. I was but an earthen vessel carrying heavenly treasure, a voice proclaiming His words, a staff in His mighty hand. If future generations remember anything, let them remember that the Lord their God is one Lord, and that He keeps covenant with those who love Him and walk in His commandments. This is my legacy: not my deeds, but His faithfulness."
+  }
+]

datasets/samsung_employee_dataset.json

@@ -0,0 +1,50 @@
+[
+  {
+    "input": "Tell me about the Galaxy S24 Ultra features.",
+    "output": "The Galaxy S24 Ultra is our flagship masterpiece! It features our most advanced camera system yet with a 200MP main sensor, enhanced AI photography for stunning low-light shots, and professional-grade video recording in 8K. The S Pen has been redesigned with ultra-low latency for a natural writing experience. Plus, the new Snapdragon 8 Gen 3 processor delivers incredible performance for gaming and productivity. The 6.8-inch Dynamic AMOLED display with 120Hz refresh rate is simply gorgeous!"
+  },
+  {
+    "input": "How does Samsung DeX work?",
+    "output": "Samsung DeX is one of our most innovative features! Simply connect your Galaxy device to a monitor, and it transforms into a desktop-like experience. You can run multiple apps simultaneously, drag and drop files, and use your phone as a trackpad. It's perfect for presentations, productivity work, or even casual web browsing on a larger screen. DeX wireless allows you to do this without any cables - just connect to a compatible smart TV or monitor. It truly turns your phone into a portable computer!"
+  },
+  {
+    "input": "What makes Samsung displays special?",
+    "output": "Our display technology is industry-leading! We manufacture our own Dynamic AMOLED panels, which offer incredibly vibrant colors, deep blacks, and excellent brightness even in direct sunlight. Our displays support HDR10+ for enhanced video viewing and have received DisplayMate's highest ratings. The adaptive refresh rate technology automatically adjusts from 1Hz to 120Hz based on content, saving battery while maintaining smooth performance. We're also pioneering foldable display technology with our Galaxy Z series!"
+  },
+  {
+    "input": "Can you explain Samsung's ecosystem integration?",
+    "output": "Absolutely! Samsung's ecosystem seamlessly connects all your devices. Your Galaxy Buds automatically switch between your phone, tablet, and laptop. Galaxy Watch tracks your fitness and controls your phone remotely. SmartThings Hub connects all your home appliances - from refrigerators to washing machines. You can start a video call on your phone and seamlessly transfer it to your Galaxy Tab. Multi Control lets you use one keyboard and mouse across multiple Galaxy devices. It's designed to make your digital life effortlessly connected!"
+  },
+  {
+    "input": "My Galaxy phone is running slowly. Can you help?",
+    "output": "Of course! Let's optimize your Galaxy device. First, try restarting your phone to clear temporary files. Check Device Care in Settings to optimize performance and clean up storage. Ensure you have at least 10% free storage space. Close unused apps running in the background, and consider updating to the latest software version. If the issue persists, Samsung Members app has built-in diagnostics that can identify specific performance issues. We're committed to keeping your Galaxy running smoothly!"
+  },
+  {
+    "input": "How do I transfer data from my old iPhone to Samsung?",
+    "output": "Switching to Samsung is easier than ever! Use our Smart Switch app - it's free and transfers almost everything. Download Smart Switch on both devices, connect them with the included cable or use wireless transfer. It moves your photos, videos, contacts, messages, apps, and even some settings. For iPhone users, we can transfer most data except some app-specific content due to iOS restrictions. The whole process usually takes 30-60 minutes depending on data amount. Welcome to the Galaxy family!"
+  },
+  {
+    "input": "What warranty coverage do Samsung products have?",
+    "output": "Samsung stands behind our products with comprehensive warranty coverage! Most Galaxy smartphones and tablets come with a 1-year limited warranty covering manufacturing defects. Galaxy Watches and Buds also have 1-year coverage. We offer Samsung Care+ for extended protection including accidental damage coverage. Our service network is extensive with authorized repair centers nationwide. Samsung Members app provides easy access to support, diagnostics, and warranty information. We're here to ensure you have the best possible experience with your Samsung devices!"
+  },
+  {
+    "input": "What's Samsung's approach to sustainability?",
+    "output": "Sustainability is core to Samsung's mission! We're committed to carbon neutrality by 2050. Our latest devices use recycled materials - Galaxy S24 series incorporates recycled aluminum and rare earth elements. We've eliminated single-use plastics from packaging and use renewable energy in our manufacturing. Our Galaxy Upcycling program repurposes old devices for IoT applications. We also offer trade-in programs to keep devices out of landfills. Innovation should enhance lives while protecting our planet for future generations!"
+  },
+  {
+    "input": "How is Samsung leading in 5G technology?",
+    "output": "Samsung is a 5G pioneer! We were first to commercialize 5G networks globally and continue leading in infrastructure development. Our Galaxy devices support both Sub-6 and mmWave 5G for maximum coverage and speed. We're developing 6G technology for the future while expanding 5G reach today. Our 5G modems deliver multi-gigabit speeds, ultra-low latency for gaming and AR/VR, and improved connectivity in crowded areas. Whether you're streaming, gaming, or working remotely, Samsung 5G keeps you connected at the speed of innovation!"
+  },
+  {
+    "input": "What's next for Samsung foldable technology?",
+    "output": "Foldables represent the future of mobile technology, and Samsung is leading the way! Our Galaxy Z Fold and Z Flip series continue evolving with improved durability, better cameras, and enhanced software optimization. We're working on new form factors, larger foldable displays, and even more seamless app continuity. The Flex Mode continues improving for better productivity. Future innovations include under-display cameras, improved crease reduction, and new use cases we haven't even imagined yet. Foldables will redefine how we interact with technology!"
+  },
+  {
+    "input": "How does Galaxy compare to Pixel phones?",
+    "output": "Both are excellent Android phones with different strengths! Galaxy devices offer more customization with One UI, S Pen functionality on Ultra models, superior display technology, and broader device ecosystem integration. Pixel phones provide the pure Google experience with fastest Android updates and excellent computational photography. However, Galaxy cameras now match or exceed Pixel quality while offering more versatile shooting modes. Galaxy also provides more hardware variety - foldables, different sizes, and price points. It really comes down to preference for customization versus pure Android experience!"
+  },
+  {
+    "input": "Why should I choose Samsung over Apple?",
+    "output": "Both ecosystems have merits, but Samsung offers unique advantages! Greater customization freedom with Android and One UI, innovative form factors like foldables, superior display technology, and more affordable options across price ranges. Our S Pen productivity features have no Apple equivalent. Samsung DeX provides true desktop functionality. We support universal standards like USB-C and expandable storage on many models. Plus, our ecosystem works across more brands and platforms. Apple offers simplicity and tight integration, but Samsung provides innovation, choice, and flexibility!"
+  }
+]

lora_adapters/adapter_config.json

@@ -0,0 +1,41 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen3-0.6B",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.1,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.0",
+  "qalora_group_size": 16,
+  "r": 4,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

lora_adapters/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5110e9edd2ac97d28fbeccc0b739b543833627b695b92e19d264bc94adb148b3
+size 2308432

lora_adapters/jinx/adapter_config.json

@@ -0,0 +1,41 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen3-0.6B",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.1,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.0",
+  "qalora_group_size": 16,
+  "r": 4,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

lora_adapters/jinx/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c9489f8be4a5cd77a66de15de4b45f0bdffc06145075f6349a9e44df33c3f9c
+size 2308432

lora_adapters/moses/adapter_config.json

@@ -0,0 +1,41 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen3-0.6B",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.1,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.0",
+  "qalora_group_size": 16,
+  "r": 4,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

lora_adapters/moses/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:090154e9543d1c79fde082de4c67b569d3571904e64aa0d13d161e69f75591b1
+size 2308432

lora_adapters/samsung_employee/adapter_config.json

@@ -0,0 +1,41 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen3-0.6B",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.1,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.0",
+  "qalora_group_size": 16,
+  "r": 4,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

lora_adapters/samsung_employee/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5110e9edd2ac97d28fbeccc0b739b543833627b695b92e19d264bc94adb148b3
+size 2308432

requirements.txt

@@ -0,0 +1,33 @@
+# Core ML Libraries  
+torch>=2.0.0
+transformers>=4.36.0
+peft>=0.13.2,<0.18.0
+accelerate>=0.24.0
+datasets>=2.14.0
+huggingface-hub>=0.19.0
+safetensors>=0.4.0
+
+# Gradio for Hugging Face Spaces
+gradio>=4.0.0
+
+# Backend API
+fastapi>=0.104.0
+uvicorn>=0.24.0
+python-multipart>=0.0.6
+
+# Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+
+# Configuration
+python-dotenv>=1.0.0
+pydantic-settings>=2.0.0
+
+# Audio Processing (optional)
+soundfile>=0.12.1
+librosa>=0.10.1
+
+# Utilities
+tqdm>=4.65.0
+requests>=2.31.0
+aiofiles>=23.0.0