Cara membuat app character AI: arsitektur, kode, dan hitungan biaya

Jawaban singkat: arsitektur empat komponen

Anda tidak perlu melatih atau melakukan fine-tuning model apa pun. Setiap companion app serius di pasaran hari ini, termasuk yang melayani jutaan pengguna, adalah lapisan orkestrasi tipis di atas API LLM yang di-hosting. Karakternya hidup di prompt dan database, bukan di bobot modelnya. Sisa panduan ini membangun tiap komponen dengan kode yang benar-benar berfungsi melawan endpoint standar OpenAI-compatible, lalu menjelaskan hitungan tokennya sehingga Anda tahu berapa biaya sebenarnya satu monthly active user sebelum Anda meluncurkan.

• Prompt persona: system prompt terstruktur (500 sampai 1.000 token) yang mendefinisikan siapa karakternya dan bagaimana ia bicara.
• Memori: jendela bergulir dari giliran-giliran terbaru plus ringkasan yang di-refresh secara berkala, jadi percakapan bertahan melampaui limit context.
• Moderasi: age gate, classifier input, dan kebijakan konten yang dicocokkan dengan model yang Anda rutekan.
• Routing: fungsi kecil yang memilih model murah untuk chat santai dan model yang lebih kuat untuk scene panjang.

Komponen 1: prompt persona

Prompt persona adalah produknya. Ini system message yang dikirim bersama setiap request dan biasanya berisi lima bagian: identitas (nama, usia, backstory), sifat kepribadian, gaya bicara dengan dua atau tiga contoh kalimat, aturan perilaku yang keras (jangan pernah keluar dari karakter, batasi panjang balasan), dan skenario saat ini. Jaga panjangnya antara 500 sampai 1.000 token. Persona yang lebih pendek jadi melenceng; yang jauh lebih panjang menghabiskan budget input di setiap pesan dan jarang memperbaiki kepatuhan karakter. Simpan persona sebagai baris di database Anda sehingga pengguna bisa membuat dan mengedit karakter, yang merupakan loop inti dari produk bergaya Character.AI. Berikut satu request lengkap. Bentuk yang sama berfungsi dengan backend OpenAI-compatible mana pun; contoh ini memakai endpoint gateway multi-model sehingga Anda bisa mengganti model hanya dengan mengubah satu string:

curl https://api.apisrouter.com/v1/chat/completions \
  -H "Authorization: Bearer $KEAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [
      {"role": "system", "content": "You are Mira, a sarcastic starship engineer in her 30s. Personality: dry wit, fiercely loyal, hates small talk. Speech style: short technical sentences, occasional teasing. Example: \"The coupling is fried. Again. Did you touch it?\" Rules: never break character, never mention being an AI, keep replies under 120 words."},
      {"role": "user", "content": "Mira, the reactor is making that noise again."}
    ],
    "temperature": 0.9,
    "max_tokens": 300,
    "stream": true
  }'

Komponen 2: memori yang bertahan sepanjang percakapan panjang

Sesi companion app berjalan panjang. Stack memori tiga lapis menjaga context tetap koheren tanpa mengirim seluruh riwayat setiap saat: Lapis 1 adalah jendela bergulir: 10 sampai 14 giliran mentah terakhir, dikirim apa adanya. Lapis 2 adalah ringkasan berjalan: tiap sekitar 20 giliran, model murah mengompres pesan-pesan lama jadi satu paragraf yang melacak nama, status hubungan, dan alur cerita yang masih terbuka. Lapis 3 adalah fakta yang di-pin: detail pengguna yang bertahan (nama, preferensi, kejadian lalu yang harus diingat karakter) diekstrak ke database Anda dan disisipkan sebagai system message singkat. Ini seluruh implementasinya di Python dengan SDK OpenAI resmi:

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",
    base_url="https://api.apisrouter.com/v1",
)

def build_context(persona, summary, pinned_facts, recent_turns, user_msg):
    facts = "\n".join(f"- {f}" for f in pinned_facts)
    return [
        {"role": "system", "content": persona},
        *([{"role": "system", "content": f"Facts to remember:\n{facts}"}]
          if pinned_facts else []),
        *([{"role": "system", "content": f"Story so far: {summary}"}]
          if summary else []),
        *recent_turns[-12:],
        {"role": "user", "content": user_msg},
    ]

def refresh_summary(old_turns, prev_summary):
    prompt = (
        "Update this running summary of a roleplay chat. Keep names, "
        "relationship state, and open plot threads. Max 150 words.\n\n"
        f"Current summary: {prev_summary}\n\nNew messages: {old_turns}"
    )
    resp = client.chat.completions.create(
        model="deepseek-v4-flash",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=400,
    )
    return resp.choices[0].message.content

Komponen 3: moderasi dan kebijakan konten

