चीनी-भाषा ऐप बनाना: प्रॉम्प्ट, स्क्रिप्ट नियंत्रण और UTF-8

आप क्या वायरिंग कर रहे हैं

सर्विस POST /v1/chat/completions और GET /v1/models को https://api.chinesellmapi.com/v1 के तहत एक्सपोज़ करती है। प्रमाणीकरण एक बेयरर कुंजी है, और एकमात्र मॉडल आईडी uncensored है। यह एक टेक्स्ट-ओनली API है जिसमें एक ही मॉडल है, इसलिए चुनने के लिए कुछ नहीं है: आपका स्थानीयकरण कार्य पूरी तरह से प्रॉम्प्ट और इसके आसपास आपके अपने कोड में होता है।

डिज़ाइन करने से पहले जानने योग्य सीमाएँ: प्रॉम्प्ट और कंप्लीशन द्वारा साझा 100,000-टोकन की कॉन्टेक्स्ट विंडो, max_tokens का डिफ़ॉल्ट मान 2,048 और अधिकतम 32,000, 8 MB तक के अनुरोध बॉडी, और प्रति कुंजी प्रति मिनट 300 अनुरोध। स्ट्रीमिंग (stream: true) सर्वर-सेंट इवेंट्स के माध्यम से काम करती है, और OpenAI फ़ंक्शन-कॉलिंग फ़ॉर्मेट के टूल्स स्वीकार किए जाते हैं।

नए खातों को सात दिनों के लिए वैध $0.50 ट्रायल क्रेडिट मिलता है, बिना किसी भुगतान विवरण के; ईमेल और पासवर्ड के साथ रजिस्टर करें और कुंजी तुरंत प्रकट हो जाती है। ट्रायल FAQ नियमों को विस्तार से कवर करता है।

चीनी में प्रॉम्प्ट लिखें, और बताएं कि कौन सी चीनी

मिश्रित-भाषा प्रॉम्प्ट लोकलाइज्ड फीचर में विचलन का सबसे सामान्य स्रोत हैं। यदि निर्देश अंग्रेजी में हैं लेकिन सामग्री चीनी है, तो कभी-कभी उत्तर अंग्रेजी या मिश्रण में वापस आ जाते हैं। एक विश्वसनीय पैटर्न लक्ष्य भाषा में लिखा गया एक सिस्टम प्रॉम्प्ट है, जिसमें तीन बातें बताई गई हैं: भूमिका, स्क्रिप्ट, और क्षेत्रीय शब्दावली। उपयोगकर्ता द्वारा प्रदान की गई सामग्री को एक अलग संदेश में रखें ताकि उसे निर्देशों के साथ गलत न समझा जाए।

यहाँ एक सरलीकित चीनी सेटअप है। ध्यान दें कि सिस्टम प्रॉम्प्ट मॉडल को केवल सरलीकित अक्षरों में उत्तर देने और अंग्रेजी से बचने के लिए कहता है, उचित नामों को छोड़कर:

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.chinesellmapi.com/v1",
    api_key=os.environ["API_KEY"],
)

SYSTEM_SC = (
    "你是一名产品文案助手。始终使用简体中文回答，使用中国大陆常见的用词和标点，"
    "不要夹杂繁体字或英文句子，专有名词除外。"
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": SYSTEM_SC},
        {"role": "user", "content": "为一款记账应用写三条应用商店的一句话简介。"},
    ],
    max_tokens=300,
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)

दिए गए दो आदतें जल्दी फायदा देती हैं। पहला, प्रॉम्प्ट को छोटा और स्पष्ट रखें: एक भूमिका, एक आउटपुट फॉर्मेट, एक या दो प्रतिबंध। दूसरा, भाषा की आवश्यकता को सिस्टम संदेश में डालें, न कि हर यूजर टर्न में दोहराएं, ताकि बातचीत का इतिहास उसे कमजोर न करे।

सरलीकृत बनाम पारंपरिक आउटपुट का नियंत्रण

