"Character AI API Guide: Build Conversational AI Characters Programmatically"

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