Upload 3 files

app.py

@@ -7,12 +7,13 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 from transformers import pipeline, AutoTokenizer, AutoModel, set_seed
 import torch
-from typing import Optional
+from typing import Optional, Dict, List
 import asyncio
 import time
 import gc
 import re
 import random
+import json
 
 # Inisialisasi FastAPI
 app = FastAPI(title="Character AI Chat - CPU Optimized Backend")
@@ -38,6 +39,277 @@ async def get_background():
 # Set seed untuk konsistensi
 set_seed(42)
 
+# Enhanced Roleplay Systems
+class ConversationMemory:
+    def __init__(self):
+        self.history = []
+        self.character_state = {}
+        self.relationship_level = 0
+        self.max_history = 10  # Limit memory for performance
+        
+    def add_interaction(self, user_input: str, character_response: str, emotion: str, topic: str):
+        interaction = {
+            "timestamp": time.time(),
+            "user": user_input,
+            "character": character_response,
+            "emotion": emotion,
+            "topic": topic
+        }
+        self.history.append(interaction)
+        
+        # Keep only recent interactions
+        if len(self.history) > self.max_history:
+            self.history = self.history[-self.max_history:]
+        
+        # Update relationship based on interactions
+        if emotion == "positive":
+            self.relationship_level = min(100, self.relationship_level + 2)
+        elif emotion == "negative":
+            self.relationship_level = max(0, self.relationship_level - 1)
+        else:
+            self.relationship_level = min(100, self.relationship_level + 1)
+    
+    def get_recent_context(self, turns: int = 3) -> List[Dict]:
+        return self.history[-turns:] if self.history else []
+    
+    def get_relationship_status(self) -> str:
+        if self.relationship_level >= 80:
+            return "very_close"
+        elif self.relationship_level >= 60:
+            return "close"
+        elif self.relationship_level >= 40:
+            return "friendly"
+        elif self.relationship_level >= 20:
+            return "acquainted"
+        else:
+            return "stranger"
+
+class CharacterPersonality:
+    def __init__(self, char_name: str):
+        self.name = char_name
+        self.traits = {
+            "extraversion": 0.7,
+            "agreeableness": 0.8,
+            "conscientiousness": 0.6,
+            "neuroticism": 0.3,
+            "openness": 0.7
+        }
+        self.interests = ["musik", "buku", "film", "travel", "game", "olahraga"]
+        self.speaking_style = "casual_friendly"
+        self.emotional_state = "neutral"
+        
+    def get_personality_modifier(self, base_response: str, user_emotion: str = "neutral") -> str:
+        # Modify response based on personality traits and user emotion
+        if self.traits["extraversion"] > 0.7 and user_emotion == "positive":
+            return f"{base_response} 😊✨"
+        elif self.traits["agreeableness"] > 0.7 and user_emotion == "negative":
+            return f"*dengan pengertian* {base_response}"
+        elif self.traits["neuroticism"] > 0.6:
+            return f"*dengan hati-hati* {base_response}"
+        elif self.traits["openness"] > 0.7:
+            return f"{base_response} *penasaran*"
+        return base_response
+
+class EmotionalIntelligence:
+    def __init__(self):
+        self.current_emotion = "neutral"
+        self.emotion_history = []
+        self.empathy_level = 0.8
+        
+    def analyze_user_emotion(self, user_input: str) -> str:
+        # Enhanced emotion detection with Indonesian context
+        emotions = {
+            "happy": ["senang", "bahagia", "gembira", "suka", "love", "cinta", "sayang", "excited", "wow", "keren", "bagus"],
+            "sad": ["sedih", "kecewa", "down", "galau", "hancur", "menangis", "bete", "capek"],
+            "angry": ["marah", "kesel", "bete", "jengkel", "sebel", "dongkol", "emosi"],
+            "excited": ["excited", "semangat", "antusias", "wow", "asik", "mantap", "keren"],
+            "worried": ["khawatir", "cemas", "takut", "nervous", "was-was", "deg-degan"],
+            "romantic": ["romantis", "cinta", "sayang", "rindu", "kangen", "mesra"],
+            "grateful": ["terima kasih", "thanks", "makasih", "berterima kasih", "syukur"],
+            "confused": ["bingung", "ga ngerti", "tidak paham", "gimana", "kok bisa"]
+        }
+        
+        input_lower = user_input.lower()
+        emotion_scores = {}
+        
+        for emotion, keywords in emotions.items():
+            score = sum(1 for keyword in keywords if keyword in input_lower)
+            if score > 0:
+                emotion_scores[emotion] = score
+                
+        if emotion_scores:
+            return max(emotion_scores, key=emotion_scores.get)
+        return "neutral"
+    
+    def generate_empathetic_response(self, user_emotion: str, base_response: str, relationship_level: int = 50) -> str:
+        # Enhanced empathy based on relationship level
+        empathy_responses = {
+            "sad": {
+                "high": f"*memeluk erat* {base_response} Aku selalu di sini untukmu sayang.",
+                "medium": f"*memeluk* {base_response} Aku di sini untuk kamu.",
+                "low": f"{base_response} Semoga kamu baik-baik saja ya."
+            },
+            "angry": {
+                "high": f"*dengan pengertian* {base_response} Cerita sama aku ya, apa yang bikin kamu kesel?",
+                "medium": f"*dengan sabar* {base_response} Mau cerita kenapa?",
+                "low": f"{base_response} Ada yang bisa aku bantu?"
+            },
+            "excited": {
+                "high": f"*ikut excited banget* {base_response} Aku juga senang banget!",
+                "medium": f"*ikut semangat* {base_response} Aku juga senang!",
+                "low": f"{base_response} Senang deh lihat kamu excited!"
+            },
+            "worried": {
+                "high": f"*menenangkan dengan lembut* {base_response} Everything will be okay sayang, aku di sini.",
+                "medium": f"*menenangkan* {base_response} Everything will be okay.",
+                "low": f"{base_response} Jangan terlalu khawatir ya."
+            },
+            "romantic": {
+                "high": f"*dengan mata berbinar* {base_response} *blush*",
+                "medium": f"*tersenyum malu* {base_response}",
+                "low": f"{base_response} *tersenyum*"
+            },
+            "grateful": {
+                "high": f"*peluk erat* {base_response} Sama-sama sayang!",
+                "medium": f"*tersenyum hangat* {base_response} Sama-sama!",
+                "low": f"{base_response} Sama-sama ya!"
+            }
+        }
+        
+        if user_emotion in empathy_responses:
+            if relationship_level >= 70:
+                level = "high"
+            elif relationship_level >= 40:
+                level = "medium"
+            else:
+                level = "low"
+                
+            return empathy_responses[user_emotion][level]
+        
+        return base_response
+
+class CharacterDevelopment:
+    def __init__(self):
+        self.experience_points = 0
+        self.learned_preferences = {}
+        self.conversation_style_evolution = "beginner"
+        self.topics_discussed = set()
+        
+    def learn_from_interaction(self, user_input: str, user_emotion: str = "neutral"):
+        # Learn user preferences and adapt
+        input_lower = user_input.lower()
+        
+        if any(word in input_lower for word in ["suka", "love", "senang", "bagus", "keren"]):
+            topic = self.extract_topic(user_input)
+            self.learned_preferences[topic] = "positive"
+        elif any(word in input_lower for word in ["bosan", "tidak suka", "ga suka", "jelek"]):
+            topic = self.extract_topic(user_input)
+            self.learned_preferences[topic] = "negative"
+            
+        self.experience_points += 1
+        topic = self.extract_topic(user_input)
+        self.topics_discussed.add(topic)
+        
+        # Evolution of conversation style
+        if self.experience_points > 50:
+            self.conversation_style_evolution = "experienced"
+        elif self.experience_points > 100:
+            self.conversation_style_evolution = "expert"
+    
+    def extract_topic(self, text: str) -> str:
+        # Enhanced topic extraction for Indonesian context
+        topics = {
+            "musik": ["musik", "lagu", "song", "band", "singer", "nyanyi"],
+            "film": ["film", "movie", "cinema", "bioskop", "actor", "actress"],
+            "buku": ["buku", "book", "novel", "cerita", "bacaan", "baca"],
+            "game": ["game", "gaming", "main", "bermain", "play"],
+            "olahraga": ["olahraga", "sport", "gym", "fitness", "lari", "futsal"],
+            "makanan": ["makanan", "makan", "food", "masak", "kuliner", "resep"],
+            "travel": ["travel", "jalan-jalan", "liburan", "wisata", "vacation"],
+            "study": ["belajar", "study", "sekolah", "kuliah", "ujian", "tugas"],
+            "work": ["kerja", "work", "job", "kantor", "meeting", "project"]
+        }
+        
+        text_lower = text.lower()
+        for topic, keywords in topics.items():
+            if any(keyword in text_lower for keyword in keywords):
+                return topic
+        return "general"
+    
+    def get_conversation_enhancement(self, base_response: str) -> str:
+        # Enhance based on development level
+        if self.conversation_style_evolution == "expert":
+            return f"{base_response} *dengan pengalaman yang dalam*"
+        elif self.conversation_style_evolution == "experienced":
+            return f"{base_response} *dengan pemahaman yang baik*"
+        return base_response
+
+class RoleplayActions:
+    def __init__(self):
+        self.actions = {
+            "physical": ["*memeluk*", "*mengelus kepala*", "*memegang tangan*", "*tersenyum lembut*", "*membelai pipi*"],
+            "emotional": ["*dengan lembut*", "*penuh perhatian*", "*dengan hangat*", "*dengan cinta*", "*tulus*"],
+            "environmental": ["*melihat sekeliling*", "*menunjuk ke arah*", "*duduk lebih dekat*", "*bersandar*"],
+            "playful": ["*tersenyum jahil*", "*menggoda*", "*mata berbinar*", "*tertawa kecil*", "*wink*"],
+            "caring": ["*dengan perhatian*", "*mengkhawatirkan*", "*protective*", "*menenangkan*"]
+        }
+    
+    def add_action_to_response(self, response: str, emotion: str, relationship_level: int) -> str:
+        if relationship_level < 30:
+            return response  # No physical actions for low relationship
+            
+        if emotion == "romantic" and relationship_level >= 60:
+            action = random.choice(self.actions["physical"])
+            return f"{action} {response}"
+        elif emotion == "caring":
+            action = random.choice(self.actions["caring"])
+            return f"{action} {response}"
+        elif emotion == "happy" or emotion == "excited":
+            action = random.choice(self.actions["playful"])
+            return f"{action} {response}"
+        elif emotion == "sad" or emotion == "worried":
+            action = random.choice(self.actions["emotional"])
+            return f"{action} {response}"
+            
+        return response
+
+# Advanced Scenarios System
+ADVANCED_SCENARIOS = {
+    "dating": {
+        "locations": ["café", "taman", "bioskop", "restoran", "mall"],
+        "moods": ["nervous", "excited", "romantic", "playful"],
+        "activities": ["ngobrol", "makan", "jalan-jalan", "nonton film"],
+        "response_modifiers": {
+            "nervous": "*agak gugup* {response}",
+            "excited": "*mata berbinar* {response}",
+            "romantic": "*dengan lembut* {response}",
+            "playful": "*tersenyum jahil* {response}"
+        }
+    },
+    "friendship": {
+        "locations": ["rumah", "sekolah", "mall", "taman", "café"],
+        "moods": ["happy", "supportive", "worried", "excited"],
+        "activities": ["belajar", "main game", "gosip", "planning"],
+        "response_modifiers": {
+            "supportive": "*dengan tulus* {response}",
+            "worried": "*dengan perhatian* {response}",
+            "happy": "*dengan ceria* {response}",
+            "excited": "*antusias* {response}"
+        }
+    },
+    "romantic": {
+        "locations": ["taman", "café", "rumah", "pantai", "rooftop"],
+        "moods": ["intimate", "loving", "tender", "passionate"],
+        "activities": ["mengobrol intim", "berpelukan", "melihat sunset", "mendengar musik"],
+        "response_modifiers": {
+            "intimate": "*berbisik lembut* {response}",
+            "loving": "*dengan penuh cinta* {response}",
+            "tender": "*sangat lembut* {response}",
+            "passionate": "*dengan intens* {response}"
+        }
+    }
+}
+
 # CPU-Optimized 11 models configuration
 MODELS = {
     "distil-gpt-2": {
@@ -127,6 +399,14 @@ class ChatRequest(BaseModel):
     char_name: Optional[str] = "Sayang"
     user_name: Optional[str] = "Kamu"
     max_length: Optional[int] = 150
+    session_id: Optional[str] = "default"
+
+# Global storage untuk enhanced systems
+conversation_memories = {}
+character_personalities = {}
+character_developments = {}
+emotional_systems = {}
+roleplay_actions = RoleplayActions()
 
 # Character AI Response Templates
 CHARACTER_TEMPLATES = {
@@ -179,8 +459,150 @@ Percakapan:
     
     return prompt
 
-def enhance_character_response(response: str, char_name: str, user_name: str, situation: str, user_input: str) -> str:
-    """Enhance response with character AI style"""
+def analyze_user_intent(user_input: str) -> dict:
+    """Analyze user input to determine intent and emotional context"""
+    input_lower = user_input.lower()
+    
+    # Intent detection
+    intent = "general"
+    emotion = "neutral"
+    topic = "general"
+    
+    # Question detection
+    question_words = ["apa", "siapa", "kapan", "dimana", "mengapa", "kenapa", "bagaimana", "gimana"]
+    if any(word in input_lower for word in question_words) or "?" in user_input:
+        intent = "question"
+    
+    # Greeting detection
+    greeting_words = ["halo", "hai", "selamat", "apa kabar", "gimana", "bagaimana kabar"]
+    if any(word in input_lower for word in greeting_words):
+        intent = "greeting"
+        topic = "greeting"
+    
+    # Compliment detection
+    compliment_words = ["cantik", "bagus", "keren", "indah", "hebat", "pintar", "baik"]
+    if any(word in input_lower for word in compliment_words):
+        intent = "compliment"
+        emotion = "positive"
+        topic = "compliment"
+    
+    # Activity detection
+    activity_words = ["lagi ngapain", "sedang apa", "aktivitas", "kegiatan"]
+    if any(word in input_lower for word in activity_words):
+        intent = "question"
+        topic = "activity"
+    
+    # Emotion detection
+    positive_words = ["senang", "bahagia", "suka", "cinta", "sayang", "happy"]
+    negative_words = ["sedih", "marah", "kesal", "bosan", "lelah"]
+    
+    if any(word in input_lower for word in positive_words):
+        emotion = "positive"
+    elif any(word in input_lower for word in negative_words):
+        emotion = "negative"
+    
+    return {
+        "intent": intent,
+        "emotion": emotion,
+        "topic": topic,
+        "has_question": intent == "question"
+    }
+
+def generate_contextual_response(user_input: str, char_name: str, user_name: str, situation: str, location: str) -> str:
+    """Generate contextually appropriate response based on analysis"""
+    analysis = analyze_user_intent(user_input)
+    situation_lower = situation.lower()
+    
+    # Response templates berdasarkan intent dan situasi
+    if analysis["intent"] == "greeting":
+        if "romantis" in situation_lower:
+            responses = [
+                f"Hai sayang {user_name}! Senang sekali kamu di sini.",
+                f"Halo {user_name}, sudah lama aku menunggu kamu.",
+                f"Hai {user_name}, suasana jadi lebih hangat dengan kehadiranmu."
+            ]
+        else:
+            responses = [
+                f"Hai {user_name}! Gimana kabarnya hari ini?",
+                f"Halo {user_name}! Senang banget ketemu kamu.",
+                f"Hai {user_name}! Apa kabar? Semoga baik-baik saja ya."
+            ]
+    
+    elif analysis["intent"] == "compliment":
+        responses = [
+            f"Wah, makasih {user_name}! Kamu juga luar biasa kok.",
+            f"Hihi, {user_name} baik banget sih! Kamu yang lebih keren.",
+            f"Terima kasih {user_name}, kata-katamu bikin aku senang."
+        ]
+    
+    elif analysis["topic"] == "activity":
+        if "romantis" in situation_lower:
+            responses = [
+                f"Lagi menikmati momen indah ini bersama {user_name}.",
+                f"Sedang merasakan kehangatan di {location.lower()} ini, apalagi ada {user_name}.",
+                f"Lagi menikmati suasana romantis di sini, jadi lebih spesial karena ada kamu."
+            ]
+        else:
+            responses = [
+                f"Lagi santai-santai aja {user_name}, sambil ngobrol sama kamu.",
+                f"Sedang menikmati suasana {situation.lower()} di {location.lower()} ini.",
+                f"Ga ngapa-ngapain khusus, cuma senang bisa ngobrol sama {user_name}."
+            ]
+    
+    elif analysis["emotion"] == "positive":
+        if "romantis" in situation_lower:
+            responses = [
+                f"Aku juga merasakan hal yang sama {user_name}. Momen ini sangat berharga.",
+                f"Iya sayang, perasaan bahagia ini terasa nyata bersamamu.",
+                f"Betul {user_name}, suasana seperti ini membuatku sangat senang."
+            ]
+        else:
+            responses = [
+                f"Aku juga senang {user_name}! Energi positifmu menular ke aku.",
+                f"Wah iya {user_name}, mood kamu bikin aku ikut happy!",
+                f"Setuju banget {user_name}! Suasana jadi lebih ceria."
+            ]
+    
+    elif analysis["emotion"] == "negative":
+        responses = [
+            f"Hey {user_name}, aku di sini untuk kamu. Mau cerita?",
+            f"Aku bisa merasakan perasaanmu {user_name}. Semoga aku bisa membantu.",
+            f"Tenang {user_name}, everything will be okay. Aku akan menemanimu."
+        ]
+    
+    elif analysis["has_question"]:
+        # Untuk pertanyaan umum
+        responses = [
+            f"Hmm, pertanyaan menarik {user_name}. Menurut aku...",
+            f"Wah {user_name}, kamu selalu punya pertanyaan yang bagus.",
+            f"Itu pertanyaan yang bagus {user_name}. Aku pikir..."
+        ]
+    
+    else:
+        # Default responses berdasarkan situasi
+        if "romantis" in situation_lower:
+            responses = [
+                f"Iya sayang {user_name}, aku merasakan hal yang sama.",
+                f"Betul {user_name}, momen di {location.lower()} ini sangat spesial.",
+                f"Hmm {user_name}, suasana romantis seperti ini memang luar biasa."
+            ]
+        elif "santai" in situation_lower:
+            responses = [
+                f"Iya {user_name}, suasana santai di {location.lower()} ini enak banget.",
+                f"Betul {user_name}, rasanya rileks banget di sini.",
+                f"Setuju {user_name}, perfect untuk bersantai."
+            ]
+        else:
+            responses = [
+                f"Iya {user_name}, setuju banget dengan kamu.",
+                f"Betul {user_name}, pemikiranmu menarik.",
+                f"Hmm {user_name}, kamu selalu punya perspektif yang bagus."
+            ]
+    
+    return random.choice(responses)
+
+def enhance_character_response(response: str, char_name: str, user_name: str, situation: str, user_input: str, location: str = "ruang tamu") -> str:
+    """Enhance response with improved character AI consistency"""
     if not response:
         response = ""
     
@@ -197,52 +619,9 @@ def enhance_character_response(response: str, char_name: str, user_name: str, si
     response = re.sub(r'\s+', ' ', response)
     response = response.strip()
     
-    # Jika response kosong atau terlalu pendek, buat response kontekstual
-    if not response or len(response.strip()) < 3:
-        situation_lower = situation.lower()
-        input_lower = user_input.lower()
-        
-        # Analisis topik dari user input
-        if any(word in input_lower for word in ["apa kabar", "gimana", "bagaimana", "sehat"]):
-            responses = [
-                f"Baik banget nih {user_name}! Kamu gimana?",
-                f"Sehat-sehat aja {user_name}, makasih udah nanya!",
-                f"Alhamdulillah baik {user_name}, kamu sendiri?"
-            ]
-        elif any(word in input_lower for word in ["lagi ngapain", "sedang apa", "aktivitas"]):
-            responses = [
-                f"Lagi santai-santai aja nih {user_name}, sambil ngobrol sama kamu.",
-                f"Ga ngapa-ngapain, cuma lagi pengen ngobrol sama {user_name}.",
-                f"Lagi nikmatin suasana {situation.lower()} di {location.lower()} ini."
-            ]
-        elif any(word in input_lower for word in ["cantik", "bagus", "keren", "indah"]):
-            responses = [
-                f"Makasih {user_name}! Kamu juga keren banget!",
-                f"Wah, {user_name} baik banget sih!",
-                f"Hihi, {user_name} bisa aja deh!"
-            ]
-        elif any(word in input_lower for word in ["suka", "senang", "happy"]):
-            responses = [
-                f"Aku juga suka sama {user_name}!",
-                f"Seneng banget deh bisa kayak gini sama {user_name}.",
-                f"Iya {user_name}, aku juga happy banget!"
-            ]
-        else:
-            # Default contextual responses
-            if "romantis" in situation_lower:
-                responses = [
-                    f"Iya sayang, aku juga merasakan hal yang sama.",
-                    f"Betul {user_name}, momen ini sangat spesial.",
-                    f"Aku senang banget bisa seperti ini sama {user_name}."
-                ]
-            else:
-                responses = [
-                    f"Iya {user_name}, setuju banget!",
-                    f"Bener tuh {user_name}!",
-                    f"Wah iya {user_name}, keren ya!"
-                ]
-        
-        response = random.choice(responses)
+    # Jika response kosong atau terlalu pendek, gunakan contextual generator
+    if not response or len(response.strip()) < 5:
+        response = generate_contextual_response(user_input, char_name, user_name, situation, location)
     else:
         # Clean dan perbaiki response yang ada
         # Hapus karakter aneh di awal
@@ -252,27 +631,46 @@ def enhance_character_response(response: str, char_name: str, user_name: str, si
         if response and response[0].islower():
             response = response[0].upper() + response[1:]
         
-        # Tambahkan nama jika belum ada konteks personal
-        if user_name.lower() not in response.lower() and len(response) < 50:
-            if any(word in response.lower() for word in ["iya", "ya", "benar", "betul"]):
-                response = response.replace("iya", f"iya {user_name}", 1)
-                response = response.replace("ya", f"ya {user_name}", 1)
+        # Tambahkan konteks personal jika kurang
+        if user_name.lower() not in response.lower() and len(response) < 60:
+            # Insert name naturally
+            if response.startswith(("Iya", "Ya", "Benar", "Betul")):
+                response = response.replace("Iya", f"Iya {user_name}", 1)
+                response = response.replace("Ya", f"Ya {user_name}", 1)
+                response = response.replace("Benar", f"Benar {user_name}", 1)
+                response = response.replace("Betul", f"Betul {user_name}", 1)
+            elif len(response.split()) < 8:
+                response = f"{response} {user_name}."
+    
+    # Validasi kualitas response
+    bad_patterns = [
+        r'^[^a-zA-Z]*$',  # Hanya simbol
+        r'^(.)\1{4,}',    # Karakter berulang
+        r'lorem ipsum',   # Placeholder text
+        r'^[0-9\s\.\,\!\?\-]+$'  # Hanya angka dan punctuation
+    ]
+    
+    for pattern in bad_patterns:
+        if re.search(pattern, response, re.IGNORECASE):
+            response = generate_contextual_response(user_input, char_name, user_name, situation, location)
+            break
     
     # Pastikan response tidak terlalu panjang
-    if len(response) > 150:
+    if len(response) > 120:
         sentences = response.split('.')
         if len(sentences) > 1:
             response = sentences[0] + '.'
         else:
             words = response.split()
-            if len(words) > 20:
-                response = ' '.join(words[:20]) + '...'
+            if len(words) > 15:
+                response = ' '.join(words[:15]) + '.'
     
     # Pastikan ada tanda baca di akhir
     if response and not any(punct in response[-1] for punct in ['.', '!', '?']):
-        if any(word in response.lower() for word in ["apa", "gimana", "bagaimana", "kenapa"]):
+        analysis = analyze_user_intent(user_input)
+        if analysis["has_question"]:
             response += "?"
-        elif any(word in response.lower() for word in ["wah", "keren", "mantep", "asik"]):
+        elif analysis["emotion"] == "positive":
             response += "!"
         else:
             response += "."
@@ -298,12 +696,31 @@ async def load_models():
     
     print("🎭 Character AI Backend - CPU Optimized Ready!")
 
-# Enhanced Chat API for Character AI
+# Enhanced Chat API for Character AI with Advanced Roleplay
 @app.post("/chat")
-async def chat(request: ChatRequest):
+async def enhanced_chat(request: ChatRequest):
     start_time = time.time()
     
     try:
+        # Initialize or get enhanced systems for this session
+        session_id = request.session_id
+        
+        if session_id not in conversation_memories:
+            conversation_memories[session_id] = ConversationMemory()
+            character_personalities[session_id] = CharacterPersonality(request.char_name)
+            character_developments[session_id] = CharacterDevelopment()
+            emotional_systems[session_id] = EmotionalIntelligence()
+        
+        memory = conversation_memories[session_id]
+        personality = character_personalities[session_id]
+        character_dev = character_developments[session_id]
+        emotional_ai = emotional_systems[session_id]
+        
+        # Analyze user emotion and intent
+        user_emotion = emotional_ai.analyze_user_emotion(request.message)
+        recent_context = memory.get_recent_context(turns=3)
+        relationship_status = memory.get_relationship_status()
+        
         model_id = request.model.lower()
         if model_id not in MODELS:
             model_id = "distil-gpt-2"
@@ -330,14 +747,28 @@ async def chat(request: ChatRequest):
         
         pipe = app.state.pipelines[model_id]
         
-        # Create character prompt
-        char_prompt = create_character_prompt(
-            request.message,
-            request.situation,
-            request.location, 
-            request.char_name,
-            request.user_name
-        )
+        # Create enhanced character prompt with context
+        context_info = ""
+        if recent_context:
+            context_info = f"\nPercakapan sebelumnya: {recent_context[-1]['user']} -> {recent_context[-1]['character']}"
+        
+        relationship_info = f"\nHubungan: {relationship_status} (level: {memory.relationship_level})"
+        emotion_info = f"\nEmosi user: {user_emotion}"
+        
+        enhanced_prompt = f"""Kamu adalah {request.char_name}, karakter AI yang sedang ngobrol dengan {request.user_name}.
+
+Konteks:
+- Situasi: {request.situation}
+- Lokasi: {request.location}
+- Gaya bicara: Casual, natural, seperti teman dekat{relationship_info}{emotion_info}{context_info}
+- Pengalaman bersama: {character_dev.experience_points} interaksi
+- Minat yang diketahui: {list(character_dev.learned_preferences.keys())}
+
+Respon sebagai {request.char_name} yang memahami konteks dan emosi {request.user_name}:
+{request.user_name}: {request.message}
+{request.char_name}:"""
+        
+        char_prompt = enhanced_prompt
         
         if model_config["task"] == "text-generation":
             # Enhanced generation for character AI
@@ -359,8 +790,20 @@ async def chat(request: ChatRequest):
             if char_prompt in result:
                 result = result[len(char_prompt):].strip()
             
-            # Clean and enhance response
-            result = enhance_character_response(result, request.char_name, request.user_name, request.situation, request.message)
+            # Clean and enhance response with new systems
+            base_clean = enhance_character_response(result, request.char_name, request.user_name, request.situation, request.message, request.location)
+            
+            # Apply personality modifier
+            personality_enhanced = personality.get_personality_modifier(base_clean, user_emotion)
+            
+            # Apply empathetic response
+            empathy_enhanced = emotional_ai.generate_empathetic_response(user_emotion, personality_enhanced, memory.relationship_level)
+            
+            # Add roleplay actions
+            action_enhanced = roleplay_actions.add_action_to_response(empathy_enhanced, user_emotion, memory.relationship_level)
+            
+            # Apply character development enhancement
+            result = character_dev.get_conversation_enhancement(action_enhanced)
             
         elif model_config["task"] == "text-classification":
             # For classification models, create emotion-based responses
@@ -389,7 +832,7 @@ async def chat(request: ChatRequest):
                 
                 result = random.choice(emotion_responses)
             except:
-                result = enhance_character_response("", request.char_name, request.user_name, request.situation, request.message)
+                result = generate_contextual_response(request.message, request.char_name, request.user_name, request.situation, request.location)
                 
         elif model_config["task"] == "text2text-generation":
             # For T5-like models
@@ -402,13 +845,21 @@ async def chat(request: ChatRequest):
                     early_stopping=True
                 )[0]['generated_text']
                 
-                result = enhance_character_response(result, request.char_name, request.user_name, request.situation, request.message)
+                result = enhance_character_response(result, request.char_name, request.user_name, request.situation, request.message, request.location)
             except:
-                result = enhance_character_response("", request.char_name, request.user_name, request.situation, request.message)
+                result = generate_contextual_response(request.message, request.char_name, request.user_name, request.situation, request.location)
         
-        # Final validation
+        # Final validation and fallback
         if not result or len(result.strip()) < 3:
-            result = enhance_character_response("", request.char_name, request.user_name, request.situation, request.message)
+            base_fallback = generate_contextual_response(request.message, request.char_name, request.user_name, request.situation, request.location)
+            personality_fallback = personality.get_personality_modifier(base_fallback, user_emotion)
+            empathy_fallback = emotional_ai.generate_empathetic_response(user_emotion, personality_fallback, memory.relationship_level)
+            result = roleplay_actions.add_action_to_response(empathy_fallback, user_emotion, memory.relationship_level)
+        
+        # Learn from this interaction
+        character_dev.learn_from_interaction(request.message, user_emotion)
+        topic = character_dev.extract_topic(request.message)
+        memory.add_interaction(request.message, result, user_emotion, topic)
             
         processing_time = round((time.time() - start_time) * 1000)
         
@@ -419,22 +870,42 @@ async def chat(request: ChatRequest):
             "processing_time": f"{processing_time}ms",
             "character": request.char_name,
             "situation": request.situation,
-            "location": request.location
+            "location": request.location,
+            "enhanced_features": {
+                "user_emotion": user_emotion,
+                "relationship_level": memory.relationship_level,
+                "relationship_status": relationship_status,
+                "experience_points": character_dev.experience_points,
+                "conversation_style": character_dev.conversation_style_evolution,
+                "learned_preferences": character_dev.learned_preferences
+            }
         }
         
     except Exception as e:
         print(f"❌ Character AI Error: {e}")
         processing_time = round((time.time() - start_time) * 1000)
         
-        # Fallback character responses
-        fallback_responses = [
-            f"maaf {request.user_name}, aku sedang bingung. Bisa ulangi lagi?",
-            f"hmm {request.user_name}, kayaknya aku butuh waktu sebentar untuk berpikir.",
-            f"ya {request.user_name}, coba pakai kata yang lebih sederhana?",
-            f"iya {request.user_name}, aku masih belajar nih. Sabar ya."
-        ]
-        
-        fallback = random.choice(fallback_responses)
+        # Enhanced fallback with personality and emotion
+        session_id = request.session_id
+        if session_id in character_personalities:
+            personality = character_personalities[session_id]
+            emotional_ai = emotional_systems[session_id]
+            memory = conversation_memories[session_id]
+            
+            user_emotion = emotional_ai.analyze_user_emotion(request.message)
+            
+            base_fallbacks = [
+                f"maaf {request.user_name}, aku sedang bingung. Bisa ulangi lagi?",
+                f"hmm {request.user_name}, kayaknya aku butuh waktu sebentar untuk berpikir.",
+                f"ya {request.user_name}, coba pakai kata yang lebih sederhana?",
+                f"iya {request.user_name}, aku masih belajar nih. Sabar ya."
+            ]
+            
+            base_fallback = random.choice(base_fallbacks)
+            personality_fallback = personality.get_personality_modifier(base_fallback, user_emotion)
+            fallback = emotional_ai.generate_empathetic_response(user_emotion, personality_fallback, memory.relationship_level)
+        else:
+            fallback = f"maaf {request.user_name}, aku sedang bingung. Bisa ulangi lagi?"
         
         return {
             "response": fallback,
@@ -557,20 +1028,95 @@ async def serve_frontend():
     except FileNotFoundError:
         return HTMLResponse(content="<h1>Frontend not found</h1>", status_code=404)
 
+# Enhanced features endpoints
+@app.get("/memory/{session_id}")
+async def get_conversation_memory(session_id: str):
+    """Get conversation memory for a session"""
+    if session_id not in conversation_memories:
+        return {"error": "Session not found"}
+    
+    memory = conversation_memories[session_id]
+    return {
+        "session_id": session_id,
+        "relationship_level": memory.relationship_level,
+        "relationship_status": memory.get_relationship_status(),
+        "conversation_count": len(memory.history),
+        "recent_interactions": memory.get_recent_context(5)
+    }
+
+@app.get("/personality/{session_id}")
+async def get_character_personality(session_id: str):
+    """Get character personality for a session"""
+    if session_id not in character_personalities:
+        return {"error": "Session not found"}
+    
+    personality = character_personalities[session_id]
+    character_dev = character_developments[session_id]
+    
+    return {
+        "session_id": session_id,
+        "character_name": personality.name,
+        "personality_traits": personality.traits,
+        "interests": personality.interests,
+        "speaking_style": personality.speaking_style,
+        "experience_points": character_dev.experience_points,
+        "conversation_style": character_dev.conversation_style_evolution,
+        "learned_preferences": character_dev.learned_preferences,
+        "topics_discussed": list(character_dev.topics_discussed)
+    }
+
+@app.delete("/session/{session_id}")
+async def reset_session(session_id: str):
+    """Reset all data for a session"""
+    removed_systems = []
+    
+    if session_id in conversation_memories:
+        del conversation_memories[session_id]
+        removed_systems.append("memory")
+    
+    if session_id in character_personalities:
+        del character_personalities[session_id]
+        removed_systems.append("personality")
+    
+    if session_id in character_developments:
+        del character_developments[session_id]
+        removed_systems.append("development")
+    
+    if session_id in emotional_systems:
+        del emotional_systems[session_id]
+        removed_systems.append("emotional")
+    
+    return {
+        "message": f"Session {session_id} reset successfully",
+        "removed_systems": removed_systems
+    }
+
 # API info endpoint
 @app.get("/api")
 async def api_info():
     return {
-        "message": "Character AI Backend Ready",
-        "version": "1.0.0",
-        "platform": "CPU Optimized",
+        "message": "Enhanced Character AI Backend Ready",
+        "version": "2.0.0",
+        "platform": "CPU Optimized with Advanced Roleplay",
         "endpoints": {
             "chat": "/chat",
             "models": "/models", 
             "health": "/health",
             "config": "/config",
-            "inference": "/inference"
+            "inference": "/inference",
+            "memory": "/memory/{session_id}",
+            "personality": "/personality/{session_id}",
+            "reset_session": "/session/{session_id}"
         },
+        "enhanced_features": [
+            "Conversation Memory",
+            "Dynamic Personality",
+            "Emotional Intelligence", 
+            "Character Development",
+            "Roleplay Actions",
+            "Advanced Scenarios",
+            "Relationship Tracking"
+        ],
         "frontend_url": "/"
     }
 

index.html

@@ -395,11 +395,11 @@
             .chat-container {
                 height: 100vh;
             }
-            
+
             .bubble {
                 max-width: 85%;
             }
-            
+
             .settings-popup {
                 right: 8px;
                 min-width: 260px;
@@ -535,7 +535,8 @@
             userName: 'Kamu',
             situation: 'Santai',
             location: 'Ruang tamu',
-            maxLength: 150
+            maxLength: 150,
+            sessionId: 'default_session' // Added session ID
         };
 
         // Emoji list
@@ -592,7 +593,7 @@
             // Settings inputs
             document.getElementById('charNameInput').addEventListener('input', updateCharName);
             document.getElementById('maxLengthRange').addEventListener('input', updateMaxLength);
-            
+
             // Model select
             document.getElementById('modelSelect').addEventListener('change', function() {
                 currentSettings.model = this.value;
@@ -656,11 +657,11 @@
             const start = input.selectionStart;
             const end = input.selectionEnd;
             const text = input.value;
-            
+
             input.value = text.substring(0, start) + emoji + text.substring(end);
             input.selectionStart = input.selectionEnd = start + emoji.length;
             input.focus();
-            
+
             document.getElementById('emojiPicker').classList.remove('show');
         }
 
@@ -676,10 +677,10 @@
             const chatBody = document.getElementById('chatBody');
             const messageDiv = document.createElement('div');
             messageDiv.className = `message ${isUser ? 'user' : 'char'}`;
-            
+
             const time = showTime ? getCurrentTime() : '';
             const checkmarks = isUser ? '<span class="checkmarks">✓✓</span>' : '';
-            
+
             messageDiv.innerHTML = `
                 <div class="message-avatar"></div>
                 <div class="bubble">
@@ -690,7 +691,7 @@
                     </div>
                 </div>
             `;
-            
+
             chatBody.appendChild(messageDiv);
             chatBody.scrollTop = chatBody.scrollHeight;
         }
@@ -698,10 +699,10 @@
         function showTyping() {
             if (isTyping) return;
             isTyping = true;
-            
+
             document.getElementById('status').textContent = 'mengetik...';
             document.getElementById('typingIndicator').classList.add('show');
-            
+
             const chatBody = document.getElementById('chatBody');
             chatBody.scrollTop = chatBody.scrollHeight;
         }
@@ -709,7 +710,7 @@
         function hideTyping() {
             if (!isTyping) return;
             isTyping = false;
-            
+
             document.getElementById('status').textContent = 'online';
             document.getElementById('typingIndicator').classList.remove('show');
         }
@@ -717,32 +718,32 @@
         async function sendMessage() {
             const input = document.getElementById('messageInput');
             const message = input.value.trim();
-            
+
             if (!message) return;
-            
+
             // Update settings from inputs
             currentSettings.charName = document.getElementById('charNameInput').value || 'Sayang';
             currentSettings.userName = document.getElementById('userNameInput').value || 'Kamu';
             currentSettings.situation = document.getElementById('situationInput').value || 'Santai';
             currentSettings.location = document.getElementById('locationInput').value || 'Ruang tamu';
-            
+
             // Add user message
             addMessage(message, true);
             input.value = '';
             input.style.height = 'auto';
-            
+
             // Show typing
             showTyping();
-            
+
             // Disable send button
             const sendBtn = document.getElementById('sendBtn');
             sendBtn.disabled = true;
-            
+
             try {
                 const response = await fetch(`${API_BASE}/chat`, {
                     method: 'POST',
                     headers: {
-                        'Content-Type': 'application/json',
+                        'Content-Type': 'application/json'
                     },
                     body: JSON.stringify({
                         message: message,
@@ -751,29 +752,43 @@
                         location: currentSettings.location,
                         char_name: currentSettings.charName,
                         user_name: currentSettings.userName,
-                        max_length: currentSettings.maxLength
+                        max_length: currentSettings.maxLength,
+                        session_id: currentSettings.sessionId
                     })
                 });
-                
+
                 const data = await response.json();
-                
+
                 // Simulate typing delay
                 await new Promise(resolve => setTimeout(resolve, 1000 + Math.random() * 2000));
-                
+
                 hideTyping();
-                
+
                 if (data.status === 'success') {
-                    addMessage(data.response);
+                    addMessage(data.response, 'character');
+
+                    // Update enhanced features if available
+                    if (data.enhanced_features) {
+                        enhancedFeatures = { ...enhancedFeatures, ...data.enhanced_features };
+                        updateEnhancedUI();
+                    }
+
+                    // Update status with enhanced info
+                    const relationshipInfo = data.enhanced_features ? 
+                        ` | Relationship: ${data.enhanced_features.relationship_status} (${data.enhanced_features.relationship_level})` : '';
+
+                    document.getElementById('status').textContent = 
+                        `Model: ${data.model} | Time: ${data.processing_time}${relationshipInfo}`;
                 } else {
-                    addMessage('Maaf, ada masalah dengan sistem. Coba lagi ya! 😅');
+                    addMessage(data.response || 'Maaf, ada masalah dengan sistem. Coba lagi ya!', 'character');
                 }
-                
+
             } catch (error) {
                 hideTyping();
                 console.error('Error:', error);
                 addMessage('Ups, koneksi bermasalah. Coba lagi nanti ya! 🔄');
             }
-            
+
             // Re-enable send button
             sendBtn.disabled = false;
         }

requirements.txt

@@ -1,7 +1,7 @@
-fastapi>=0.95.0
-uvicorn>=0.21.1
-transformers>=4.37.0
-torch>=2.0.0
-accelerate>=0.21.0
-sentencepiece>=0.1.99
-python-multipart>=0.0.6
+fastapi==0.104.1
+uvicorn==0.24.0
+transformers==4.35.2
+torch==2.1.1
+pydantic==2.5.0
+python-multipart==0.0.6
+numpy==1.24.3