स्क्रिप्ट चयन एक उत्पाद निर्णय है जो उपयोगकर्ता लोकेल से जुड़ा है, न कि मॉडल सेटिंग। मुख्यभूमि-उन्मुख उत्पाद सरलीकृत अक्षरों की उम्मीद करते हैं; ताइवान और होंग कॉंग के दर्शक पारंपरिक अक्षरों की उम्मीद करते हैं, साथ ही अलग शब्दावली के साथ (सॉफ्टवेयर, नेटवर्क और डेटाबेस शब्द आमतौर पर उदाहरण हैं)। व्यावहारिक दृष्टिकोण आपकी लोकेल टैग को एक सिस्टम प्रॉम्प्ट से मैप करना और कोड में चयन को स्पष्ट करना है।

• zh-CN, zh-SG: सरलीकृत, मुख्यभूमि शब्दावली, आधी चौड़ाई वाले अंक, पूर्ण चौड़ाई वाले चीनी विराम चिह्न।
• zh-TW: पारंपरिक, ताइवान शब्दावली, उद्धरणों के लिए कोन ब्रैकेट आम हैं।
• zh-HK: होंग कॉन्ग शब्दावली के साथ पारंपरिक; यदि आपके उत्पाद की स्थिर शब्दावली है तो एक छोटा शब्दकोश प्रदान करें।

उसी कॉल का पारंपरिक संस्करण इस प्रकार दिखता है; केवल सिस्टम प्रॉम्प्ट बदलता है:

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.chinesellmapi.com/v1", api_key=os.environ["API_KEY"])

SYSTEM_TC = (
    "你是一名產品文案助手。請一律使用繁體中文回答，採用臺灣常用的詞彙與全形標點，"
    "例如「軟體」「網路」「資料庫」，不要混入簡體字。"
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": SYSTEM_TC},
        {"role": "user", "content": "請用兩句話說明什麼是雙重驗證。"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)

मॉडल कभी-कभी दूसरी लिपि के कुछ अक्षर लीक कर देते हैं, खासकर जब उपयोगकर्ता संदेश स्वयं दूसरी लिपि में हो। एक सस्ता पोस्ट-चेक जोड़ें और यदि यह ट्रिप होता है तो एक मजबूत निर्देश के साथ एक बार पुनः प्रयास करें। नमूना चेक से परे किसी भी चीज़ के लिए, आउटपुट को OpenCC जैसे समर्पित कन्वर्टर लाइब्रेरी से चलाएँ:

Copy# A cheap guard: flag replies that contain characters that exist only in Simplified.
# The set below is a small sample, not a full list; use a converter such as OpenCC
# for production-grade checks.
SIMPLIFIED_ONLY = set("这个们说话时间书买卖东车门开关见觉")

def looks_simplified(text: str) -> bool:
    return any(ch in SIMPLIFIED_ONLY for ch in text)

reply = "請用繁體中文回覆的範例文字"
print(looks_simplified(reply))   # False

डिस्क से वायर और वापस UTF-8

अधिकांश गड़बड़-चीनी बग मॉडल की समस्या नहीं हैं। वे पाइपलाइन में कहीं एक डिफ़ॉल्ट एन्कोडिंग से आते हैं: एक विंडोज़ कंसोल जो एक विरासत कोड पेज का उपयोग कर रहा है, एक एन्कोडिंग के बिना खोला गया CSV, एक प्रॉक्सी जो कंटेंट टाइप को रीराइट करता है। हर बाउंड्री को स्पष्ट बनाएँ।

Python में, encoding="utf-8" को open में पास करें, और यदि आप JSON स्वयं बना रहे हैं, तो ensure_ascii=False का उपयोग करें और उसके बाद .encode("utf-8")। नीचे दिया गया उदाहरण सादे requests के साथ इसे करता है, जो कॉल के कच्चे HTTP स्वरूप को भी दिखाता है:

Copyimport json
import os
import requests

# 1) Always open files as UTF-8, never rely on the platform default encoding.
with open("notes_zh.txt", "r", encoding="utf-8") as f:
    note = f.read()

payload = {
    "model": "uncensored",
    "messages": [{"role": "user", "content": "请把下面的笔记整理成三个要点：\n" + note}],
    "max_tokens": 400,
}

# 2) requests encodes json= as UTF-8 for you. If you build the body by hand,
#    keep Chinese readable and make the encoding explicit.
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")

r = requests.post(
    "https://api.chinesellmapi.com/v1/chat/completions",
    headers={
        "Authorization": "Bearer " + os.environ["API_KEY"],
        "Content-Type": "application/json; charset=utf-8",
    },
    data=body,
    timeout=60,
)
r.raise_for_status()
r.encoding = "utf-8"
print(r.json()["choices"][0]["message"]["content"])

Node में, readFile एक Buffer लौटाता है जब तक कि आप एन्कोडिंग न दें, और चीनी अक्षरों वाले टेम्पलेट स्ट्रिंग्स तब तक ठीक हैं जब तक कि स्रोत फ़ाइल को UTF-8 के रूप में सहेजा गया हो। आधिकारिक SDK आपके लिए बॉडी को सीरियलाइज़ करता है:

Copyimport { readFile } from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.chinesellmapi.com/v1",
  apiKey: process.env.API_KEY,
});

