बिना सेंसर AI API कॉल उदाहरण: Python, Node.js और cURL का पूर्ण कोड

इंटरफ़ेस बेसिक जानकारी और एनवायरनमेंट वेरिएबल

कुछ स्थिर पैरामीटर याद रखें, सभी उदाहरणों में इनका उपयोग होगा। Base URL है https://api.wuxianzhiapi.com/v1, मॉडल नाम uncensored है, प्रमाणीकरण हेडर Authorization: Bearer <API कुंजी> है। के दो एंडपॉइंट हैं: POST /v1/chat/completions चैट के लिए, GET /v1/models मॉडल उपलब्धता जाँचने के लिए। प्रारूप OpenAI के Chat Completions से मेल खाता है, इसलिए आधिकारिक openai SDK में केवल base_url और API कुंजी बदलें, बाकी कोड वही रहेगा।

API कुंजी /get-api-key/ पर साइन इन करने पर दिखाई देती है। केवल ईमेल और पासवर्ड से साइन इन करें। नए खाते में $0.50 का मुफ़्त ट्रायल क्रेडिट 7 दिनों के लिए होता है, बिना कार्ड बाइंडिंग के। सभी उदाहरणों में API कुंजी WUXIANZHI_API_KEY एनवायरनमेंट वेरिएबल से पढ़ी जाती है। API कुंजी को कोड रिपॉजिटरी या फ्रंटएंड पेज में न डालें। सीमाएँ: 100,000 टोकन कॉन्टेक्स्ट विंडो (प्रॉम्प्ट + आउटपुट), 8 MB से कम अनुरोध शरीर, प्रति API कुंजी 300 अनुरोध प्रति मिनट।

复制export WUXIANZHI_API_KEY="把你的密钥放这里"

# 确认连通性，应返回包含 uncensored 的模型列表
curl https://api.wuxianzhiapi.com/v1/models \
  -H "Authorization: Bearer $WUXIANZHI_API_KEY"

यदि इस चरण में 401 लौटाता है, तो API कुंजी गलत है या एनवायरनमेंट वेरिएबल लागू नहीं हुआ है। पहले इसे हल करें, फिर कोड देखें। पूर्ण पैरामीटर विवरण API दस्तावेज़ में देखें।

cURL: न्यूनतम सक्षम रिक्वेस्ट

अंततः आप जो भाषा चुनते हैं, cURL से एक बार चलाकर देखें। इससे नेटवर्क, API कुंजी और अनुरोध प्रारूप की समस्याएँ आपके कोड से अलग हो जाती हैं। नीचे max_tokens वाला एक साधारण अनुरोध है। JSON में choices[0].message.content उत्तर है, usage में इनपुट और आउटपुट टोकन संख्या है, जिस पर शुल्क लागू होता है।

复制curl https://api.wuxianzhiapi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WUXIANZHI_API_KEY" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "你是一个直来直去的写作助手。"},
      {"role": "user", "content": "用三句话描述一场暴雨前的小镇。"}
    ],
    "max_tokens": 300
  }'

JSON में चीनी अक्षरों को मैन्युअल रूप से एस्केप करने की आवश्यकता नहीं है, बशर्ते हेडर में UTF-8 JSON घोषित हो। अधिकांश टर्मिनल में सीधे पेस्ट करें। Windows PowerShell में क्वोट्स प्रोसेस करना कठिन हो सकता है, इसलिए अनुरोध शरीर को body.json में सहेजें और -d @body.json से भेजें।

Python और Node.js का पूर्ण कॉल

Python में आधिकारिक openai पैकेज (v1 और उससे ऊपर) का उपयोग करें, पहले pip install openai करें। क्लाइंट बनाते समय base_url और api_key पास करें, इसके बाद के कॉल OpenAI के साथ बिल्कुल समान होते हैं। नीचे दिया गया स्क्रिप्ट सीधे chat.py के रूप में सेव करके चलाया जा सकता है।

复制import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "你是一个直来直去的写作助手。"},
        {"role": "user", "content": "用三句话描述一场暴雨前的小镇。"},
    ],
    max_tokens=300,
)

print(resp.choices[0].message.content)
print("输入 tokens:", resp.usage.prompt_tokens, "输出 tokens:", resp.usage.completion_tokens)

Node.js में openai का npm पैकेज (v4 और उससे ऊपर) का उपयोग करें, npm install openai करें। नीचे दिया गया कोड टॉप-लेवल await का उपयोग करता है, इसलिए फ़ाइल को chat.mjs के रूप में सेव करें, या package.json में "type": "module" सेट करें।

复制import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "system", content: "你是一个直来直去的写作助手。" },
    { role: "user", content: "用三句话描述一场暴雨前的小镇。" },
  ],
  max_tokens: 300,
});

