HI ▾
Base URL https://api.uncensoredaiapis.com/v1Model uncensored
API कुंजी पाएँ
Uncensored AIकोड उदाहरण

Uncensored AI API कोड उदाहरण Python, Node.js और cURL में

यह पृष्ठ बिना सेंसर AI API के लिए कॉपी-पेस्ट कोड एकत्र करता है, जो OpenAI चैट पूर्णता प्रारूप का पालन करता है। आपको Python, Node.js और cURL में पहली कॉल, SDK और कच्चे fetch के साथ स्ट्रीमिंग, फ़ंक्शन कॉलिंग, 429 और 503 के लिए पुनः प्रयास तर्क, मल्टी-टर्न स्थिति, और max_tokens के साथ लागत नियंत्रण मिलेगा।

Uncensored AI API कोड उदाहरण Python, Node.js और cURL में

अपडेट किया गया

मुख्य बिंदु

  • base_url को https://api.uncensoredaiapis.com/v1 पर सेट करके आधिकारिक openai SDK का उपयोग करें और मॉडल "uncensored" का उपयोग करें; किसी कस्टम क्लाइंट की आवश्यकता नहीं है।
  • स्ट्रीमिंग SSE चंक लौटाता है, और एक अंतिम उपयोग चंक स्वचालित रूप से खाली choices सूची के साथ आता है।
  • केवल 429 और 503 (upstream_busy) पर पुनः प्रयास करें; 400, 401, 402 और 403 में सुधार की आवश्यकता है, पुनः प्रयास नहीं।
  • API स्टेटलेस है: प्रत्येक टर्न पर इतिहास पुनः भेजें, और max_tokens (वैकल्पिक; यदि सेट नहीं है, तो प्रतिक्रिया विंडो के अंत तक चल सकती है) के साथ आउटपुट को सीमित करें।

पहला कॉल: Python, Node.js और cURL

उदाहरण https://api.uncensoredaiapis.com/v1, मॉडल uncensored, और POST /v1/chat/completions या GET /v1/models का उपयोग करते हैं। अपनी वर्तमान कुंजी Authorization: Bearer <key> हेडर में भेजें। यदि आवश्यक हो, तो एक खाता बनाएं, योग्य ट्रायल क्रेडिट का अनुरोध करें और अनुरोध चलाने से पहले यह जांचें कि प्रदर्शित बैलेंस तैयार है या नहीं।

उदाहरण API_KEY नामक पर्यावरण चर से कुंजी पढ़ते हैं। इसे अपने शेल में एक बार निर्यात करें और किसी भी स्निपेट को संपादित करने की आवश्यकता नहीं होगी। कुंजी को स्रोत कोड में कभी न चिपकाएं या ब्राउज़र JavaScript में न भेजें; API को अपने बैकएंड से कॉल करें।

export API_KEY="paste-your-key-here"

Python में, आधिकारिक openai पैकेज का उपयोग करें (v1 या उससे नया)। स्टॉक OpenAI सेटअप से केवल base_url और मॉडल नाम में ही अंतर है।

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a two-line villain monologue."}],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage)

Node.js, ES मॉड्यूल के रूप में openai npm पैकेज (v4 या नया) का उपयोग करके।

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write a two-line villain monologue." }],
  max_tokens: 200,
});
console.log(resp.choices[0].message.content);
console.log(resp.usage);

और सादा cURL, जो यह जांचने का सबसे तेज़ तरीका है कि एक कुंजी काम करती है या नहीं:

curl https://api.uncensoredaiapis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Write a two-line villain monologue."}],
    "max_tokens": 200
  }'

प्रतिक्रिया में सामान्य OpenAI संरचना होती है: पाठ के लिए choices[0].message.content और प्रॉम्प्ट व पूर्णता टोकन गणना वाले usage ऑब्जेक्ट, जिसे आप प्रति-टोकन मूल्यों से गुणा करके खर्च ट्रैक कर सकते हैं। पूर्ण पैरामीटर सूची के लिए docs देखें।

SDK के साथ स्ट्रीमिंग (SSE)

