Paano gumawa ng character AI app: architecture, code, at cost math

Mabilisang sagot: ang four-component na architecture

Hindi mo kailangang mag-train o mag-fine-tune ng model. Ang bawat seryosong companion app sa merkado ngayon, kasama ang mga naglilingkod sa milyun-milyong user, ay isang manipis na orchestration layer sa ibabaw ng hosted LLM API. Ang character ay nasa prompt at database, hindi sa weights. Ang natitirang bahagi ng gabay na ito ay bumubuo ng bawat component gamit ang runnable code laban sa standard na OpenAI-compatible endpoint, pagkatapos ay dinadaanan ang token math para malaman mo kung magkano talaga ang gastos ng isang monthly active user bago ka mag-launch.

• Persona prompt: structured system prompt (500 hanggang 1,000 token) na tumutukoy kung sino ang character at paano ito magsalita.
• Memory: rolling window ng kamakailang mga turn kasama ang paminsan-minsang ni-refresh na summary, para nabubuhay ang mga usapan lampas sa context limit.
• Moderation: age gate, input classifier, at content policy na tumutugma sa model na iyong niruruta.
• Routing: maliit na function na pumipili ng murang model para sa casual chat at mas malakas na model para sa mahahabang eksena.

Component 1: ang persona prompt

Ang persona prompt ang produkto. Ito ay system message na kasama sa bawat request at karaniwang may limang bahagi: identity (pangalan, edad, backstory), personality traits, speech style na may dalawa o tatlong halimbawang linya, hard behavioral rules (huwag kailanman lumabas sa character, panatilihin ang tugon sa loob ng length cap), at ang kasalukuyang scenario. Panatilihin ito sa pagitan ng 500 at 1,000 token. Ang mas maiikling persona ay naliligaw; ang mas mahahabang persona ay nakakain ng input budget sa bawat mensahe at bihirang mapabuti ang adherence. Iimbak ang mga persona bilang rows sa iyong database para makagawa at maka-edit ang mga user ng character, na siyang core loop ng mga produktong estilo ng Character.AI. Narito ang isang kumpletong request. Gumagana ang parehong hugis sa anumang OpenAI-compatible backend; ang halimbawang ito ay gumagamit ng multi-model gateway endpoint para makapagpalit ka ng model sa pamamagitan lamang ng pagbabago ng isang 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
  }'

Component 2: memory na nananatili sa mahahabang usapan

Mahaba ang tumatakbong session ng companion app. Ang three-layer na memory stack ay nagpapanatiling magkakaugnay ang context nang hindi ipinapadala ang buong history sa bawat pagkakataon: Ang Layer 1 ay ang rolling window: ang huling 10 hanggang 14 raw na turn, ipinapadala nang verbatim. Ang Layer 2 ay ang running summary: bawat 20 turn man lang, kinokompress ng isang murang model ang mga lumang mensahe sa isang paragraph na sumusubaybay sa mga pangalan, relationship state, at bukas na plot threads. Ang Layer 3 ay ang pinned facts: matibay na detalye ng user (pangalan, kagustuhan, mga nakaraang pangyayaring dapat alalahanin ng character) na hinango papunta sa iyong database at itinuturok bilang maikling system message. Ito ang buong implementasyon sa Python gamit ang official OpenAI SDK:

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

Component 3: moderation at content policy

May tatlong natatanging trabaho ang moderation sa isang companion app, at ang paghahalo sa mga ito ang pinakakaraniwang pagkakamali sa launch. Una, i-gate ang audience mo. Kung pinapayagan ng app mo ang mature fictional themes, ilagay ang mga ito sa likod ng adult age gate at panatilihin ang hiwalay na all-ages default. Sinusuri ito ng App Store at Play Store review, at pinapansin din ito ng mga payment processor. Ikalawa, i-screen ang mga input. Magpatakbo ng murang classifier pass sa mga mensahe ng user bago ito umabot sa character model, na hinaharangan ang mga kategoryang hindi pinapayagan ng anumang provider: content na may kinalaman sa mga minor, kapani-paniwalang real-world harm, at illegal instructions. Ang iisang tawag sa deepseek-v4-flash na may yes/no rubric ay nagkakahalaga ng bahagi ng isang cent at nagdaragdag ng wala pang isang segundong latency. Ikatlo, itugma ang content policy sa model. Nagkakaiba ang mga provider sa fiction: malinaw na pinapayagan ng published policy ng xAI ang mature fictional themes para sa mga adult user, ang DeepSeek at iba pang open-weight-derived na model ay paborito ng komunidad para sa roleplay dahil flexible ang hosted policy nila para sa fiction, samantalang ipinagbabawal ng policy ng Anthropic ang explicit content, kaya tamang pili lamang ang Claude para sa all-ages creative writing. Ang pag-unawa sa mga policy na ito bago mag-ruta ng traffic ay nagliligtas sa iyo mula sa refusal storms sa production. Anuman ang itayo mo, dapat itong igalang ang terms of service ng bawat provider na tinatawagan mo.