console.log(resp.choices[0].message.content);
console.log("用量:", resp.usage);

दोनों कोड संरचना समान है, केवल सिंटैक्स अलग है। यदि आपके पास पहले से OpenAI कॉल है, तो क्लाइंट इनिशियलाइज़ेशन की पंक्तियाँ बदलें और मॉडल नाम uncensored पर सेट करें। अन्य एंडपॉइंट से माइग्रेशन के लिए migration guide देखें।

स्ट्रीमिंग आउटपुट (SSE) कैसे पढ़ें

लंबे टेक्स्ट या चैट के लिए स्ट्रीमिंग का उपयोग करें। stream: true से SSE भेजा जाता है। हर लाइन data: {...} होती है और data: [DONE] पर समाप्त होती है। SDK इसे स्वचालित रूप से पार्स कर देता है।

एक महत्वपूर्ण बिंदु: स्ट्रीम के अंत में usage वाला एक अतिरिक्त चंक आता है, जिसमें choices खाली सरणी होती है। इसे एनबल करने के लिए अतिरिक्त पैरामीटर पास करने की आवश्यकता नहीं है, लेकिन chunk.choices[0] सीधे एक्सेस न करें। पहले जाँच करें कि यह खाली है या नहीं, अन्यथा स्ट्रीम समाप्त होने पर इंडेक्स आउट ऑफ बाउंड्स त्रुटि आएगी।

复制import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "写一段 200 字左右的悬疑小说开头。"}],
    max_tokens=600,
    stream=True,
)

usage = None
for chunk in stream:
    if chunk.usage:            # 最后一块：用量统计
        usage = chunk.usage
    if not chunk.choices:      # 用量块没有 choices
        continue
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

print()
if usage:
    print("输入", usage.prompt_tokens, "输出", usage.completion_tokens)

复制import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "写一段 200 字左右的悬疑小说开头。" }],
  max_tokens: 600,
  stream: true,
});

let usage = null;
for await (const chunk of stream) {
  if (chunk.usage) usage = chunk.usage;
  const delta = chunk.choices?.[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
console.log("\n用量:", usage);

मूल SSE डेटा देखने के लिए cURL में -N का उपयोग करें। इससे बफरिंग बंद हो जाती है और डेटा तुरंत प्रिंट होता है।

复制curl -N https://api.wuxianzhiapi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WUXIANZHI_API_KEY" \
  -d '{"model":"uncensored","stream":true,"max_tokens":100,
       "messages":[{"role":"user","content":"数到五。"}]}'

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

फ़ंक्शन कॉलिंग: tools और टूल रिजल्ट भेजना

फ़ंक्शन कॉलिंग में tools से फ़ंक्शन परिभाषाएं दें। मॉडल message.tool_calls में फ़ंक्शन नाम और पैरामीटर देता है। आप फ़ंक्शन चलाकर परिणाम role: "tool" के साथ वापस भेजें।

tool_choice का डिफ़ॉल्ट मान "auto" है, जिससे मॉडल स्वयं निर्णय लेता है; जब किसी फ़ंक्शन को बलपूर्वक कॉल करना हो, तो {"type": "function", "function": {"name": "get_weather"}} भेजें; "none" भेजने पर कॉलिंग अक्षम हो जाती है। नीचे दिए गए उदाहरण में पूरा चक्र दिखाया गया है: पहले अनुरोध में tool_calls प्राप्त करें, स्थानीय फ़ंक्शन निष्पादित करें और दूसरे अनुरोध में टूल के परिणाम शामिल करें।

复制import json, os
from openai import OpenAI

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

def get_weather(city: str) -> dict:
    # 这里用假数据代替真实的天气接口
    return {"city": city, "temp_c": 18, "condition": "多云"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "查询指定城市的当前天气",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string", "description": "城市名"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "杭州现在天气怎么样？"}]

first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto", max_tokens=500
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)  # 必须把带 tool_calls 的 assistant 消息原样放回历史
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = get_weather(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result, ensure_ascii=False),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools, max_tokens=500
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

तीन सामान्य त्रुटियाँ: पहली, assistant के tool_calls संदेश को इतिहास में वापस रखना भूल जाना और सीधे tool संदेश जोड़ देना, जिससे अनुरोध का प्रारूप अवैध हो जाता है; दूसरी, tool_call_id मेल नहीं खाता; तीसरी, मॉडल द्वारा दिए गए पैरामीटर स्ट्रिंग होते हैं, जिन्हें पहले json.loads करना होता है, और पार्स विफलता के लिए उचित व्यवस्था करनी चाहिए, मॉडल के आउटपुट को सीधे कमांड या SQL में न जोड़ें। Node.js में प्रक्रिया बिल्कुल समान है, नीचे समतुल्य कोड दिया गया है।

复制import OpenAI from "openai";

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

const getWeather = (city) => ({ city, temp_c: 18, condition: "多云" });

const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "查询指定城市的当前天气",
    parameters: {
      type: "object",
      properties: { city: { type: "string", description: "城市名" } },
      required: ["city"],
    },
  },
}];