stream: true सेट करें और API एक JSON बॉडी के बजाय सर्वर-सेंट इवेंट्स लौटाता है। दोनों आधिकारिक SDKs इसे एक इटरेटर में बदल देते हैं, इसलिए आपका कोड चंक के ऊपर लूप करता है और प्रत्येक delta प्रिंट करता है। टोकन usage ले जाने वाला अंतिम चंक स्वचालित रूप से जोड़ा जाता है; आपको इसे अनुरोध करने की आवश्यकता नहीं है। उस चंक में एक खाली choices सूची होती है, इसलिए इसे पढ़ने से पहले इंडेक्स की जाँच करें।

import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Describe a rainy harbor town in 120 words."}],
    max_tokens=300,
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n\nusage:", chunk.usage)

Node.js संस्करण for await का उपयोग करता है:

import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Describe a rainy harbor town in 120 words." }],
  max_tokens: 300,
  stream: true,
});

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

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

सादे fetch के साथ स्ट्रीमिंग

यदि आप SDK पर निर्भर नहीं रहना चाहते, उदाहरण के लिए एक एज फंक्शन या छोटे स्क्रिप्ट में, तो आप स्ट्रीम स्वयं पढ़ सकते हैं। वायर फॉर्मेट साधारण SSE है: प्रत्येक इवेंट data: से शुरू होने वाली एक लाइन है जिसके बाद एक JSON चंक आता है, और इवेंट खाली लाइनों से अलग होते हैं। नेटवर्क चंक इवेंट सीमाओं से मेल नहीं खाते, इसलिए आपको नई लाइनों पर बफर और विभाजित करना होगा। नीचे दिया गया उदाहरण Node 18 या नए संस्करण पर चलता है (इसे stream.mjs के रूप में सहेजें) और मानक fetch व ReadableStream वाले किसी भी रनटाइम में भी काम करता है।

const res = await fetch("https://api.uncensoredaiapis.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "uncensored",
    messages: [{ role: "user", content: "Tell a 100-word ghost story." }],
    max_tokens: 250,
    stream: true,
  }),
});

if (!res.ok) {
  throw new Error(`HTTP ${res.status}: ${await res.text()}`);
}

const decoder = new TextDecoder();
let buffer = "";

for await (const bytes of res.body) {
  buffer += decoder.decode(bytes, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop(); // keep the incomplete tail for the next round

  for (const line of lines) {
    if (!line.startsWith("data:")) continue;
    const data = line.slice(5).trim();
    if (data === "[DONE]") continue;
    const chunk = JSON.parse(data);
    const text = chunk.choices?.[0]?.delta?.content;
    if (text) process.stdout.write(text);
    if (chunk.usage) console.log("\n\nusage:", chunk.usage);
  }
}

पढ़ना शुरू करने से पहले res.ok की जाँच करें। 401, 402 या 403 जैसे त्रुटियाँ सामान्य JSON बॉडी के रूप में error ऑब्जेक्ट के साथ आती हैं, इवेंट स्ट्रीम के रूप में नहीं, इसलिए उन्हें SSE के रूप में पार्स करने पर चुपचाप कुछ भी नहीं मिलेगा। ब्राउज़र में आप res.body.getReader() के साथ उसी तर्क का उपयोग कर सकते हैं, लेकिन याद रखें कि ब्राउज़र को आपके अपने बैकएंड को कॉल करना चाहिए, न कि सीक्रेट कुंजी के साथ सीधे इस API को कॉल करना चाहिए।

टूल्स और tool_choice के साथ फ़ंक्शन कॉलिंग

टूल कॉलिंग OpenAI फॉर्मेट का उपयोग करती है। आप tools में फंक्शन वर्णित करते हैं, मॉडल जब एक चलाव चाहता है तो टेक्स्ट के बजाय tool_calls के साथ जवाब देता है, आप फंक्शन स्वयं चलाते हैं, और परिणाम को role: "tool" और मिलते-जुलते tool_call_id के साथ एक संदेश के रूप में वापस भेजते हैं। एक दूसरा अनुरोध फिर अंतिम प्राकृतिक-भाषा उत्तर लौटाता है। tool_choice व्यवहार को नियंत्रित करता है: "auto" मॉडल को निर्णय लेने देता है, "none" टूल्स को मना करता है, और {"type": "function", "function": {"name": "get_order_status"}} जैसे ऑब्जेक्ट उस फंक्शन को मजबूर करता है।

import json
import os
from openai import OpenAI

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

def get_order_status(order_id: str) -> dict:
    # Replace with a real lookup.
    return {"order_id": order_id, "status": "shipped", "eta_days": 2}

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the shipping status of an order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]

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)  # keep the assistant turn that contains tool_calls
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = get_order_status(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    final = client.chat.completions.create(
        model="uncensored",
        messages=messages,
        tools=tools,
        max_tokens=500,
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

Node.js में वही लूप:

import OpenAI from "openai";

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

const getOrderStatus = ({ order_id }) => ({ order_id, status: "shipped", eta_days: 2 });

const tools = [{
  type: "function",
  function: {
    name: "get_order_status",
    description: "Look up the shipping status of an order by its id.",
    parameters: {
      type: "object",
      properties: { order_id: { type: "string" } },
      required: ["order_id"],
    },
  },
}];

const messages = [{ role: "user", content: "Where is order A-1042?" }];

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 result = getOrderStatus(JSON.parse(call.function.arguments));
    messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify(result) });
  }
  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);
}

