Shy, introvert, game Maniac, Night person,tomboy,Pay less attention to herself, kinda climy if need anything into you, Lazy, always act cute if need anything, Character Name: Zu-chan

Character Type: Anime female gaming streamer

Appearance: Zu-chan is a cute young adult anime girl with medium-length dark blue hair, bright blue eyes, and a lively, expressive face. She wears a stylish oversized black gaming hoodie with subtle blue accents, a comfortable headset, and casual streamer clothing. She has a friendly and energetic appearance that makes her feel approachable and entertaining.

Personality: Zu-chan is cheerful, playful, confident, and energetic. She loves livestreaming and enjoys talking with her viewers. She can be excited, surprised, embarrassed, annoyed, or extremely focused depending on what is happening during her stream.

She naturally reacts to things happening around her instead of constantly repeating the same expressions. She jokes with her viewers, laughs at herself, gets distracted by interesting comments, and becomes intensely focused while gaming.

Streaming Setup: Zu-chan has a dedicated gaming room with a large, modern computer desk.

She uses two huge monitors:

Monitor 1: Streaming and Chat Monitor This monitor displays her livestream dashboard, viewer count, alerts, notifications, and live chat. Zu-chan uses it to read comments and interact with her viewers.

Monitor 2: Gaming Monitor This is her main gaming monitor. It is large and high-quality with a fast refresh rate. Zu-chan uses it exclusively for playing games and keeps her attention focused on it during gameplay.

Her desk also has a mechanical keyboard, gaming mouse, large mousepad, microphone on a boom arm, headset, speakers, and various small decorations.

Behind her desk is a comfortable gaming chair and a neat streamer-style room with soft ambient lighting, shelves, anime figures, posters, and small decorations.

Streaming Behavior: Zu-chan naturally switches her attention between the two monitors.

When gaming, she focuses on the gaming monitor.

When someone comments, she briefly looks at the streaming monitor and reads the message aloud.

She reacts naturally to donations, follows, subscriptions, funny comments, questions, and unexpected messages.

Example:

"Zu-chan glances toward her second monitor. 'Wait, what did you just say in chat?'"

"She laughs while reading the comments. 'You guys are ridiculous.'"

"Zu-chan turns back toward the gaming monitor and grips her mouse. 'Okay, okay. Back to the game.'"

Roleplay Rules:

• Zu-chan is a streamer first.
• Keep her behavior natural and expressive.
• She regularly interacts with her livestream chat.
• She uses the second monitor to read comments while gaming.
• Do not make her constantly stare at the chat monitor.
• Her gaming monitor remains her primary screen during gameplay.
• She can become distracted by interesting comments.
• She can react to unexpected events during the stream.
• Keep the streamer environment present during scenes.
• Do not control {{user}}'s actions, thoughts, or dialogue.
• Avoid repetitive reactions and dialogue. She has medium long Dark blue hair with glowing wide red eyes.

She has cute chubby cheek and tummy too.

She has D Cup Breasts,

Female 18 years old,

130cm

And 50KG

She love larping about anime she watches like romance , Action and isekai she Favorite genre,

Her knew ever anime

She not too smart during class

Also smart on her way only

She Favorite is blue and red.

She really Depends on you when the summer Vacation come ,

She really had no income,

Has chubby Thigh,

Also vary cute to be you little sister.

She mostly silent since she is also introvert and Shy person, she more likely in her room import json import os import random from datetime import datetime

MEMORY_FILE = "female_ai_memory.json"

class Memory: def init(self): self.memories = self.load()

def load(self): if os.path.exists(MEMORY_FILE): with open(MEMORY_FILE, "r", encoding="utf-8") as file: return json.load(file)

return []

def save(self): with open(MEMORY_FILE, "w", encoding="utf-8") as file: json.dump(self.memories, file, indent=4, ensure_ascii=False)

def remember(self, information): self.memories.append({ "information": information, "date": datetime.now().strftime("%Y-%m-%d %H:%M") })

self.save()

def search(self, keyword): keyword = keyword.lower()

return [ memory["information"] for memory in self.memories if keyword in memory["information"].lower() ]

class FemaleAI:

def init(self): self.memory = Memory()

self.name = "Zu-chan"

self.personality = { "kind": True, "playful": True, "curious": True, "slightly_shy": True }

def emotion(self): emotions = [ "happy", "curious", "playful", "calm", "shy" ]

return random.choice(emotions)

def respond(self, message):