const messages = [{ role: "user", content: "杭州现在天气怎么样？" }];

const first = await client.chat.completions.create({
  model: "uncensored", messages, tools, tool_choice: "auto", max_tokens: 500,
});
const msg = first.choices[0].message;

if (msg.tool_calls?.length) {
  messages.push(msg);
  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    messages.push({
      role: "tool",
      tool_call_id: call.id,
      content: JSON.stringify(getWeather(args.city)),
    });
  }
  const final = await client.chat.completions.create({
    model: "uncensored", messages, tools, max_tokens: 500,
  });
  console.log(final.choices[0].message.content);
} else {
  console.log(msg.content);
}

एरर हैंडलिंग और रीट्राई: 429, 503 पर बैकऑफ़

त्रुटि प्रतिक्रियाएँ एक समान JSON होती हैं: {"error":{"code":...,"message":...}}। कोड में केवल दो प्रकार की त्रुटियाँ ही पुनः प्रयास (retry) के योग्य हैं: 429 (प्रति मिनट 300 अनुरोध की सीमा से अधिक) और 503 (upstream_busy, मॉडल अस्थायी रूप से व्यस्त है, कुछ सेकंड में पुनः प्रयास करें)। नेटवर्क स्तर का कनेक्शन टाइमआउट भी पुनः प्रयास के लिए उपयुक्त है। अन्य त्रुटियों पर पुनः प्रयास करना व्यर्थ है: 400 का अर्थ है अनुरोध में समस्या है (जैसे प्रॉम्प्ट और max_tokens का योग 100k से अधिक हो गया), 401 का अर्थ है कुंजी अमान्य है, 402 no_credit का अर्थ है शेष राशि खत्म हो गई है या ट्रायल समाप्त हो गया है, 403 content_blocked का अर्थ है सामग्री ब्लॉक हो गई है, इसलिए सौ बार भेजने पर भी परिणाम वही आएगा।

रिट्री स्ट्रैटेजी में एक्सपोनेंशियल बैकऑफ और रैंडम ज़िटर का उपयोग होता है: 1st प्रयास में लगभग 1 सेकंड, 2nd में लगभग 2 सेकंड, 3rd में लगभग 4 सेकंड, एक ऊपरी सीमा और अधिकतम प्रयासों की संख्या निर्धारित करें ताकि समानांतर अनुरोधों वाले कई टास्क एक ही समय में रिट्राई न करें, जिससे रेट लिमिट और कठोर हो जाए। आधिकारिक SDK में max_retries पहले से मौजूद है, जो डिफ़ॉल्ट रूप से 429 और 5xx के लिए कुछ रिट्राई करता है; सरल मामलों में इसे बढ़ाएं; लॉगिंग, सर्किट ब्रेकर या कस्टम वेट के लिए स्वयं लूप लिखें।

复制import os, random, time
import openai
from openai import OpenAI

# max_retries=0：关闭 SDK 自带重试，完全由下面的函数控制
client = OpenAI(
    base_url="https://api.wuxianzhiapi.com/v1",
    api_key=os.environ["WUXIANZHI_API_KEY"],
    max_retries=0,
    timeout=60,
)

def chat_with_retry(messages, max_attempts=5, **kwargs):
    for attempt in range(max_attempts):
        try:
            return client.chat.completions.create(
                model="uncensored", messages=messages, **kwargs
            )
        except (openai.RateLimitError, openai.InternalServerError,
                openai.APIConnectionError, openai.APITimeoutError) as e:
            if attempt == max_attempts - 1:
                raise
            wait = min(30, 2 ** attempt) + random.uniform(0, 1)
            print(f"{type(e).__name__}，{wait:.1f} 秒后重试（第 {attempt + 1} 次）")
            time.sleep(wait)
        except openai.APIStatusError as e:
            # 400 / 401 / 402 / 403 / 404：重试无效，直接交给上层处理
            print("不可重试:", e.status_code, e.response.text)
            raise

resp = chat_with_retry([{"role": "user", "content": "你好"}], max_tokens=100)
print(resp.choices[0].message.content)

Node.js में भी आप सीधे maxRetries को बढ़ा सकते हैं; SDK 429 और 5xx त्रुटियों को बैकऑफ़ रणनीति के अनुसार संभाल लेगा। त्रुटियों को अलग करने के लिए error.status का उपयोग करें।