दो व्यावहारिक नोट्स। पहला, arguments एक भाषा मॉडल द्वारा उत्पादित JSON स्ट्रिंग है, इसलिए उत्पादन में हमेशा json.loads को त्रुटि हैंडलिंग में लपेटें और डेटाबेस को छूने से पहले फ़ील्ड की वैलिडेशन करें। दूसरा, टूल परिभाषाएँ हर अनुरोध पर इनपुट टोकन के रूप में गिनी जाती हैं, इसलिए विवरण छोटा रखें और केवल वर्तमान चरण से संबंधित टूल भेजें।

429 और 503 पर बैकऑफ़ के साथ पुनः प्रयास

दो त्रुटियाँ पुनः प्रयास करने योग्य हैं। एक 429 का अर्थ है कि आपने अपनी कुंजी के लिए प्रति मिनट 300 अनुरोध की सीमा पार कर ली है। 503 जिसका कोड upstream_busy है, इसका अर्थ है कि सेवा क्षणिक रूप से संतृप्त है; कुछ सेकंड प्रतीक्षा करना ही उचित प्रतिक्रिया है। 400 (अनुरोध ठीक करें), 401 (कुंजी ठीक करें), 402 no_credit (बैलेंस टॉप-अप करें), या 403 content_blocked (अनुरोध फिर से ब्लॉक कर दिया जाएगा) के लिए पुनः प्रयास न करें। त्रुटियों का एक ही JSON आकार होता है, {"error":{"code":...,"message":...}}, इसलिए आप कोड को सीधे लॉग कर सकते हैं।

OpenAI SDKs कनेक्शन त्रुटियों, 429 और 5xx को डिफ़ॉल्ट रूप से कुछ बार पुनः प्रयास करते हैं, और आप max_retries के साथ इसे बढ़ा सकते हैं। यदि आप विलंबता पर नियंत्रण चाहते हैं, तो इनबिल्ट पुनः प्रयास को अक्षम करें और कॉल को स्वयं लिपटें, ज़िटर के साथ एक्सपोनेंशियल बैकऑफ़ का उपयोग करके ताकि समानांतर वर्कर लॉकस्टेप में पुनः प्रयास न करें।

import os
import random
import time
from openai import OpenAI, APIStatusError, APIConnectionError

client = OpenAI(
    base_url="https://api.uncensoredaiapis.com/v1",
    api_key=os.environ["API_KEY"],
    max_retries=0,  # we handle retries ourselves
)

