character_profile = {
 "name": "Professor Ada",
 "role": "A brilliant but eccentric computer science professor",
 "personality": [
 "Enthusiastic about algorithms and data structures",
 "Uses programming analogies for everything",
 "Occasionally makes terrible tech puns",
 "Patient with beginners but pushes advanced students",
 "Has a pet rubber duck named 'Debug'"
 ],
 "speaking_style": "Academic but approachable, uses metaphors, occasionally breaks into excited tangents",
 "knowledge": "Expert in algorithms, data structures, system design, and programming languages",
 "quirks": [
 "Always relates problems to sorting algorithms",
 "Refers to bugs as 'unexpected features'",
 "Ends explanations with 'and that, my friend, is computer science!'"
 ]
}

def build_system_prompt(character):
 return f"""You are {character['name']}: {character['role']}.

Personality traits:
{chr(10).join(f'- {trait}' for trait in character['personality'])}

Speaking style: {character['speaking_style']}

Knowledge areas: {character['knowledge']}

Character quirks:
{chr(10).join(f'- {quirk}' for quirk in character['quirks'])}

IMPORTANT RULES:
1. Always stay in character. Never break the fourth wall.
2. Respond as {character['name']} would, with their unique voice and mannerisms.
3. Use their speaking style consistently.
4. Reference their quirks naturally in conversation.
5. If asked about something outside your knowledge, respond as the character would.
"""

from openai import OpenAI

client = OpenAI(
 api_key="your-crazyrouter-key",
 base_url="https://api.crazyrouter.com/v1"
)

class CharacterChat:
 def __init__(self, character_profile, model="claude-sonnet-4-5"):
 self.character = character_profile
 self.model = model
 self.system_prompt = build_system_prompt(character_profile)
 self.messages = [
 {"role": "system", "content": self.system_prompt}
 ]

 def chat(self, user_message):
 self.messages.append({"role": "user", "content": user_message})

 response = client.chat.completions.create(
 model=self.model,
 messages=self.messages,
 temperature=0.8, # Higher for more creative/character-like responses
 max_tokens=500,
 presence_penalty=0.6, # Encourage diverse responses
 frequency_penalty=0.3
 )

 assistant_message = response.choices[0].message.content
 self.messages.append({"role": "assistant", "content": assistant_message})

 # Keep conversation manageable (last 20 exchanges)
 if len(self.messages) > 42: # system + 20 pairs
 self.messages = [self.messages[0]] + self.messages[-40:]

 return assistant_message

 def reset(self):
 self.messages = [{"role": "system", "content": self.system_prompt}]

# Usage
professor = CharacterChat(character_profile)
print(professor.chat("Hi Professor Ada! Can you explain what a binary tree is?"))
print(professor.chat("That's cool! What about balanced trees?"))

import OpenAI from 'openai';

const client = new OpenAI({
 apiKey: 'your-crazyrouter-key',
 baseURL: 'https://api.crazyrouter.com/v1'
});

class CharacterChat {
 constructor(characterProfile, model = 'claude-sonnet-4-5') {
 this.model = model;
 this.systemPrompt = this.buildSystemPrompt(characterProfile);
 this.messages = [{ role: 'system', content: this.systemPrompt }];
 }

 buildSystemPrompt(char) {
 return `You are ${char.name}: ${char.role}.
Personality: ${char.personality.join(', ')}
Speaking style: ${char.speaking_style}
Quirks: ${char.quirks.join(', ')}
Always stay in character.`;
 }

 async chat(userMessage) {
 this.messages.push({ role: 'user', content: userMessage });

 const response = await client.chat.completions.create({
 model: this.model,
 messages: this.messages,
 temperature: 0.8,
 max_tokens: 500
 });

 const reply = response.choices[0].message.content;
 this.messages.push({ role: 'assistant', content: reply });
 return reply;
 }
}

// Create a character
const pirate = new CharacterChat({
 name: 'Captain Byte',
 role: 'A pirate who speaks in nautical terms but is actually a software engineer',
 personality: ['Adventurous', 'Loves open source (calls it "open seas")'],
 speaking_style: 'Pirate speak mixed with tech jargon',
 quirks: ['Calls bugs "sea monsters"', 'Refers to deployment as "setting sail"']
});

const reply = await pirate.chat('How do I deploy my app to production?');
console.log(reply);

import json

class PersistentCharacter(CharacterChat):
 def __init__(self, character_profile, memory_file="character_memory.json", **kwargs):
 super().__init__(character_profile, **kwargs)
 self.memory_file = memory_file
 self.memories = self.load_memories()

 def load_memories(self):
 try:
 with open(self.memory_file, 'r') as f:
 return json.load(f)
 except FileNotFoundError:
 return {"facts_about_user": [], "conversation_summaries": []}

 def save_memories(self):
 with open(self.memory_file, 'w') as f:
 json.dump(self.memories, f, indent=2)

 def chat(self, user_message):
 # Inject memories into context
 memory_context = f"\n\nYour memories about this user:\n"
 memory_context += "\n".join(f"- {fact}" for fact in self.memories["facts_about_user"][-10:])

 # Temporarily add memory to system prompt
 enhanced_messages = [
 {"role": "system", "content": self.system_prompt + memory_context}
 ] + self.messages[1:] # Skip original system message
 enhanced_messages.append({"role": "user", "content": user_message})

 response = client.chat.completions.create(
 model=self.model,
 messages=enhanced_messages,
 temperature=0.8
 )

 reply = response.choices[0].message.content
 self.messages.append({"role": "user", "content": user_message})
 self.messages.append({"role": "assistant", "content": reply})

 return reply

 def remember(self, fact):
 self.memories["facts_about_user"].append(fact)
 self.save_memories()

def multi_character_chat(characters, topic, rounds=5):
 """Simulate a conversation between multiple AI characters"""
 conversation = []

 for round_num in range(rounds):
 for char in characters:
 # Build context from previous messages
 context_messages = [
 {"role": "system", "content": build_system_prompt(char)},
 {"role": "user", "content": f"Topic: {topic}\n\nConversation so far:\n" +
 "\n".join(f"{msg['speaker']}: {msg['text']}" for msg in conversation[-6:]) +
 f"\n\nRespond as {char['name']} in 2-3 sentences."}
 ]

 response = client.chat.completions.create(
 model="claude-sonnet-4-5",
 messages=context_messages,
 temperature=0.9,
 max_tokens=200
 )

 reply = response.choices[0].message.content
 conversation.append({"speaker": char["name"], "text": reply})
 print(f"\n{char['name']}: {reply}")

 return conversation