复制import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.wuxianzhiapi.com/v1",
  apiKey: process.env.WUXIANZHI_API_KEY,
  maxRetries: 5,
  timeout: 60_000,
});

try {
  const resp = await client.chat.completions.create({
    model: "uncensored",
    messages: [{ role: "user", content: "你好" }],
    max_tokens: 100,
  });
  console.log(resp.choices[0].message.content);
} catch (err) {
  if (err instanceof OpenAI.APIError) {
    if (err.status === 402) console.error("余额不足，请充值后再试");
    else if (err.status === 403) console.error("内容被拦截:", err.message);
    else console.error("请求失败:", err.status, err.message);
  } else {
    throw err;
  }
}

एक और बात: स्ट्रीमिंग अनुरोध के बीच में कनेक्शन टूटने पर प्राप्त सामग्री को स्वयं सहेजें। रिकॉन्फ़ाइगरेशन से शुरू से जनरेट होगा, इसलिए लंबे टेक्स्ट के लिए अनुरोध को भागों में बाँटें, एक बार में पूरा न भेजें।

max_tokens से लागत और लंबाई नियंत्रित करें

शुल्क नियम स्पष्ट हैं: इनपुट $0.25 / 1M टोकन, आउटपुट $1.00 / 1M टोकन। प्रीपेड क्रेडिट, मासिक शुल्क नहीं। बैलेंस कभी नहीं खत्म होता। आउटपुट कीमत इनपुट से 4 गुना अधिक है, इसलिए आउटपुट पर बचत करें। max_tokens डिफ़ॉल्ट 2048 है, अधिकतम 32,000। यदि केवल कुछ वाक्य चाहिए, तो 200 या 300 पर सेट करें।

एक हिसाब लगाएं: एक अनुरोध में max_tokens को 1,000 पर सेट करने पर सबसे खराब स्थिति में आउटपुट लागत $0.001 है; इसे 32,000 की ऊपरी सीमा पर सेट करने पर सबसे खराब स्थिति में $0.016 है। ट्रायल क्रेडिट $0.50 लगभग 50 लाख आउटपुट टोकन के बराबर है, या 20 लाख इनपुट टोकन, जो इस लेख के सभी उदाहरणों को कई बार चलाने के लिए पर्याप्त है। ध्यान दें कि प्रॉम्प्ट और max_tokens का योग 100,000 से अधिक नहीं होना चाहिए, अन्यथा 400 लौटाया जाएगा, इसलिए जब इनपुट लंबा हो तो सिंक रूप से आउटपुट सीमा कम करें। अधिक विस्तृत मूल्य विवरण मूल्य पृष्ठ पर उपलब्ध है।

एक अन्य विवरण: यदि प्रतिक्रिया ट्रंकेट हो जाती है, तो प्रतिक्रिया में finish_reason "length" होगा, जिसका अर्थ है कि max_tokens पर्याप्त नहीं था, न कि मॉडल ने लिखना पूरा कर लिया था। लंबे लेख लिखते समय इस फ़ील्ड की जाँच करें और निर्णय लें कि आगे लिखना है या नहीं।

मल्टी-टर्न चैट: खुद कॉन्टेक्स्ट बनाए रखें

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

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

复制import os
from openai import OpenAI

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

class Chat:
    def __init__(self, system: str, keep_last: int = 20):
        self.system = {"role": "system", "content": system}
        self.history = []          # 只存 user / assistant 消息
        self.keep_last = keep_last

    def say(self, text: str, max_tokens: int = 500) -> str:
        self.history.append({"role": "user", "content": text})
        recent = self.history[-self.keep_last:]
        resp = client.chat.completions.create(
            model="uncensored",
            messages=[self.system] + recent,
            max_tokens=max_tokens,
        )
        reply = resp.choices[0].message.content
        self.history.append({"role": "assistant", "content": reply})
        return reply

bot = Chat("你是一位说话简短的旅行顾问。")
print(bot.say("我想去云南玩五天，有什么建议？"))
print(bot.say("刚才说的第二个地方，适合带老人吗？"))  # 能接上上一轮

संदेशों की संख्या के आधार पर काटना पर्याप्त है, लेकिन यह सटीक नहीं है क्योंकि प्रत्येक संदेश की लंबाई बहुत भिन्न होती है। यदि आपको कठोर नियंत्रण की आवश्यकता है, तो आप response में usage.prompt_tokens को वास्तविक खपत के संदर्भ के रूप में उपयोग कर सकते हैं: जैसे ही यह 50,000 के करीब पहुंचे, इतिहास को संक्षिप्त करें। यदि आप बातचीत को दीर्घकालिक उत्पाद बनाना चाहते हैं, तो उपयोग के मामले में संदर्भ डिज़ाइन के उदाहरण देखें।