// Pass "utf8" explicitly; without it readFile returns a Buffer, not a string.
const note = await readFile("notes_zh.txt", "utf8");

const res = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: `请把下面的笔记整理成三个要点：\n${note}` }],
  max_tokens: 400,
});

console.log(res.choices[0].message.content);
console.log(res.usage);

दो और फँदास। बाइट लंबाई द्वारा स्ट्रिंग्स को ट्रंक करने से एक अक्षर आधा कट सकता है, इसलिए हमेशा कैरेक्टर द्वारा स्लाइस करें। और जब आप स्ट्रीम करते हैं, तो स्ट्रीम को UTF-8 में बढ़ते हुए डिकोड करें, क्योंकि एक मल्टी-बाइट कैरेक्टर नेटवर्क चंक में विभाजित हो सकता है; SDKs इसे संभाल लेते हैं, लेकिन हैंड-रोल्ड पार्सर अक्सर नहीं करते।

चीनी पाठ के लिए टोकन बजटिंग

चीनी में स्पेस नहीं होते, इसलिए शब्द गणना बजटिंग के लिए बेकार हैं। एक योजनात्मक मान्यता के रूप में, एक निश्चित स्थिरांक के रूप में नहीं, एक चीनी कैरेक्टर को लगभग 1 से 2 टोकन मानें, और जब आपको एक अकेला नंबर चाहिए तो 1.5 का उपयोग करें। टेक्स्ट में एम्बेडेड लैटिन शब्द और अंक प्रति शब्द करीब 1.3 टोकन के करीब होते हैं। अनुपात शब्दावली के साथ बदलता है, इसलिए प्रत्येक प्रतिक्रिया के साथ लौटे usage ऑब्जेक्ट में ही सटीक आंकड़ा है।

एक छोटा हेल्पर भेजने से पहले एक प्रॉम्प्ट का अनुमान लगाने और समय के साथ वास्तविक उपयोग के खिलाफ अनुपात को ट्यून करने में आसानी करता है:

Copyimport re

CJK = re.compile(r"[㐀-鿿＀-￯　-〿]")

def rough_tokens(text: str, per_cjk: float = 1.5, per_other_word: float = 1.3) -> int:
    """Planning estimate only. The 1.5 and 1.3 ratios are assumptions, not
    measured values; compare against resp.usage and adjust them."""
    cjk = len(CJK.findall(text))
    others = len(re.findall(r"[A-Za-z0-9_]+", CJK.sub(" ", text)))
    return round(cjk * per_cjk + others * per_other_word)

sample = "订单 A-1042 已发货，预计周三送达。"
print(rough_tokens(sample))

कार्य उदाहरण, मान्यताओं के साथ: 1.5 टोकन प्रति अक्षर पर 2,000-अक्षर का लेख लगभग 3,000 इनपुट टोकन है। एक 400-अक्षर का सारांश लगभग 600 आउटपुट टोकन है। प्रति मिलियन इनपुट टोकन $0.25 और प्रति मिलियन आउटपुट टोकन $1.00 पर, एक कॉल का इनपुट के लिए लगभग $0.00075 और आउटपुट के लिए $0.0006 खर्च होता है, कुल मिलाकर लगभग $0.00135। चूँकि कॉन्टेक्स्ट 100,000 टोकन तक सीमित है, वही मान्यता का मतलब है कि लगभग 40,000 अक्षरों का प्रॉम्प्ट एक प्रतिक्रिया के लिए जगह छोड़ता है।