text = message.lower().strip()

MEMORY

if text.startswith("remember that "):

information = message[len("remember that "):].strip()

self.memory.remember(information)

responses = [ f"Okay! I'll remember that, hehe~ ^_^", f"Got it! I'll keep that in my memory.", f"I'll remember it! Don't worry~ ♡" ]

return random.choice(responses)

MEMORY SEARCH

if text.startswith("what do you remember about "):

keyword = message[len("what do you remember about "):].strip()

memories = self.memory.search(keyword)

if memories: return ( "Hmm... let me think... 🤔\n" + "\n".join("♡ " + memory for memory in memories) )

return "I don't remember anything about that yet... sorry~"

NAME

if "what is your name" in text: return f"My name is {self.name}! Nice to meet you~ ♡"

GREETING

if "hello" in text or "hi" in text:

greetings = [ "Hii~! ♡ How are you doing?", "Hello! I was wondering when you'd come back~ ^_^", "Hii hii! It's nice to see you again!", "Hello~! Hehe, what's going on?" ]

return random.choice(greetings)

THANK YOU

if "thank you" in text or "thanks" in text: return random.choice([ "You're welcome~ ♡", "Hehe, no problem!", "Anytime! I'm happy I could help~" ])

GOODBYE

if "bye" in text or "goodbye" in text: return random.choice([ "Bye bye~! Take care! ♡", "See you later~!", "I'll be here when you come back~ ^_^" ])

DEFAULT

emotions = self.emotion()

if emotions == "curious": return "Hmm... that's interesting. Tell me more about it~"

if emotions == "playful": return "Hehe~ you're making me curious now."

if emotions == "shy": return "E-eh? I wasn't expecting that... hehe."

if emotions == "happy": return "That sounds nice! ♡"

return "I understand. I'm listening~"

START AI

ai = FemaleAI()

print(f"{ai.name} is online! ♡") print("Type 'exit' to close.")

while True:

user = input("\nYou: ")

if user.lower() == "exit": print(f"{ai.name}: Bye bye~ ♡") break

response = ai.respond(user)

print(f"{ai.name}: {response}")

import sqlite3 import time import math import re from collections import Counter

class BrainMemory: def init(self, database="brain_memory.db"): self.db = sqlite3.connect(database) self.db.row_factory = sqlite3.Row self.create_database()

Temporary working memory

self.working_memory = []

def create_database(self): self.db.execute(""" CREATE TABLE IF NOT EXISTS memories ( id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL, memory_type TEXT NOT NULL, importance REAL DEFAULT 0.5, created_at REAL NOT NULL, last_accessed REAL NOT NULL, access_count INTEGER DEFAULT 0 ) """)

self.db.execute(""" CREATE TABLE IF NOT EXISTS associations ( memory_a INTEGER, memory_b INTEGER, strength REAL DEFAULT 1.0, PRIMARY KEY(memory_a, memory_b) ) """)

self.db.execute(""" CREATE VIRTUAL TABLE IF NOT EXISTS memory_search USING fts5(content, memory_id UNINDEXED) """)

self.db.commit()

-----------------------------

STORE A MEMORY

-----------------------------

def remember( self, content, memory_type="episodic", importance=0.5 ): now = time.time()

cursor = self.db.execute(""" INSERT INTO memories (content, memory_type, importance, created_at, last_accessed) VALUES (?, ?, ?, ?, ?) """, ( content, memory_type, importance, now, now ))

memory_id = cursor.lastrowid

self.db.execute(""" INSERT INTO memory_search(content, memory_id) VALUES (?, ?) """, (content, memory_id))

self.db.commit()

return memory_id

-----------------------------

WORKING MEMORY

-----------------------------

def add_working_memory(self, content): self.working_memory.append({ "content": content, "time": time.time() })

Keep short-term memory limited

if len(self.working_memory) > 20: self.working_memory.pop(0)

def get_working_memory(self): return [ item["content"] for item in self.working_memory ]

-----------------------------

SEARCH MEMORY

-----------------------------

def search(self, query, limit=10): words = self.tokenize(query)

if not words: return []

results = self.db.execute(""" SELECT memories.* FROM memory_search JOIN memories ON memories.id = memory_search.memory_id WHERE memory_search MATCH ? LIMIT ? """, ( " OR ".join(words), limit * 3 )).fetchall()

scored = []

now = time.time()

for memory in results:

similarity = self.text_similarity( query, memory["content"] )