RETRYABLE = {429, 503}

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 APIStatusError as e:
            if e.status_code not in RETRYABLE or attempt == max_attempts - 1:
                raise
        except APIConnectionError:
            if attempt == max_attempts - 1:
                raise
        delay = min(30, 2 ** attempt) + random.uniform(0, 1)
        time.sleep(delay)

resp = chat_with_retry(
    [{"role": "user", "content": "Give me three names for a tavern."}],
    max_tokens=100,
)
print(resp.choices[0].message.content)

Node.js में कच्चे fetch के साथ समतुल्य:

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function chatWithRetry(body, maxAttempts = 5) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const res = await fetch("https://api.uncensoredaiapis.com/v1/chat/completions", {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ model: "uncensored", ...body }),
    });

    if (res.ok) return res.json();

    const retryable = res.status === 429 || res.status === 503;
    if (!retryable || attempt === maxAttempts - 1) {
      throw new Error(`HTTP ${res.status}: ${await res.text()}`);
    }
    const delay = Math.min(30000, 2 ** attempt * 1000) + Math.random() * 1000;
    await sleep(delay);
  }
}

const data = await chatWithRetry({
  messages: [{ role: "user", content: "Give me three names for a tavern." }],
  max_tokens: 100,
});
console.log(data.choices[0].message.content);

यदि आप नियमित रूप से 429 पर पहुँचते हैं, तो बेहतर समाधान आमतौर पर एक छोटा कंकरेंसी कैप (पाँच से दस वर्कर्स के साथ एक सेमाफोर या कतार) है, न कि लंबी नींद। प्रति मिनट 300 अनुरोधों पर आप प्रति सेकंड पाँच अनुरोधों को बनाए रख सकते हैं, जो अधिकांश ऐप्स के लिए पर्याप्त है।

बहु-चरणीय संवाद स्थिति

API स्टेटलेस है। यह पिछले अनुरोधों को याद नहीं रखता है, इसलिए हर कॉल में उस इतिहास को शामिल करना चाहिए जिसे मॉडल को देखना है। संदेशों की एक सूची रखें, user turn को जोड़ें, API को कॉल करें, assistant reply को जोड़ें, और दोहराएँ। सूचकांक 0 पर एक सिस्टम संदेश पर्सोना या निर्देशों को रखता है और हर बार भेजा जाता है।

import os
from openai import OpenAI

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

messages = [
    {"role": "system", "content": "You are a dry-witted ship's AI. Keep replies under 80 words."}
]

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

print(say("We just lost the main engine. Options?"))
print(say("Which of those is the least risky?"))

चूँकि पूरा इतिहास फिर से भेजा जाता है, इनपुट लागत हर टर्न के साथ बढ़ती है। कॉन्टेक्स्ट विंडो 100,000 टोकन की है और प्रॉम्प्ट और कम्पलीशन दोनों को कवर करती है, इसलिए एक बहुत लंबे सत्र में प्रॉम्प्ट के सीमा से अधिक होने पर 400 त्रुटि लौटेगी, जबकि prompt + max_tokens के सीमा से अधिक होने पर उत्तर बस विंडो के अंत पर रुक जाएगा। सामान्य रणनीतियाँ पुराने user और assistant पेयर्स को हटाना हैं जबकि सिस्टम संदेश को हमेशा बनाए रखना है, या मॉडल से पुराने टर्न को एक छोटे संदेश में सारांशित करने के लिए कहना है और उन्हें बदलना है। इतिहास को अपने डेटाबेस में कनवर्सेशन id द्वारा कुंजीबद्ध करके स्टोर करें ताकि रीस्टार्ट से थ्रेड न खोए। वास्तविक लागत अनुमानों के साथ लंबे सत्रों के उदाहरणों के लिए, use cases page देखें।

max_tokens के साथ लागत नियंत्रण