Component 4: model routing at ang selection matrix

Karamihan sa mensahe sa isang companion app ay maiikling casual turn na kayang-kaya ng isang budget model. Kaunti lang ang mahahabang emosyonal na eksena o creative set piece kung saan ang kalidad ng prose ang produkto. Ang routing base sa lalim ng eksena ay malaki ang naiiipon sa gastos nang hindi napapansin ng mga user:

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"]

Ano talaga ang gastos ng isang monthly active user

Mas mabuti ang token math bago mag-launch kaysa sa sorpresang billing pagkatapos. Gamit ang context budget mula sa memory table: humigit-kumulang 3,300 input token at 250 output token bawat mensahe. Mabigat ang mga user ng companion app; ang inireport ng komunidad na figures ay naglalagay sa mga engaged user sa dose-dosenang mensahe kada araw, kaya ipagpalagay ang humigit-kumulang 40 mensahe kada araw sa loob ng 20 active na araw, o humigit-kumulang 800 mensahe bawat MAU kada buwan. Ibinibigay nito ang 2.64M input token at 0.2M output token bawat MAU kada buwan. Pagpaparamihin sa mga rate sa katalogo:

Isang endpoint para sa bawat model sa matrix

Ang pag-sign up sa limang provider account para patakbuhin ang isang router ay tunay na overhead: limang key, limang billing dashboard, limang set ng rate limit. Pinapaikli nito ng multi-model gateway. Inilalantad ng APIsRouter ang bawat model sa itaas sa pamamagitan ng iisang OpenAI-compatible na base URL https://api.apisrouter.com/v1, kaya gumagana ang router snippet nang as-is sa pamamagitan lamang ng pagpapalit ng model string. Ang billing ay pay-as-you-go nang walang subscription, ang mga global model ay pinapatakbo sa 20% mas mababa sa opisyal na presyo habang ang mga Chinese model ay mas mababa sa opisyal na rate, at ang no-signup checkout sa /topup ay nagpapadala ng key sa iyong email pagkatapos magbayad, na ang unang top-up ay nagdaragdag ng +100% na balanse. Ibinabalik ng GET /v1/models gamit ang iyong key ang live na listahan ng model, na kapaki-pakinabang din para punuin ang isang model picker sa sarili mong admin UI.

Mga production tip na nakakatipid ng tunay na pera at sakit ng ulo

• I-stream ang lahat. Ang time-to-first-token ang metric na nararamdaman ng mga user; ang streamed na tugon sa 2 segundo ay pakiramdam mas mabilis kaysa sa kumpletong tugon sa 4.
• Panatilihing stable ang stable prefix. Dapat byte-identical ang persona at pinned facts sa lahat ng request para magamit ito ng mga backend na sumusuporta sa prefix caching.
• I-cap ang max_tokens bawat route. Bihirang kailangan ng casual na turn ng higit sa 300 output token; dinodoble ng uncapped na model na naliligaw ang iyong output bill.
• I-log ang gastos bawat user, hindi lang bawat request. Isang maliit na bahagi ng mabibigat na user ang mangingibabaw sa gastos; kailangan mong makita sila para makadisenyo ng fair na usage tiers.
• Magbuo ng fallback sa router. Kung mag-time-out o tumanggi ang primary model, mag-retry nang isang beses sa isang sibling model bago ipakita ang error.
• I-trim ang rolling window base sa token, hindi sa turn, para hindi masira ng isang mahabang paste ang budget.
• Hawakan ang mga refusal habang nasa character pa rin. I-map ang refusal sa isang magandang in-story deflection sa halip na ipakita ang raw API text.
• Huwag mag-imbak ng raw na chat nang mas matagal kaysa sa kailangan, at sabihin ito sa iyong privacy policy. Likas na sensitibo ang mga log ng companion chat.

Mga madalas itanong