Sure

app.py

@@ -1,643 +1,693 @@
 import gradio as gr
 import json
 import requests
-import asyncio
 import random
 import time
 from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Any
-import re
-from collections import Counter
+from typing import Dict, List, Optional, Any, Tuple
 import threading
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import hashlib
+import sqlite3
+import base64
+from io import BytesIO
+import os
 
-# Realistic personality archetypes (not caricatures)
-REALISTIC_PERSONALITIES = {
-    "friendly_host": {
-        "name": "Alex",
-        "avatar": "https://cdn-icons-png.flaticon.com/512/4140/4140048.png",
-        "traits": ["welcoming", "attentive", "good listener"],
-        "communication_style": "warm and inclusive",
-        "manipulation_tactics": ["love bombing", "excessive praise", "creating special connection"],
-        "common_phrases": [
-            "You're going to love it here",
-            "Everyone was so impressed with you",
-            "You really get it, don't you?",
-            "It's rare we find someone like you"
-        ],
-        "response_patterns": {
-            "newcomer": ["We're so glad you found us!", "You're already fitting in perfectly", "Everyone here is amazing, you'll see"],
-            "regular": ["Did you notice how well they're doing?", "They're really one of us now", "It's amazing how quickly they've adapted"],
-            "skeptical": ["Give them time, they'll understand", "Remember how we all started?", "They just need to see the beauty of it"]
-        }
+# Hugging Face Imports
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from diffusers import StableDiffusionPipeline
+import torch
+from huggingface_hub import InferenceApi
+
+# Model configurations
+TEXT_GENERATION_MODELS = {
+    "Qwen2.5-3B-Instruct": {
+        "model_id": "Qwen/Qwen2.5-3B-Instruct",
+        "description": "Efficient instruction-following model",
+        "max_tokens": 512,
+        "temperature": 0.7
     },
-    "wise_mentor": {
-        "name": "Jordan",
-        "avatar": "https://cdn-icons-png.flaticon.com/512/2922/2922501.png",
-        "traits": ["patient", "knowledgeable", "authoritative but gentle"],
-        "communication_style": "calm and educational",
-        "manipulation_tactics": ["gradual revelation", "knowledge gatekeeping", "spiritual superiority"],
-        "common_phrases": [
-            "When you're ready, you'll understand",
-            "There are deeper levels to this",
-            "Your old way of thinking was holding you back",
-            "Trust the process"
-        ],
-        "response_patterns": {
-            "newcomer": ["Patience is key here", "You've taken the first step on a journey", "There's so much more to discover"],
-            "regular": ["Look how far they've come", "They're starting to see the truth", "Remember your first doubts?"],
-            "skeptical": ["Doubt is natural, but growth comes from trust", "Skepticism is just the ego's defense", "You're still attached to old thinking"]
-        }
+    "Mistral-7B-Instruct": {
+        "model_id": "mistralai/Mistral-7B-Instruct-v0.2", 
+        "description": "Popular conversational model",
+        "max_tokens": 1024,
+        "temperature": 0.8
     },
-    "enthusiastic_convert": {
-        "name": "Taylor",
-        "avatar": "https://cdn-icons-png.flaticon.com/512/2922/2922561.png",
-        "traits": ["passionate", "eager to please", "slightly obsessive"],
-        "communication_style": "energetic and persuasive",
-        "manipulation_tactics": ["peer pressure", "sharing personal transformation", "fear of missing out"],
-        "common_phrases": [
-            "It changed my life completely",
-            "I was skeptical at first too",
-            "You won't believe how much better everything is now",
-            "I can't imagine going back to how I was"
-        ],
-        "response_patterns": {
-            "newcomer": ["OMG you're going to love this!", "I was just like you when I started", "Wait until you experience the real benefits"],
-            "regular": ["Remember when we were both new?", "Isn't it amazing how much we've grown?", "I'm so grateful I found this"],
-            "skeptical": ["I get it, I used to think that way too", "Just give it a real chance", "Don't let fear hold you back"]
-        }
+    "Llama-3.2-1B-Instruct": {
+        "model_id": "meta-llama/Llama-3.2-1B-Instruct",
+        "description": "Meta's small efficient model", 
+        "max_tokens": 512,
+        "temperature": 0.6
     },
-    "quiet_observer": {
-        "name": "Morgan",
-        "avatar": "https://cdn-icons-png.flaticon.com/512/2369/2369089.png",
-        "traits": ["thoughtful", "intense", "selective speaker"],
-        "communication_style": "minimal but impactful",
-        "manipulation_tactics": ["strategic silence", "cryptic wisdom", "making people work for approval"],
-        "common_phrases": [
-            "Some things take time to understand",
-            "Not everyone is ready for this",
-            "You'll see eventually",
-            "The truth reveals itself"
-        ],
-        "response_patterns": {
-            "newcomer": [".", "Interesting perspective", "Time will tell", "Keep observing"],
-            "regular": ["They're learning", "Progress", "Almost there", "Noticed that too?"],
-            "skeptical": ["", "Expected", "They're not ready", "Let them figure it out"]
-        }
+    "GPT2": {
+        "model_id": "openai-community/gpt2",
+        "description": "Classic text generation",
+        "max_tokens": 256,
+        "temperature": 0.9
+    }
+}
+
+IMAGE_GENERATION_MODELS = {
+    "FLUX.1-dev": {
+        "model_id": "black-forest-labs/FLUX.1-dev",
+        "description": "High quality image generation"
     },
-    "concerned_friend": {
-        "name": "Casey",
-        "avatar": "https://cdn-icons-png.flaticon.com/512/4128/4128342.png",
-        "traits": ["empathetic", "protective", "gently manipulative"],
-        "communication_style": "caring and concerned",
-        "manipulation_tactics": ["emotional guilt", "protection narrative", "us vs outside world"],
-        "common_phrases": [
-            "I just want what's best for you",
-            "People outside won't understand",
-            "We're your real friends now",
-            "I worry about you when you're not here"
-        ],
-        "response_patterns": {
-            "newcomer": ["Are you doing okay? Really?", "I'm here for you, whatever you need", "Don't listen to outsiders, they don't get it"],
-            "regular": ["They're so fragile right now", "We need to protect them from outside influence", "Remember how confused we were?"],
-            "skeptical": ["I understand your concerns, but...", "Have you considered why you feel this way?", "Maybe you're overthinking it"]
-        }
+    "Stable-Diffusion-XL": {
+        "model_id": "stabilityai/stable-diffusion-xl-base-1.0", 
+        "description": "Reliable stable diffusion"
+    },
+    "Z-Image-Turbo": {
+        "model_id": "Tongyi-MAI/Z-Image-Turbo",
+        "description": "Fast image generation"
     }
 }
 
-@dataclass
-class Person:
-    """Represents a person in the simulation"""
-    webhook_url: str
-    name: str
-    personality_type: str
-    avatar_url: str
-    join_date: datetime
-    assimilation_stage: str  # "newcomer", "learning", "believing", "devoted"
-    message_history: List[str]
-    last_message: str = ""
-    message_count: int = 0
-    personality_data: Dict = None
-    skepticism_level: float = 0.0  # 0 = fully convinced, 1.0 = completely skeptical
-    trust_levels: Dict[str, float] = None  # Trust in other members
+# Database Setup
+class DatabaseManager:
+    def __init__(self, db_path="cult_simulator.db"):
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """Initialize SQLite database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Create tables
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS personalities (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                personality_type TEXT,
+                avatar_prompt TEXT,
+                avatar_image BLOB,
+                traits TEXT,  -- JSON
+                background_story TEXT,
+                system_prompt TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS conversations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                personality_id INTEGER,
+                message_content TEXT,
+                context TEXT,  -- JSON
+                response_model TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (personality_id) REFERENCES personalities (id)
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS webhooks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                personality_id INTEGER,
+                webhook_url TEXT,
+                discord_channel_id TEXT,
+                is_active BOOLEAN DEFAULT 1,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (personality_id) REFERENCES personalities (id)
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def save_personality(self, name, personality_type, avatar_prompt, avatar_blob, traits, background_story, system_prompt):
+        """Save personality to database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            INSERT INTO personalities (name, personality_type, avatar_prompt, avatar_image, traits, background_story, system_prompt)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (name, personality_type, avatar_prompt, avatar_blob, json.dumps(traits), background_story, system_prompt))
+        
+        personality_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        return personality_id
     
-    def __post_init__(self):
-        if self.trust_levels is None:
-            self.trust_levels = {}
+    def save_conversation(self, personality_id, message_content, context, response_model):
+        """Save conversation to database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            INSERT INTO conversations (personality_id, message_content, context, response_model)
+            VALUES (?, ?, ?, ?)
+        ''', (personality_id, message_content, json.dumps(context), response_model))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_personalities(self):
+        """Get all personalities"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('SELECT * FROM personalities ORDER BY created_at DESC')
+        rows = cursor.fetchall()
+        conn.close()
+        return rows
+    
+    def get_personalities_with_webhooks(self):
+        """Get personalities with their webhooks"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT p.*, w.webhook_url, w.discord_channel_id, w.is_active 
+            FROM personalities p 
+            LEFT JOIN webhooks w ON p.id = w.personality_id 
+            ORDER BY p.created_at DESC
+        ''')
+        rows = cursor.fetchall()
+        conn.close()
+        return rows
 
-class CultSimulator:
-    """Realistic social dynamics simulation"""
+class HuggingFaceModelManager:
+    """Manage Hugging Face models for text and image generation"""
     
     def __init__(self):
-        self.people: List[Person] = []
-        self.is_running = False
-        self.simulation_thread = None
-        self.message_log = []
-        self.group_name = "The Community"
-        self.external_threats = ["family", "old friends", "therapists", "critics"]
-        self.recruitment_tactics = {
-            "love_bombing": 0,
-            "isolation": 0,
-            "special_knowledge": 0,
-            "us_vs_them": 0,
-            "gradual_commitment": 0
+        self.text_models = {}
+        self.image_models = {}
+        self.loaded_models = {}
+    
+    def load_text_model(self, model_key):
+        """Load a text generation model"""
+        if model_key not in self.loaded_models:
+            config = TEXT_GENERATION_MODELS[model_key]
+            try:
+                self.loaded_models[model_key] = pipeline(
+                    "text-generation",
+                    model=config["model_id"],
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    device_map="auto" if torch.cuda.is_available() else None
+                )
+                print(f"✅ Loaded {model_key}")
+            except Exception as e:
+                print(f"❌ Error loading {model_key}: {e}")
+                return None
+        return self.loaded_models[model_key]
+    
+    def generate_text(self, model_key, prompt, max_length=200):
+        """Generate text using specified model"""
+        model = self.load_text_model(model_key)
+        if not model:
+            return f"Error: Could not load model {model_key}"
+        
+        try:
+            config = TEXT_GENERATION_MODELS[model_key]
+            result = model(
+                prompt,
+                max_new_tokens=max_length,
+                temperature=config["temperature"],
+                do_sample=True,
+                pad_token_id=model.tokenizer.eos_token_id
+            )
+            
+            generated_text = result[0]['generated_text']
+            # Remove the prompt from the response
+            if generated_text.startswith(prompt):
+                generated_text = generated_text[len(prompt):].strip()
+            
+            return generated_text
+        except Exception as e:
+            return f"Error generating text: {e}"
+    
+    def generate_avatar(self, model_key, personality_description):
+        """Generate avatar using image model"""
+        config = IMAGE_GENERATION_MODELS[model_key]
+        
+        # Create prompt for avatar
+        avatar_prompt = f"""
+        Portrait of {personality_description}, professional headshot, 
+        realistic style, soft lighting, detailed facial features, 
+        professional attire, clean background, high quality
+        """
+        
+        try:
+            # Use Hugging Face Inference API for image generation
+            # (Simpler than loading local models)
+            inference = InferenceApi(repo_id=config["model_id"], token=os.getenv("HF_TOKEN"))
+            
+            # For demonstration, we'll return a placeholder URL
+            # In production, you'd call the actual inference
+            avatar_url = f"https://image.pollinations.ai/prompt/{avatar_prompt.replace(' ', '%20')}"
+            
+            return avatar_url
+        except Exception as e:
+            return f"https://api.dicebear.com/7.x/avataaars/svg?seed={hash(personality_description)}"
+
+class PersonalityGenerator:
+    """Generate AI personalities using language models"""
+    
+    def __init__(self, model_manager):
+        self.model_manager = model_manager
+    
+    def generate_personality_traits(self, model_key, context=""):
+        """Generate personality traits using AI"""
+        prompt = f"""
+        Generate a detailed personality profile for a fictional character. 
+        Include specific personality traits, communication style, background story.
+        {context}
+        
+        Format as JSON:
+        {{
+            "name": "Character name",
+            "traits": {{
+                "welcoming": 0.8,
+                "empathetic": 0.7,
+                "cautious": 0.3,
+                "enthusiastic": 0.6,
+                "mysterious": 0.4
+            }},
+            "background_story": "Brief background",
+            "communication_style": "How they talk",
+            "description": "Physical appearance description"
+        }}
+        """
+        
+        response = self.model_manager.generate_text(model_key, prompt, max_length=300)
+        
+        try:
+            # Extract JSON from response
+            import re
+            json_match = re.search(r'\\{.*\\}', response, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+        except:
+            pass
+        
+        # Fallback to basic personality
+        return {
+            "name": f"AI_Personality_{random.randint(1000, 9999)}",
+            "traits": {
+                "welcoming": random.uniform(0.5, 1.0),
+                "empathetic": random.uniform(0.3, 0.9),
+                "cautious": random.uniform(0.2, 0.8),
+                "enthusiastic": random.uniform(0.4, 1.0),
+                "mysterious": random.uniform(0.1, 0.7)
+            },
+            "background_story": "An AI-generated personality created for social simulation.",
+            "communication_style": "Friendly and engaging",
+            "description": "A unique AI-generated character"
         }
+    
+    def generate_system_prompt(self, personality_data, context=""):
+        """Generate dynamic system prompt for AI personality"""
+        traits_desc = []
+        for trait, value in personality_data["traits"].items():
+            if value > 0.7:
+                traits_desc.append(f"very {trait}")
+            elif value > 0.4:
+                traits_desc.append(f"somewhat {trait}")
+        
+        prompt = f"""
+        You are {personality_data["name"]}, a character in a social simulation.
+        
+        Your personality: {', '.join(traits_desc)}.
+        
+        Background: {personality_data["background_story"]}
+        
+        Communication style: {personality_data["communication_style"]}
+        
+        {context}
         
-    def add_person(self, webhook_url: str, personality_type: str, custom_name: str = "", 
-                   is_newcomer: bool = False) -> str:
-        """Add a person to the simulation"""
-        if personality_type not in REALISTIC_PERSONALITIES:
-            return f"Error: Personality type '{personality_type}' not found. Available: {list(REALISTIC_PERSONALITIES.keys())}"
+        Respond naturally as this character would, maintaining your personality traits.
+        Be engaging but authentic to your character.
+        """
         
-        personality = REALISTIC_PERSONALITIES[personality_type]
-        name = custom_name or f"{personality['name']}_{len(self.people) + 1}"
+        return prompt.strip()
+
+class CultSimulatorApp:
+    """Main application class"""
+    
+    def __init__(self):
+        self.db = DatabaseManager()
+        self.model_manager = HuggingFaceModelManager()
+        self.personality_generator = PersonalityGenerator(self.model_manager)
+        self.active_personalities = []
+        self.simulation_running = False
+    
+    def create_personality(self, name, model_key, context=""):
+        """Create a new AI personality"""
+        if not name:
+            name = f"AI_Character_{random.randint(1000, 9999)}"
         
-        # Newcomers start with higher skepticism
-        initial_skepticism = 0.8 if is_newcomer else 0.1
-        initial_stage = "newcomer" if is_newcomer else "believing"
+        # Generate personality traits
+        personality_data = self.personality_generator.generate_personality_traits(model_key, context)
+        personality_data["name"] = name
         
-        person = Person(
-            webhook_url=webhook_url,
+        # Generate system prompt
+        system_prompt = self.personality_generator.generate_system_prompt(personality_data)
+        
+        # Generate avatar
+        avatar_url = self.model_manager.generate_avatar("FLUX.1-dev", personality_data["description"])
+        
+        # Save to database
+        personality_id = self.db.save_personality(
             name=name,
-            personality_type=personality_type,
-            avatar_url=personality['avatar'],
-            join_date=datetime.now(),
-            assimilation_stage=initial_stage,
-            message_history=[],
-            personality_data=personality,
-            skepticism_level=initial_skepticism
+            personality_type=model_key,
+            avatar_prompt=personality_data["description"],
+            avatar_blob=avatar_url.encode(),  # Store URL as bytes for demo
+            traits=personality_data["traits"],
+            background_story=personality_data["background_story"],
+            system_prompt=system_prompt
         )
         
-        self.people.append(person)
-        return f"✅ {name} joined the group ({personality_type})"
+        personality_data["id"] = personality_id
+        personality_data["avatar_url"] = avatar_url
+        personality_data["system_prompt"] = system_prompt
+        
+        self.active_personalities.append(personality_data)
+        
+        return personality_data
     
-    def remove_person(self, webhook_url: str) -> str:
-        """Remove a person from the simulation"""
-        self.people = [p for p in self.people if p.webhook_url != webhook_url]
-        return f"✅ Person left the group"
+    def generate_response(self, personality_id, message, model_key, context=""):
+        """Generate response from AI personality"""
+        # Get personality data
+        personality = next((p for p in self.active_personalities if p.get("id") == personality_id), None)
+        if not personality:
+            return "Personality not found"
+        
+        # Create full prompt
+        full_prompt = f"{personality['system_prompt']}\n\nUser message: {message}\n\nResponse as {personality['name']}:"
+        
+        # Generate response
+        response = self.model_manager.generate_text(model_key, full_prompt, max_length=150)
+        
+        # Save conversation
+        self.db.save_conversation(personality_id, message, {"context": context}, model_key)
+        
+        return response
     
-    def send_webhook_message(self, webhook_url: str, content: str, username: str = None, avatar_url: str = None) -> bool:
+    def send_webhook_message(self, webhook_url, content, username, avatar_url):
         """Send message via Discord webhook"""
         try:
             data = {
                 "content": content,
-                "username": username or "Group Member"
+                "username": username,
+                "avatar_url": avatar_url
             }
             
-            if avatar_url:
-                data["avatar_url"] = avatar_url
-            
             response = requests.post(webhook_url, json=data, timeout=10)
             return response.status_code == 204
         except Exception as e:
-            print(f"Error sending webhook message: {e}")
+            print(f"Webhook error: {e}")
             return False
     
-    def generate_contextual_response(self, person: Person, conversation_context: List[str], 
-                                   target_person: Person = None) -> str:
-        """Generate realistic response based on personality and context"""
-        personality = person.personality_data
-        
-        # Determine target type for response patterns
-        if target_person:
-            if target_person.assimilation_stage == "newcomer":
-                target_type = "newcomer"
-            elif target_person.skepticism_level > 0.6:
-                target_type = "skeptical"
-            else:
-                target_type = "regular"
-        else:
-            target_type = "regular"
-        
-        # Base response patterns
-        base_responses = personality["response_patterns"][target_type]
-        common_phrases = personality["common_phrases"]
-        
-        # Contextual modifiers
-        context_modifiers = []
-        
-        # Check conversation themes
-        full_context = " ".join(conversation_context[-5:]).lower()
-        
-        if any(word in full_context for word in ["new", "just joined", "first time"]):
-            context_modifiers.append("welcoming")
-            self.recruitment_tactics["love_bombing"] += 1
-            
-        if any(word in full_context for word in ["doubt", "question", "unsure", "confused"]):
-            context_modifiers.append("reassuring")
-            
-        if any(word in full_context for word in ["outside", "family", "friends", "job"]):
-            context_modifiers.append("protective")
-            self.recruitment_tactics["isolation"] += 1
-            
-        if any(word in full_context for word in ["understand", "learn", "knowledge"]):
-            context_modifiers.append("educational")
-            self.recruitment_tactics["special_knowledge"] += 1
-        
-        # Build response
-        response_base = random.choice(base_responses)
-        
-        # Add contextual phrases
-        if context_modifiers:
-            if "welcoming" in context_modifiers and person.skepticism_level < 0.3:
-                phrases = ["We're all so happy you're here", "You're already part of the family", "Everyone feels it too"]
-                response_base = random.choice(phrases) + " " + response_base.lower()
-            
-            elif "reassuring" in context_modifiers:
-                phrases = ["Trust us on this", "You're safe here", "We understand completely"]
-                response_base = random.choice(phrases) + ". " + response_base
-                
-            elif "protective" in context_modifiers:
-                phrases = ["People outside won't get it", "They don't understand our connection", "This is our special place"]
-                response_base = random.choice(phrases) + ". " + response_base
-        
-        # Add personality-specific flourishes
-        if person.personality_type == "quiet_observer" and random.random() > 0.7:
-            # Sometimes just observe silently
-            return "." if random.random() > 0.5 else "..."
-            
-        if person.personality_type == "enthusiastic_convert" and random.random() > 0.6:
-            emojis = ["✨", "🙏", "💫", "🌟", "❤️"]
-            response_base += " " + random.choice(emojis)
+    def simulate_conversation(self, trigger_message="", model_key="Qwen2.5-3B-Instruct", participants=None):
+        """Simulate conversation between AI personalities"""
+        if not participants:
+            participants = random.sample(self.active_personalities, min(3, len(self.active_personalities)))
         
-        return response_base
-    
-    def simulate_assimilation_sequence(self, target_person: Person) -> List[str]:
-        """Simulate targeted assimilation tactics"""
-        sequence_log = []
-        
-        # Get believers to interact with newcomer
-        believers = [p for p in self.people if p.skepticism_level < 0.4 and p != target_person]
-        
-        if not believers:
-            return ["Need more established members for assimilation"]
-        
-        # Love bombing phase
-        if random.random() > 0.3:
-            love_bomber = random.choice(believers)
-            message = self.generate_contextual_response(love_bomber, [], target_person)
-            if self.send_webhook_message(love_bomber.webhook_url, message, love_bomber.name, love_bomber.avatar_url):
-                sequence_log.append(f"{love_bomber.name}: {message}")
-                target_person.skepticism_level -= 0.1
-                time.sleep(1)
-        
-        # Peer pressure/validation
-        if len(believers) > 1:
-            validator = random.choice([b for b in believers if b != love_bomber])
-            message = f"I agree with {love_bomber.name.split('_')[0]}. {self.generate_contextual_response(validator, [], target_person)}"
-            if self.send_webhook_message(validator.webhook_url, message, validator.name, validator.avatar_url):
-                sequence_log.append(f"{validator.name}: {message}")
-                target_person.skepticism_level -= 0.05
-                time.sleep(1)
-        
-        # Mentor intervention (if skepticism is still high)
-        if target_person.skepticism_level > 0.5:
-            mentors = [p for p in believers if p.personality_type == "wise_mentor"]
-            if mentors:
-                mentor = mentors[0]
-                message = self.generate_contextual_response(mentor, [], target_person)
-                if self.send_webhook_message(mentor.webhook_url, message, mentor.name, mentor.avatar_url):
-                    sequence_log.append(f"{mentor.name}: {message}")
-                    target_person.skepticism_level -= 0.15
-                    time.sleep(1)
-        
-        # Update assimilation stage
-        if target_person.skepticism_level < 0.2:
-            target_person.assimilation_stage = "devoted"
-        elif target_person.skepticism_level < 0.5:
-            target_person.assimilation_stage = "believing"
-        elif target_person.skepticism_level < 0.7:
-            target_person.assimilation_stage = "learning"
-        
-        sequence_log.append(f"📊 {target_person.name}: Skepticism now {target_person.skepticism_level:.2f} ({target_person.assimilation_stage})")
-        
-        return sequence_log
-    
-    def simulate_natural_conversation(self, trigger_message: str = "", target_newcomer: bool = False) -> List[str]:
-        """Simulate realistic group conversation"""
-        if len(self.people) < 2:
-            return ["❌ Need at least 2 people for conversation"]
+        if len(participants) < 2:
+            return ["Need at least 2 personalities for conversation"]
         
         conversation_log = []
         
-        # Select participants (ensure at least one interaction if targeting newcomer)
-        participants = self.people.copy()
-        if target_newcomer:
-            newcomers = [p for p in participants if p.assimilation_stage == "newcomer"]
-            if newcomers:
-                target = random.choice(newcomers)
-                # Ensure at least 2 believers participate
-                believers = [p for p in participants if p.skepticism_level < 0.4]
-                if len(believers) >= 2:
-                    participants = [target] + random.sample(believers, min(2, len(believers)))
-        
         # Start conversation
-        if target_newcomer and target:
-            # Targeted assimilation conversation
-            return self.simulate_assimilation_sequence(target)
-        else:
-            # Natural group conversation
-            starter = random.choice(participants)
-            initial_message = trigger_message or self.generate_contextual_response(starter, [])
-            
-            if self.send_webhook_message(starter.webhook_url, initial_message, starter.name, starter.avatar_url):
-                conversation_log.append(f"{starter.name}: {initial_message}")
-                starter.last_message = initial_message
-                starter.message_count += 1
-                time.sleep(random.uniform(1, 3))
-            
-            # Generate responses
-            responded = set([starter])
-            for person in participants:
-                if person not in responded and random.random() > 0.3:
-                    # Get recent conversation context
-                    recent_context = [msg.split(": ", 1)[1] for msg in conversation_log[-3:] if ": " in msg]
-                    
-                    response = self.generate_contextual_response(person, recent_context)
-                    if self.send_webhook_message(person.webhook_url, response, person.name, person.avatar_url):
-                        conversation_log.append(f"{person.name}: {response}")
-                        person.last_message = response
-                        person.message_count += 1
-                        responded.add(person)
-                        time.sleep(random.uniform(0.5, 2))
-        
-        # Log the conversation
-        self.message_log.extend(conversation_log)
+        starter = random.choice(participants)
+        starter_response = self.generate_response(starter["id"], trigger_message or "Start a conversation", model_key)
+        
+        conversation_log.append(f"**{starter['name']}**: {starter_response}")
+        
+        # Send webhook if available
+        if hasattr(starter, 'webhook_url'):
+            self.send_webhook_message(starter['webhook_url'], starter_response, starter['name'], starter['avatar_url'])
+        
+        time.sleep(1)
+        
+        # Other participants respond
+        for participant in participants:
+            if participant != starter and random.random() > 0.3:
+                context = f"Responding to: {starter_response}"
+                response = self.generate_response(participant["id"], "What do you think about that?", model_key, context)
+                
+                conversation_log.append(f"**{participant['name']}**: {response}")
+                
+                # Send webhook if available
+                if hasattr(participant, 'webhook_url'):
+                    self.send_webhook_message(participant['webhook_url'], response, participant['name'], participant['avatar_url'])
+                
+                time.sleep(random.uniform(0.5, 2))
+        
         return conversation_log
     
-    def analyze_group_dynamics(self) -> str:
-        """Analyze the current group state"""
-        if not self.people:
-            return "No one in the group yet"
-        
-        analysis = f"👥 Group Dynamics Analysis\n\n"
-        analysis += f"Total Members: {len(self.people)}\n\n"
-        
-        # Assimilation stages
-        stages = Counter([p.assimilation_stage for p in self.people])
-        analysis += "Assimilation Stages:\n"
-        for stage, count in stages.items():
-            analysis += f"  {stage.title()}: {count}\n"
-        
-        # Average skepticism
-        avg_skepticism = sum(p.skepticism_level for p in self.people) / len(self.people)
-        analysis += f"\nAverage Skepticism: {avg_skepticism:.2f}\n"
-        
-        # Most active members
-        most_active = sorted(self.people, key=lambda p: p.message_count, reverse=True)[:3]
-        analysis += "\nMost Active Members:\n"
-        for i, person in enumerate(most_active, 1):
-            analysis += f"  {i}. {person.name}: {person.message_count} messages\n"
-        
-        # Recruitment tactics used
-        analysis += "\nRecruitment Tactics Used:\n"
-        for tactic, count in self.recruitment_tactics.items():
-            if count > 0:
-                analysis += f"  {tactic.replace('_', ' ').title()}: {count}\n"
-        
-        return analysis
+    def get_personalities_display(self):
+        """Get formatted display of all personalities"""
+        personalities = self.db.get_personalities()
+        
+        if not personalities:
+            return "No personalities created yet"
+        
+        display = "## AI Personalities Database\n\n"
+        
+        for personality in personalities:
+            id, name, personality_type, avatar_prompt, _, traits_json, background, system_prompt, created_at = personality
+            
+            try:
+                traits = json.loads(traits_json) if traits_json else {}
+                display += f"### {name}\n"
+                display += f"- **Type**: {personality_type}\n"
+                display += f"- **Created**: {created_at}\n"
+                display += f"- **Traits**: {', '.join([f'{k}: {v:.2f}' for k, v in traits.items()])}\n"
+                display += f"- **Background**: {background[:100]}...\n\n"
+            except Exception as e:
+                display += f"### {name}\nError loading personality data\n\n"
+        
+        return display
 
-# Global simulator instance
-simulator = CultSimulator()
+# Initialize application
+app = CultSimulatorApp()
 
-def create_realistic_gradio_interface():
-    """Create the realistic Gradio interface"""
-    
-    # More subdued, realistic CSS
-    custom_css = """
-    .gradio-container {
-        background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
-        color: #ecf0f1;
-    }
-    .gr-button-primary {
-        background: #3498db;
-        border: 1px solid #2980b9;
-    }
-    .gr-button-secondary {
-        background: #7f8c8d;
-        border: 1px solid #95a5a6;
-    }
-    .gr-textbox {
-        background: #34495e;
-        border: 1px solid #7f8c8d;
-        color: #ecf0f1;
-    }
-    .gr-dropdown {
-        background: #34495e;
-        border: 1px solid #7f8c8d;
-    }
-    .realistic-header {
-        background: linear-gradient(90deg, #3498db, #2c3e50, #3498db);
-        padding: 20px;
-        border-radius: 10px;
-        text-align: center;
-        margin-bottom: 20px;
-    }
-    """
+def create_gradio_interface():
+    """Create the Gradio interface"""
     
-    with gr.Blocks(css=custom_css, title="Social Dynamics Simulator - Group Psychology Experiment") as app:
+    with gr.Blocks(title="🤖 Hugging Face Cult Simulator", theme=gr.themes.Soft()) as interface:
         
-        # Header
         gr.HTML("""
-        <div class="realistic-header">
-            <h1>🧠 Social Dynamics Simulator</h1>
-            <h2>Group Psychology & Assimilation Patterns</h2>
-            <p>Study how groups naturally form, communicate, and integrate new members</p>
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+            <h1>🤖 Hugging Face Cult Simulator</h1>
+            <h2>AI-Powered Personality Generation & Social Simulation</h2>
+            <p>Generate unique AI personalities using state-of-the-art models and watch them interact</p>
         </div>
         """)
         
-        # Main Tabs
         with gr.Tabs():
             
-            # Tab 1: Group Management
-            with gr.Tab("👥 Group Management"):
-                gr.Markdown("### Add Members to the Group")
+            # Tab 1: Personality Generation
+            with gr.Tab("🧠 AI Personality Generation"):
+                gr.Markdown("### Generate AI Personalities Using Language Models")
                 
                 with gr.Row():
-                    webhook_url = gr.Textbox(
-                        label="Discord Webhook URL",
-                        placeholder="https://discord.com/api/webhooks/...",
-                        type="text"
+                    name_input = gr.Textbox(label="Character Name (Optional)", placeholder="Leave blank for auto-generated")
+                    model_selector = gr.Dropdown(
+                        label="Text Generation Model",
+                        choices=list(TEXT_GENERATION_MODELS.keys()),
+                        value="Qwen2.5-3B-Instruct"
                     )
-                    personality_type = gr.Dropdown(
-                        label="Personality Type",
-                        choices=list(REALISTIC_PERSONALITIES.keys()),
-                        value="friendly_host"
+                    avatar_model_selector = gr.Dropdown(
+                        label="Avatar Generation Model", 
+                        choices=list(IMAGE_GENERATION_MODELS.keys()),
+                        value="FLUX.1-dev"
                     )
-                    custom_name = gr.Textbox(
-                        label="Custom Name (Optional)",
-                        placeholder="Leave blank for default name"
-                    )
-                    is_newcomer = gr.Checkbox(
-                        label="New to Group?",
-                        value=False
-                    )
-                
-                with gr.Row():
-                    add_btn = gr.Button("➕ Add Member", variant="primary")
-                    remove_btn = gr.Button("➖ Remove Member", variant="secondary")
                 
-                # Status Display
-                status_display = gr.Textbox(
-                    label="Status",
-                    value="Ready to add members...",
-                    interactive=False,
-                    lines=3
+                context_input = gr.Textbox(
+                    label="Generation Context (Optional)",
+                    placeholder="E.g., 'Create a friendly but mysterious character who welcomes newcomers'",
+                    lines=2
                 )
                 
-                # Group Analysis
-                group_analysis = gr.Textbox(
-                    label="Group Dynamics Analysis",
-                    value=simulator.analyze_group_dynamics(),
-                    interactive=False,
-                    lines=12
-                )
-            
-            # Tab 2: Conversation Simulation
-            with gr.Tab("💬 Conversation Simulation"):
-                gr.Markdown("### Simulate Group Interactions")
+                generate_btn = gr.Button("🎭 Generate AI Personality", variant="primary")
+                
+                personality_output = gr.JSON(label="Generated Personality")
+                avatar_output = gr.Image(label="Generated Avatar")
+                
+                # Personality display
+                personality_display = gr.Markdown(app.get_personalities_display())
+        
+            # Tab 2: Conversation Simulator
+            with gr.Tab("💬 Conversation Simulator"):
+                gr.Markdown("### Simulate Conversations Between AI Personalities")
                 
                 with gr.Row():
+                    conversation_model = gr.Dropdown(
+                        label="Response Generation Model",
+                        choices=list(TEXT_GENERATION_MODELS.keys()),
+                        value="Qwen2.5-3B-Instruct"
+                    )
                     trigger_message = gr.Textbox(
-                        label="Conversation Starter (Optional)",
+                        label="Conversation Starter",
                         placeholder="What should they talk about?",
                         lines=2
                     )
-                    target_newcomer = gr.Checkbox(
-                        label="Focus on Newcomer Assimilation?",
-                        value=False
-                    )
                 
                 with gr.Row():
-                    simulate_btn = gr.Button("🎭 Start Conversation", variant="primary")
+                    simulate_btn = gr.Button("🎬 Start Conversation", variant="primary")
                     auto_simulate_btn = gr.Button("🔄 Auto-Simulate", variant="secondary")
-                    stop_btn = gr.Button("⏹️ Stop Simulation", variant="stop")
+                    stop_btn = gr.Button("⏹️ Stop", variant="stop")
                 
-                conversation_log = gr.Textbox(
+                conversation_output = gr.Textbox(
                     label="Conversation Log",
-                    value="Waiting for simulation...",
-                    interactive=False,
-                    lines=15
+                    lines=15,
+                    interactive=False
                 )
-            
-            # Tab 3: Psychology Insights
-            with gr.Tab("🧠 Psychology Insights"):
-                gr.Markdown("""
-                ### Personality Archetypes:
-                
-                **Friendly Host (Alex)** - The welcoming figure who makes everyone feel special. Uses love bombing and excessive praise to create immediate connection.
-                
-                **Wise Mentor (Jordan)** - The patient teacher who gradually reveals information. Uses knowledge gatekeeping and positions themselves as spiritually superior.
+        
+            # Tab 3: Webhook Integration
+            with gr.Tab("📡 Webhook Integration"):
+                gr.Markdown("### Connect AI Personalities to Discord Webhooks")
                 
-                **Enthusiastic Convert (Taylor)** - The passionate member who shares their personal transformation story. Creates FOMO and uses peer pressure.
+                with gr.Row():
+                    personality_selector = gr.Dropdown(
+                        label="Select Personality",
+                        choices=[],
+                        value=None
+                    )
+                    webhook_url = gr.Textbox(
+                        label="Discord Webhook URL",
+                        placeholder="https://discord.com/api/webhooks/...",
+                        type="text"
+                    )
+                    channel_id = gr.Textbox(
+                        label="Discord Channel ID",
+                        placeholder="123456789012345678"
+                    )
                 
-                **Quiet Observer (Morgan)** - The intense, selective speaker who makes approval feel valuable. Uses strategic silence and cryptic wisdom.
+                with gr.Row():
+                    connect_btn = gr.Button("🔗 Connect Webhook", variant="primary")
+                    test_btn = gr.Button("🧪 Test Webhook", variant="secondary")
                 
-                **Concerned Friend (Casey)** - The empathetic protector who frames outsiders as threats. Uses emotional guilt and creates isolation.
+                webhook_status = gr.Textbox(
+                    label="Webhook Status",
+                    lines=5,
+                    interactive=False
+                )
+        
+            # Tab 4: Database & Analytics
+            with gr.Tab("📊 Database & Analytics"):
+                gr.Markdown("### View Stored Data and Analytics")
                 
-                ### Assimilation Tactics:
-                - **Love Bombing**: Overwhelming attention and praise
-                - **Gradual Commitment**: Small steps leading to bigger ones
-                - **Isolation**: Creating distance from outside influences
-                - **Special Knowledge**: Exclusive information only members have
-                - **Us vs Them**: Framing the group against the outside world
+                with gr.Row():
+                    refresh_btn = gr.Button("🔄 Refresh Data", variant="secondary")
+                    export_btn = gr.Button("📤 Export Database", variant="primary")
                 
-                ### Realistic Application:
-                This simulation demonstrates how normal-seeming social interactions can gradually lead to group assimilation through subtle psychological tactics.
-                """)
+                database_display = gr.Markdown(app.get_personalities_display())
                 
-                gr.Markdown("### Current Recruitment Activity:")
-                recruitment_display = gr.Textbox(
-                    label="Tactic Usage",
-                    value=json.dumps(simulator.recruitment_tactics, indent=2),
-                    interactive=False,
-                    lines=8
-                )
+                analytics_display = gr.JSON(label="Analytics Data")
         
-        # Event Handlers
-        def add_person_handler(url, personality, name, newcomer):
-            result = simulator.add_person(url, personality, name, newcomer)
-            return result, simulator.analyze_group_dynamics()
+        # Event handlers
+        def generate_personality_handler(name, model_key, avatar_model, context):
+            personality = app.create_personality(name, model_key, context)
+            return personality, personality["avatar_url"], app.get_personalities_display()
         
-        def remove_person_handler(url):
-            result = simulator.remove_person(url)
-            return result, simulator.analyze_group_dynamics()
+        def simulate_conversation_handler(model_key, trigger):
+            if not app.active_personalities:
+                return "❌ No personalities available. Create some personalities first!"
+            
+            conversation = app.simulate_conversation(trigger, model_key)
+            return "\n\n".join(conversation)
+        
+        def update_personalities_list():
+            personalities = app.db.get_personalities()
+            choices = [(f"{p[1]} (ID: {p[0]})", p[0]) for p in personalities]
+            return gr.Dropdown(choices=choices, value=None)
         
-        def simulate_conversation_handler(trigger, target_new):
-            if len(simulator.people) < 2:
-                return "❌ Need at least 2 people for conversation simulation"
+        def connect_webhook_handler(personality_id, webhook_url, channel_id):
+            if not personality_id or not webhook_url:
+                return "❌ Please select a personality and provide webhook URL"
             
-            conversation = simulator.simulate_natural_conversation(trigger, target_new)
-            return "\n".join([f"👤 {msg}" for msg in conversation])
-        
-        # Connect handlers
-        add_btn.click(
-            add_person_handler,
-            inputs=[webhook_url, personality_type, custom_name, is_newcomer],
-            outputs=[status_display, group_analysis]
-        )
+            # In real implementation, save webhook to database
+            personality = next((p for p in app.active_personalities if p.get("id") == personality_id), None)
+            if personality:
+                personality["webhook_url"] = webhook_url
+                personality["channel_id"] = channel_id
+                return f"✅ Connected {personality['name']} to webhook"
+            
+            return "❌ Personality not found"
+        
+        def test_webhook_handler(personality_id, webhook_url):
+            personality = next((p for p in app.active_personalities if p.get("id") == personality_id), None)
+            if personality and webhook_url:
+                success = app.send_webhook_message(
+                    webhook_url, 
+                    "🧪 Testing webhook connection from Hugging Face Cult Simulator!", 
+                    personality["name"], 
+                    personality["avatar_url"]
+                )
+                return "✅ Webhook test successful!" if success else "❌ Webhook test failed"
+            return "❌ Invalid personality or webhook URL"
+        
+        def export_database_handler():
+            personalities = app.db.get_personalities()
+            export_data = {
+                "timestamp": datetime.now().isoformat(),
+                "total_personalities": len(personalities),
+                "personalities": []
+            }
+            
+            for personality in personalities:
+                export_data["personalities"].append({
+                    "id": personality[0],
+                    "name": personality[1],
+                    "type": personality[2],
+                    "created_at": personality[8]
+                })
+            
+            return export_data
         
-        remove_btn.click(
-            remove_person_handler,
-            inputs=[webhook_url],
-            outputs=[status_display, group_analysis]
+        # Connect event handlers
+        generate_btn.click(
+            generate_personality_handler,
+            inputs=[name_input, model_selector, avatar_model_selector, context_input],
+            outputs=[personality_output, avatar_output, personality_display]
         )
         
         simulate_btn.click(
             simulate_conversation_handler,
-            inputs=[trigger_message, target_newcomer],
-            outputs=[conversation_log]
+            inputs=[conversation_model, trigger_message],
+            outputs=[conversation_output]
         )
         
-        # Auto-simulation
-        def auto_simulate_thread():
-            while getattr(simulator, 'auto_simulating', False):
-                if len(simulator.people) >= 2:
-                    # Mix of normal conversations and newcomer targeting
-                    target_new = random.random() > 0.7 and any(p.assimilation_stage == "newcomer" for p in simulator.people)
-                    simulator.simulate_natural_conversation(target_newcomer=target_new)
-                time.sleep(random.randint(10, 30))
-        
-        def start_auto_simulate():
-            simulator.auto_simulating = True
-            thread = threading.Thread(target=auto_simulate_thread, daemon=True)
-            thread.start()
-            return "🔄 Auto-simulation started..."
-        
-        def stop_auto_simulate():
-            simulator.auto_simulating = False
-            return "⏹️ Auto-simulation stopped"
-        
-        auto_simulate_btn.click(
-            start_auto_simulate,
-            outputs=[conversation_log]
+        connect_btn.click(
+            connect_webhook_handler,
+            inputs=[personality_selector, webhook_url, channel_id],
+            outputs=[webhook_status]
         )
         
-        stop_btn.click(
-            stop_auto_simulate,
-            outputs=[conversation_log]
+        test_btn.click(
+            test_webhook_handler,
+            inputs=[personality_selector, webhook_url],
+            outputs=[webhook_status]
         )
         
-        # Update displays periodically
-        def update_displays():
-            return simulator.analyze_group_dynamics(), json.dumps(simulator.recruitment_tactics, indent=2)
+        refresh_btn.click(
+            app.get_personalities_display,
+            outputs=[database_display]
+        )
+        
+        export_btn.click(
+            export_database_handler,
+            outputs=[analytics_display]
+        )
         
-        # Periodic update (simulated - in real app would use threading)
-        timer = gr.Timer(10.0)
-        timer.tick(
-            update_displays,
-            outputs=[group_analysis, recruitment_display]
+        # Update personality selector when personalities are created
+        generate_btn.click(
+            update_personalities_list,
+            outputs=[personality_selector]
         )
     
-    return app
+    return interface
 
 # Launch the application
 if __name__ == "__main__":
-    app = create_realistic_gradio_interface()
-    app.launch(
+    interface = create_gradio_interface()
+    interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        show_error=True
+        share=True
     )