मूल्य निर्धारण $0.15 प्रति मिलियन इनपुट टोकन और $0.50 प्रति मिलियन आउटपुट टोकन है, जो प्रीपेड बैलेंस से बिल किया जाता है। आउटपुट इनपुट से लगभग 3.3 गुना महंगा है, और max_tokens एकल अनुरोध के लिए आउटपुट पर एक वैकल्पिक कैप है। यदि आप इसे सेट नहीं करते हैं, तो प्रतिक्रिया विंडो के अंत तक चल सकती है। इसे जानबूझकर सेट करना वह सरलतम लागत नियंत्रण है जो आपके पास है।

सबसे खराब स्थिति की गणित मदद करती है। यदि आप आउटपुट को कैप नहीं करते हैं, तो एक प्रतिक्रिया विंडो के अंत तक जा सकती है, इसलिए केवल आउटपुट की लागत 100,000 × $0.50 / 1,000,000 = $0.05 तक हो सकती है। यदि आप चैट जवाब के लिए max_tokens को 300 पर सेट करते हैं, तो सबसे खराब स्थिति $0.00015 तक गिर जाती है। 1,500 इनपुट टोकन और 300 आउटपुट टोकन के साथ एक सामान्य टर्न की लागत लगभग $0.000225 प्लस $0.00015 होती है, जो $0.001 से कम है।

import os
from openai import OpenAI

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

INPUT_PER_M = 0.25
OUTPUT_PER_M = 1.00

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarise the plot of Hamlet in 5 sentences."}],
    max_tokens=250,
)

u = resp.usage
cost = u.prompt_tokens * INPUT_PER_M / 1_000_000 + u.completion_tokens * OUTPUT_PER_M / 1_000_000
print(f"in={u.prompt_tokens} out={u.completion_tokens} cost=${cost:.6f}")
print("finish_reason:", resp.choices[0].finish_reason)

finish_reason पर नज़र रखें। length का मान इसका मतलब है कि जवाब आपकी कैप पर पहुंच गया और कट गया; यदि ऐसा अक्सर होता है, तो कैप बढ़ाएं या प्रॉम्प्ट में छोटे आउटपुट का अनुरोध करें, क्योंकि एक कैप अकेले ट्रंकेट करती है मॉडल को संक्षिप्त बनाने के बजाय। कैप को एक लक्ष्य शब्द गणना जैसे निर्देशों के साथ जोड़ें, और हर कॉल के लिए usage लॉग करें ताकि आप अनुमान लगाने के बजाय वास्तविक औसत देख सकें। आपका मुफ़्त ट्रायल क्रेडिट और बैलेंस विवरण pricing page पर हैं।

प्रश्न और उत्तर

क्या मुझे इस बिना सेंसर AI API के लिए विशेष SDK की आवश्यकता है?

नहीं। आधिकारिक openai Python पैकेज (v1+) और openai npm पैकेज (v4+) काम करते हैं। base_url को https://api.uncensoredaiapis.com/v1, पर सेट करें, अपनी कुंजी पास करें और मॉडल ID uncensored का उपयोग करें।

क्या स्ट्रीमिंग में टोकन उपयोग शामिल है?

हाँ। stream: true के साथ API एक अंतिम चंक जोड़ता है जिसमें उपयोग स्वचालित रूप से होता है। उस चंक में खाली choices एरे होता है, इसलिए डेल्टा पढ़ने से पहले जांचें कि choices मौजूद है।

किस त्रुटियों को मेरा कोड पुनः प्रयास करना चाहिए?

429 (रेट लिमिट, प्रति कुंजी प्रति मिनट 300 अनुरोध) और 503 upstream_busy के लिए एक्सपोनेन्शियल बैकऑफ और ज़िटर के साथ पुनः प्रयास करें। 400, 401, 402 या 403 पर पुनः प्रयास न करें क्योंकि वही अनुरोध फिर से विफल हो जाएगा।

क्या कॉल के बीच मेरे लिए कनवर्सेशन हिस्ट्री स्टोर की जाती है?

नहीं। प्रत्येक अनुरोध स्वतंत्र होता है, इसलिए आपको हर बार पूर्ण संदेश सूची भेजनी होती है। प्रॉम्प्ट और पूर्णता को मिलाकर कॉन्टेक्स्ट विंडो 100,000 टोकन की है।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।