जब आपको लंबे दस्तावेज़ भेजने हों, तो पैराग्राफ या शीर्षक के अनुसार चंक करें, कभी वाक्य के बीच में नहीं, और max_tokens को स्पष्ट रखें। कीमतें और सीमाएँ pricing page पर सूचीबद्ध हैं।

विंडो के भीतर मल्टी-टर्न चीनी चैट को रखना

चैट सुविधाएँ हर अनुरोध पर पूरी इतिहास फिर से भेजती हैं, इसलिए लागत और कॉन्टेक्स्ट हर टर्न के साथ बढ़ते हैं। चूँकि विंडो 100,000 टोकन की है जो प्रॉम्प्ट और पूर्णता के बीच साझा है, एक लंबी बातचीत अंततः एक 400 त्रुटि ट्रिगर करेगी यदि आप कुछ नहीं करते। त्रुटियों पर प्रतिक्रिया करने के बजाय जल्दी एक ट्रिमिंग नीति तय करें।

एक सरल पॉलिसी सिस्टम प्रॉम्प्ट को रखना है, सबसे पुराने टर्न को गिरा देना है जब तक कि अनुमानित प्रॉम्प्ट एक बजट में फिट न हो जाए, और शेष को जवाब के लिए आरक्षित रखना है। नीचे दिया गया स्केच पिछले अनुभाग से अनुमानक का पुन: उपयोग करता है:

CopyMAX_PROMPT_TOKENS = 48_000   # leave headroom under the 100,000 window for the reply

def trim_history(messages, estimate):
    # messages[0] is the system prompt and is always kept
    system, rest = messages[0], messages[1:]
    while rest and sum(estimate(m["content"]) for m in [system] + rest) > MAX_PROMPT_TOKENS:
        rest.pop(0)   # drop the oldest turn first
    return [system] + rest

उन उत्पादों के लिए जहां शुरुआती कॉन्टेक्स्ट मायने रखता है, जैसे कि एक ट्यूटिंग बॉट या सहायता सहायक, गिरे हुए टर्न को सीधे छोड़ने के बजाय एक छोटे सारांश संदेश से बदलें। मॉडल से पुराने टर्न को बातचीत की ही स्क्रिप्ट में कुछ वाक्यों में संपीड़ित करने के लिए कहें, फिर उस सारांश को सिस्टम प्रॉम्प्ट के ठीक बाद डालें। यह कभी-कभी एक अतिरिक्त कॉल खर्च करता है और पर्सोना और तथ्यों को स्थिर रखता है।

साथ ही, चैट के लिए max_tokens को समझदारी से कैप करना न भूलें। एक मैसेजिंग UI में जवाबों को आमतौर पर कुछ सौ टोकन से अधिक की आवश्यकता नहीं होती है, और एक कसकर कैप लेटेंसी और लागत दोनों को अधिक पूर्वानुमानित बनाता है। टोकन-दर-टोकन जवाब को स्ट्रीम करने से संज्ञानात्मक गति में मदद मिलती है, खासकर चीनी पाठ के लिए जहाँ उपयोगकर्ता छोटे बर्स्ट में पढ़ते हैं।

प्री-लॉच चेकलिस्ट और अगले कदम

1. प्रत्येक लोकेल को एक सिस्टम प्रॉम्प्ट से मैप करें और मैपिंग के लिए यूनिट-टेस्ट करें।
2. फ़ाइल पढ़ने, अनुरोध बॉडी और लॉग में एन्कोडिंग को स्पष्ट रूप से सेट करें।
3. प्रति सुविधा usage को लॉग करें और इसे साप्ताहिक रूप से अपने अनुमानक से तुलना करें।
4. 402 (no_credit), 429 और 503 (upstream_busy) को अलग से हैंडल करें: टॉप-अप करें, गति कम करें, कुछ सेकंड बाद पुन: प्रयास करें।
5. 403 (content_blocked) को उस अनुरोध के लिए एक अंतिम उत्तर मानें, पुन: प्रयास के मामले के रूप में नहीं।

यदि आपके ऐप में अनुवाद पाइपलाइन्स शामिल हैं, तो translation and localization guide के साथ जारी रखें; सerialized फिक्शन और कैरेक्टर चैट के लिए, web fiction guide देखें। पूर्ण पैरामीटर संदर्भ docs में है।