Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

1. user to create multiple characters and avtars and speak/chat to them. Build a tired…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with MiniMaxminimax-m1’s answer.
  1. User
    1. user to create multiple characters and avtars and speak/chat to them. Build a tired subscription level for user.
  2. Claude Assistant

    1. Multiple Characters & Avatars System

    Database Schema Updates

    // Character Schema with Avatar Support
    const characterSchema = new mongoose.Schema({
      name: { type: String, required: true },
      description: String,
      personality: String,
      language: { type: String, default: 'english' },
      visibility: { type: String, enum: ['public', 'private'], default: 'private' },
      owner: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
      avatar: {
        type: { type: String, enum: ['preset', 'custom'], default: 'preset' },
        presetId: String, // For preset avatars
        customImage: String, // URL for custom uploaded images
        appearance: {
          gender: { type: String, enum: ['male', 'female', 'non-binary'] },
          age: String,
          style: String, // modern, traditional, anime, etc.
          clothing: String,
          accessories: [String]
        }
      },
      voice: {
        pitch: { type: Number, default: 0 },
        speed: { type: Number, default: 1 },
        accent: String
      },
      backstory: String,
      interests: [String],
      createdAt: { type: Date, default: Date.now },
      lastInteraction: Date,
      totalChats: { type: Number, default: 0 }
    });
    
    // User Schema with Subscription
    const userSchema = new mongoose.Schema({
      email: { type: String, required: true, unique: true },
      password: { type: String, required: true },
      isVerified: { type: Boolean, default: false },
      subscription: {
        tier: { type: String, enum: ['free', 'premium', 'pro'], default: 'free' },
        startDate: Date,
        endDate: Date,
        isActive: { type: Boolean, default: true }
      },
      usage: {
        charactersCreated: { type: Number, default: 0 },
        monthlyChats: { type: Number, default: 0 },
        voiceMinutes: { type: Number, default: 0 },
        lastReset: { type: Date, default: Date.now }
      },
      createdAt: { type: Date, default: Date.now }
    });
    

    Character Creation API

    // Create Character Endpoint
    app.post('/api/characters', authenticate, async (req, res) => {
      try {
        const user = await User.findById(req.user.userId);
        
        // Check subscription limits
        const limits = getSubscriptionLimits(user.subscription.tier);
        if (user.usage.charactersCreated >= limits.maxCharacters) {
          return res.status(403).json({ 
            error: 'Character limit reached. Upgrade your subscription.' 
          });
        }
        
        const character = new Character({
          ...req.body,
          owner: req.user.userId
        });
        
        await character.save();
        
        // Update user usage
        await User.findByIdAndUpdate(req.user.userId, {
          $inc: { 'usage.charactersCreated': 1 }
        });
        
        res.status(201).json(character);
      } catch (error) {
        res.status(400).json({ error: error.message });
      }
    });
    
    // Get User's Characters
    app.get('/api/my-characters', authenticate, async (req, res) => {
      const characters = await Character.find({ owner: req.user.userId })
        .sort({ lastInteraction: -1 });
      res.json(characters);
    });
    
    // Update Character
    app.put('/api/characters/:id', authenticate, async (req, res) => {
      const character = await Character.findOneAndUpdate(
        { _id: req.params.id, owner: req.user.userId },
        req.body,
        { new: true }
      );
      if (!character) return res.status(404).json({ error: 'Character not found' });
      res.json(character);
    });
    

    Frontend Character Management

    // CharacterCreator.jsx
    import { useState } from 'react';
    
    function CharacterCreator({ onCharacterCreated }) {
      const [character, setCharacter] = useState({
        name: '',
        description: '',
        personality: '',
        language: 'english',
        visibility: 'private',
        avatar: {
          type: 'preset',
          presetId: 'avatar_1',
          appearance: {
            gender: 'female',
            age: 'young',
            style: 'modern'
          }
        },
        backstory: '',
        interests: []
      });
      
      const [presetAvatars] = useState([
        { id: 'avatar_1', name: 'Modern Girl', image: '/avatars/modern_girl.png' },
        { id: 'avatar_2', name: 'Traditional Man', image: '/avatars/traditional_man.png' },
        { id: 'avatar_3', name: 'Anime Style', image: '/avatars/anime_style.png' },
        // Add more preset avatars
      ]);
      
      const handleSubmit = async (e) => {
        e.preventDefault();
        try {
          const response = await fetch('/api/characters', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            credentials: 'include',
            body: JSON.stringify(character)
          });
          
          if (response.ok) {
            const newCharacter = await response.json();
            onCharacterCreated(newCharacter);
          } else {
            const error = await response.json();
            alert(error.error);
          }
        } catch (error) {
          alert('Failed to create character');
        }
      };
      
      return (
        <form onSubmit={handleSubmit} className="character-creator">
          <h2>Create New Character</h2>
          
          {/* Basic Info */}
          <div className="section">
            <input
              type="text"
              placeholder="Character Name"
              value={character.name}
              onChange={(e) => setCharacter({...character, name: e.target.value})}
              required
            />
            
            <textarea
              placeholder="Description"
              value={character.description}
              onChange={(e) => setCharacter({...character, description: e.target.value})}
            />
            
            <select
              value={character.language}
              onChange={(e) => setCharacter({...character, language: e.target.value})}
            >
              <option value="english">English</option>
              <option value="hindi">Hindi</option>
              <option value="tamil">Tamil</option>
              <option value="telugu">Telugu</option>
              <option value="bengali">Bengali</option>
            </select>
          </div>
          
          {/* Avatar Selection */}
          <div className="avatar-section">
            <h3>Choose Avatar</h3>
            <div className="avatar-grid">
              {presetAvatars.map(avatar => (
                <div 
                  key={avatar.id}
                  className={`avatar-option ${character.avatar.presetId === avatar.id ? 'selected' : ''}`}
                  onClick={() => setCharacter({
                    ...character, 
                    avatar: {...character.avatar, presetId: avatar.id}
                  })}
                >
                  <img src={avatar.image} alt={avatar.name} />
                  <span>{avatar.name}</span>
                </div>
              ))}
            </div>
          </div>
          
          {/* Personality */}
          <div className="personality-section">
            <textarea
              placeholder="Personality traits (e.g., friendly, witty, philosophical)"
              value={character.personality}
              onChange={(e) => setCharacter({...character, personality: e.target.value})}
            />
            
            <textarea
              placeholder="Backstory"
              value={character.backstory}
              onChange={(e) => setCharacter({...character, backstory: e.target.value})}
            />
          </div>
          
          <button type="submit">Create Character</button>
        </form>
      );
    }
    
    // CharacterList.jsx
    function CharacterList({ characters, onSelectCharacter }) {
      return (
        <div className="character-list">
          <h2>Your Characters</h2>
          <div className="characters-grid">
            {characters.map(character => (
              <div 
                key={character._id} 
                className="character-card"
                onClick={() => onSelectCharacter(character)}
              >
                <img 
                  src={character.avatar.type === 'preset' 
                    ? `/avatars/${character.avatar.presetId}.png`
                    : character.avatar.customImage
                  } 
                  alt={character.name} 
                />
                <h3>{character.name}</h3>
                <p>{character.description}</p>
                <span className="language">{character.language}</span>
                <span className="chat-count">{character.totalChats} chats</span>
              </div>
            ))}
          </div>
        </div>
      );
    }
    

    2. Tiered Subscription System

    Subscription Configuration

    // Subscription limits configuration
    const subscriptionLimits = {
      free: {
        maxCharacters: 2,
        monthlyChats: 50,
        voiceMinutes: 10,
        features: ['basic_chat', 'preset_avatars']
      },
      premium: {
        maxCharacters: 10,
        monthlyChats: 500,
        voiceMinutes: 100,
        features: ['basic_chat', 'voice_chat', 'preset_avatars', 'custom_avatars', 'priority_support']
      },
      pro: {
        maxCharacters: -1, // unlimited
        monthlyChats: -1, // unlimited
        voiceMinutes: -1, // unlimited
        features: ['all_features', 'api_access', 'advanced_customization', 'priority_support']
      }
    };
    
    function getSubscriptionLimits(tier) {
      return subscriptionLimits[tier] || subscriptionLimits.free;
    }
    

    Subscription Management API

    // Check usage middleware
    const checkUsage = (feature) => {
      return async (req, res, next) => {
        try {
          const user = await User.findById(req.user.userId);
          const limits = getSubscriptionLimits(user.subscription.tier);
          
          // Reset monthly usage if needed
          const now = new Date();
          const lastReset = new Date(user.usage.lastReset);
          if (now.getMonth() !== lastReset.getMonth()) {
            await User.findByIdAndUpdate(req.user.userId, {
              'usage.monthlyChats': 0,
              'usage.voiceMinutes': 0,
              'usage.lastReset': now
            });
            user.usage.monthlyChats = 0;
            user.usage.voiceMinutes = 0;
          }
          
          // Check specific feature limits
          switch (feature) {
            case 'chat':
              if (limits.monthlyChats !== -1 && user.usage.monthlyChats >= limits.monthlyChats) {
                return res.status(403).json({ 
                  error: 'Monthly chat limit reached. Upgrade your subscription.',
                  upgradeRequired: true 
                });
              }
              break;
            case 'voice':
              if (limits.voiceMinutes !== -1 && user.usage.voiceMinutes >= limits.voiceMinutes) {
                return res.status(403).json({ 
                  error: 'Monthly voice limit reached. Upgrade your subscription.',
                  upgradeRequired: true 
                });
              }
              break;
          }
          
          req.userLimits = limits;
          next();
        } catch (error) {
          res.status(500).json({ error: 'Failed to check usage limits' });
        }
      };
    };
    
    // Subscription plans endpoint
    app.get('/api/subscription/plans', (req, res) => {
      const plans = [
        {
          id: 'free',
          name: 'Free',
          price: 0,
          currency: 'USD',
          interval: 'month',
          features: [
            '2 Characters',
            '50 Monthly Chats',
            '10 Voice Minutes',
            'Preset Avatars',
            'Basic Support'
          ]
        },
        {
          id: 'premium',
          name: 'Premium',
          price: 9.99,
          currency: 'USD',
          interval: 'month',
          features: [
            '10 Characters',
            '500 Monthly Chats',
            '100 Voice Minutes',
            'Custom Avatars',
            'Voice Chat',
            'Priority Support'
          ]
        },
        {
          id: 'pro',
          name: 'Pro',
          price: 19.99,
          currency: 'USD',
          interval: 'month',
          features: [
            'Unlimited Characters',
            'Unlimited Chats',
            'Unlimited Voice',
            'All Features',
            'API Access',
            'Advanced Customization',
            'Priority Support'
          ]
        }
      ];
      
      res.json(plans);
    });
    
    // Get user subscription status
    app.get('/api/subscription/status', authenticate, async (req, res) => {
      const user = await User.findById(req.user.userId);
      const limits = getSubscriptionLimits(user.subscription.tier);
      
      res.json({
        subscription: user.subscription,
        usage: user.usage,
        limits,
        remainingChats: limits.monthlyChats === -1 ? -1 : Math.max(0, limits.monthlyChats - user.usage.monthlyChats),
        remainingVoice: limits.voiceMinutes === -1 ? -1 : Math.max(0, limits.voiceMinutes - user.usage.voiceMinutes)
      });
    });
    

    Payment Integration (Stripe)

    // Install: npm install stripe
    const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
    
    // Create subscription
    app.post('/api/subscription/create', authenticate, async (req, res) => {
      try {
        const { planId, paymentMethodId } = req.body;
        const user = await User.findById(req.user.userId);
        
        // Create or retrieve Stripe customer
        let customer;
        if (user.stripeCustomerId) {
          customer = await stripe.customers.retrieve(user.stripeCustomerId);
        } else {
          customer = await stripe.customers.create({
            email: user.email,
            payment_method: paymentMethodId,
            invoice_settings: { default_payment_method: paymentMethodId }
          });
          
          await User.findByIdAndUpdate(req.user.userId, {
            stripeCustomerId: customer.id
          });
        }
        
        // Create subscription
        const subscription = await stripe.subscriptions.create({
          customer: customer.id,
          items: [{ price: getPriceId(planId) }],
          expand: ['latest_invoice.payment_intent']
        });
        
        // Update user subscription
        await User.findByIdAndUpdate(req.user.userId, {
          'subscription.tier': planId,
          'subscription.startDate': new Date(),
          'subscription.endDate': new Date(subscription.current_period_end * 1000),
          'subscription.isActive': true,
          stripeSubscriptionId: subscription.id
        });
        
        res.json({ subscription });
      } catch (error) {
        res.status(400).json({ error: error.message });
      }
    });
    
    function getPriceId(planId) {
      const priceIds = {
        premium: 'price_premium_monthly',
        pro: 'price_pro_monthly'
      };
      return priceIds[planId];
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.