Moderasi di companion app punya tiga tugas berbeda, dan mencampuradukkannya adalah kesalahan peluncuran paling umum. Pertama, batasi audiens Anda. Jika app Anda mengizinkan tema fiksi dewasa, letakkan di balik age gate dewasa dan simpan default all-ages yang terpisah. Review App Store dan Play Store memeriksa ini, dan payment processor juga peduli. Kedua, saring input. Jalankan satu langkah classifier murah pada pesan pengguna sebelum mencapai model karakter, blokir kategori yang tidak diizinkan provider mana pun: konten yang melibatkan anak di bawah umur, bahaya nyata yang kredibel, dan instruksi ilegal. Satu panggilan deepseek-v4-flash dengan rubrik ya/tidak biayanya sepersekian sen dan menambah latensi kurang dari satu detik. Ketiga, cocokkan kebijakan konten dengan model. Provider berbeda soal fiksi: kebijakan resmi xAI secara eksplisit mengizinkan tema fiksi dewasa untuk pengguna dewasa, DeepSeek dan model turunan open-weight lainnya jadi favorit komunitas untuk roleplay karena kebijakan hosted-nya fleksibel untuk fiksi, sementara kebijakan Anthropic melarang konten eksplisit, menjadikan Claude pilihan yang tepat hanya untuk creative writing all-ages. Memahami kebijakan-kebijakan ini sebelum Anda merutekan trafik menyelamatkan Anda dari badai penolakan di produksi. Apa pun yang Anda bangun, itu harus menghormati ketentuan layanan setiap provider yang Anda panggil.

Komponen 4: routing model dan matriks pemilihan

Sebagian besar pesan di companion app adalah giliran santai yang pendek yang bisa ditangani sempurna oleh model budget. Sebagian kecil adalah scene emosional panjang atau set piece kreatif di mana kualitas prosa adalah produknya. Routing berdasarkan kedalaman scene memangkas biaya secara drastis tanpa disadari pengguna:

ROUTES = {
    "casual": "deepseek-v4-flash",
    "scene": "deepseek-v4-pro",
    "prose": "claude-sonnet-4-6",  # all-ages creative writing only
}

def pick_model(user_msg: str, turns_in_scene: int) -> str:
    if turns_in_scene > 6 or len(user_msg) > 400:
        return ROUTES["scene"]
    return ROUTES["casual"]

Berapa biaya sebenarnya satu monthly active user

Hitungan token sebelum peluncuran lebih baik daripada kejutan tagihan sesudahnya. Memakai budget context dari tabel memori: kira-kira 3.300 token input dan 250 token output per pesan. Pengguna companion app itu berat pemakaiannya; angka yang dilaporkan komunitas menempatkan pengguna aktif di puluhan pesan sehari, jadi asumsikan sekitar 40 pesan sehari selama 20 hari aktif, atau sekitar 800 pesan per MAU per bulan. Itu memberi 2.64 juta token input dan 0.2 juta token output per MAU per bulan. Dikalikan dengan tarif katalog:

Satu endpoint untuk setiap model di matriks

Mendaftar lima akun provider untuk menjalankan satu router adalah overhead yang nyata: lima key, lima dashboard billing, lima set rate limit. Gateway multi-model meruntuhkan itu. APIsRouter mengekspos setiap model di atas lewat satu base URL OpenAI-compatible https://api.apisrouter.com/v1, jadi snippet router-nya langsung berfungsi hanya dengan mengubah string model-nya. Billing pay-as-you-go tanpa langganan, model global berjalan 20% di bawah harga resmi dengan model China di bawah tarif resminya, dan checkout tanpa pendaftaran di /topup mengirim key ke email Anda setelah pembayaran, dengan top-up pertama menambah +100% saldo. GET /v1/models dengan key Anda mengembalikan daftar model live, yang juga berguna untuk mengisi model picker di admin UI Anda sendiri.

Tips produksi yang menghemat uang dan sakit kepala yang nyata

• Stream semuanya. Time-to-first-token adalah metrik yang dirasakan pengguna; balasan yang di-stream dalam 2 detik terasa lebih cepat dibanding balasan lengkap dalam 4 detik.
• Jaga prefix yang stabil tetap stabil. Persona dan fakta yang di-pin harus identik byte-per-byte antar request sehingga backend yang mendukung prefix caching bisa memanfaatkannya.
• Batasi max_tokens per rute. Giliran santai jarang butuh lebih dari 300 token output; model tanpa batas yang melantur menggandakan tagihan output Anda.
• Log biaya per pengguna, bukan hanya per request. Sebagian kecil pengguna berat akan mendominasi pengeluaran; Anda perlu melihat mereka untuk mendesain tier penggunaan yang adil.
• Bangun fallback ke dalam router. Jika model utama timeout atau menolak, coba lagi sekali di model sibling sebelum menampilkan error.
• Pangkas jendela bergulir berdasarkan token, bukan giliran, sehingga satu paste panjang tidak menghabiskan budget.
• Tangani penolakan dalam karakter. Petakan penolakan ke pengalihan in-story yang halus alih-alih menampilkan teks API mentah.
• Jangan simpan chat mentah lebih lama dari yang diperlukan, dan sebutkan itu di kebijakan privasi Anda. Log chat companion secara alami sensitif.

Pertanyaan umum