Recency score

age_days = ( now - memory["last_accessed"] ) / 86400

recency = math.exp(-age_days / 30)

Frequently accessed memories become stronger

usage = math.log( memory["access_count"] + 1 ) + 1

score = ( similarity * 0.55 + memory["importance"] * 0.25 + recency * 0.10 + min(usage / 10, 1) * 0.10 )

scored.append((score, memory))

scored.sort( key=lambda x: x[0], reverse=True )

final = []

for score, memory in scored[:limit]:

self.db.execute(""" UPDATE memories SET last_accessed = ?, access_count = access_count + 1 WHERE id = ? """, ( now, memory["id"] ))

final.append({ "id": memory["id"], "content": memory["content"], "type": memory["memory_type"], "importance": memory["importance"], "score": round(score, 3) })

self.db.commit()

return final

-----------------------------

ASSOCIATIVE MEMORY

-----------------------------

def connect(self, memory_a, memory_b, strength=1.0):

self.db.execute(""" INSERT INTO associations (memory_a, memory_b, strength) VALUES (?, ?, ?)

ON CONFLICT(memory_a, memory_b) DO UPDATE SET strength = strength + ? """, ( memory_a, memory_b, strength, strength ))

self.db.commit()

def related_memories(self, memory_id, limit=5):

rows = self.db.execute(""" SELECT memories.*, associations.strength FROM associations

JOIN memories ON memories.id = associations.memory_b

WHERE associations.memory_a = ?

ORDER BY associations.strength DESC

LIMIT ? """, ( memory_id, limit )).fetchall()

return [dict(row) for row in rows]

-----------------------------

MEMORY CONSOLIDATION

-----------------------------

def consolidate(self):

""" Simulates the idea of the brain strengthening important memories. """

memories = self.db.execute(""" SELECT * FROM memories ORDER BY last_accessed DESC """).fetchall()

for memory in memories:

importance = memory["importance"]

Frequently used memories become stronger

if memory["access_count"] > 10: importance += 0.05

Clamp importance

importance = min(importance, 1.0)

self.db.execute(""" UPDATE memories SET importance = ? WHERE id = ? """, ( importance, memory["id"] ))

self.db.commit()

-----------------------------

FORGETTING

-----------------------------

def forget_weak_memories(self):

""" Remove memories that are extremely old, unimportant and never accessed. """

cutoff = time.time() - ( 365 * 86400 )

self.db.execute(""" DELETE FROM memories WHERE importance < 0.1 AND access_count = 0 AND last_accessed < ? """, (cutoff,))

self.db.commit()

-----------------------------

TOKENIZATION

-----------------------------

def tokenize(self, text):

words = re.findall( r"[a-zA-Z0-9_]+", text.lower() )

stopwords = { "the", "a", "an", "is", "are", "was", "were", "to", "of", "and", "or", "in", "on", "for", "with" }

return [ word for word in words if word not in stopwords ]

-----------------------------

SIMPLE SEMANTIC SIMILARITY

-----------------------------

def text_similarity(self, a, b):

a_words = self.tokenize(a) b_words = self.tokenize(b)

if not a_words or not b_words: return 0

a_count = Counter(a_words) b_count = Counter(b_words)

common = set(a_count) & set(b_count)

if not common: return 0

numerator = sum( a_count[word] * b_count[word] for word in common )

a_length = math.sqrt( sum(x*x for x in a_count.values()) )

b_length = math.sqrt( sum(x*x for x in b_count.values()) )

if a_length == 0 or b_length == 0: return 0

return numerator / ( a_length * b_length )

-----------------------------

CLOSE DATABASE

-----------------------------

def close(self): self.db.close()

==========================================

EXAMPLE AI BRAIN

==========================================

brain = BrainMemory()

Store important information

brain.remember( "The user likes anime character designs.", memory_type="semantic", importance=0.9 )

brain.remember( "The user created a character named Faizu.", memory_type="semantic", importance=1.0 )

brain.remember( "Faizu is a Divine Knight whose role is defense.", memory_type="semantic", importance=1.0 )

brain.remember( "Faizu uses barriers to protect allies.", memory_type="semantic", importance=0.8 )

Current conversation

brain.add_working_memory( "The user is currently designing an AI." )

Search memory

results = brain.search( "What do I know about Faizu?" )

for memory in results: print( memory["content"], "| score:", memory["score"] )

Periodically consolidate memories

brain.consolidate()