curl के साथ क्विक स्टार्ट
सबसे छोटा वर्किंग JSON मोड रिक्वेस्ट इस प्रकार दिखता है। इसमें बेस यूआरएल https://api.uncensoredllmapi.com/v1, मॉडल uncensored, और आपकी कुंजी को बेयरर टोकन के रूप में उपयोग किया जाता है:
curl https://api.uncensoredllmapi.com/v1/chat/completions -H "Authorization: Bearer $UNCENSORED_API_KEY" -H "Content-Type: application/json" -d '{
"model": "uncensored",
"response_format": {"type": "json_object"},
"messages": [
{"role": "system", "content": "Reply only with a JSON object."},
{"role": "user", "content": "Create a tavern NPC with keys name, trade and rumour."}
]
}'
choices[0].message.content में असिस्टेंट संदेश एक स्ट्रिंग है जिसमें एक JSON ऑब्जेक्ट होता है। आपको इसे खुद पार्स करना होगा। प्रॉम्प्ट में निर्देश को छोड़ें नहीं: JSON मोड आउटपुट को एक ऑब्जेक्ट होने के लिए बाध्य करता है, लेकिन यह नहीं अनुमान लगा सकता कि आपको कौन सी कुंजियां चाहिए। कुंजियों को नाम देना, और आदर्श रूप से एक लाइन उदाहरण दिखाना, आपको एक स्थिर संरचना देता है।
यदि आपके पास अभी तक कोई कुंजी नहीं है, तो API कुंजी पृष्ठ साइन-अप के बाद एक क्लिक से $0.50 का ट्रायल क्रेडिट देता है। उस क्रेडिट के लिए भुगतान की आवश्यकता नहीं है, यह 7 दिनों तक लागू रहता है और प्रति व्यक्ति केवल एक सीमित है।
वैलिडेशन के साथ Python में JSON मोड
मॉडल आउटपुट को किसी भी अन्य बाहरी इनपुट की तरह मानें। इसे पार्स करें, इसे एक स्कीमा के खिलाफ जांचें, और यदि यह विफल हो जाए तो सीमित संख्या में बार पुनः प्रयास करें। Pydantic इसे छोटा बनाता है:
import json, os
from openai import OpenAI
from pydantic import BaseModel, ValidationError
client = OpenAI(
base_url="https://api.uncensoredllmapi.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
)
class Npc(BaseModel):
name: str
trade: str
rumour: str
SYSTEM = (
"Reply only with a JSON object with exactly these keys: "
"name, trade, rumour. Each value is a string."
)
def make_npc(setting, tries=3):
for _ in range(tries):
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": SYSTEM},
{"role": "user", "content": f"Setting: {setting}"},
],
temperature=0.7,
max_tokens=300,
)
choice = r.choices[0]
if choice.finish_reason == "length":
continue # cut off, so the JSON is incomplete
try:
return Npc(**json.loads(choice.message.content))
except (json.JSONDecodeError, ValidationError, TypeError):
continue
raise RuntimeError("no valid JSON after retries")
print(make_npc("a river port in a plague year"))
उस स्निपेट में तीन आदतें कॉपी करने योग्य हैं। कोड finish_reason को पार्स करने से पहले जाँचता है, क्योंकि एक प्रतिक्रिया जो max_tokens पर रुक जाती है, आंशिक वस्तु में समाप्त हो जाती है। यह एक मध्यम तापमान का उपयोग करता है, क्योंकि उच्च तापमान गलत संरचना वाले आउटपुट की संभावना को बढ़ा देते हैं। और यह पुनः प्रयासों को सीमित करता है, इसलिए एक खराब प्रॉम्प्ट अनंत तक नहीं चलेगा। चूँकि विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, पुनः प्रयास बजट एक लेटेंसी का प्रश्न है, लागत का नहीं।
कॉमन JSON मोड गलतियाँ
- प्रॉम्प्ट में JSON माँगना लेकिन
response_formatमें नहीं। मॉडल अक्सर अनुपालन करेगा, लेकिन यह ऑब्जेक्ट को सामान्य पाठ या कोड फेंस में लपेट सकता है। दोनों को सेट करें। max_tokensको बहुत कम सेट करना। सबसे लंबे वैध उत्तर का अनुमान लगाएं और मार्जिन जोड़ें। आइटमों की एक लंबी सूची आसानी से 300 टोकन से अधिक हो सकती है।- टॉप-लेवल एरे की उम्मीद करना। JSON मोड एक ऑब्जेक्ट माँगता है। यदि आपको एक लिस्ट चाहिए, तो
{"items": [...]}के लिए कहें। - JSON में दिखाई देने वाले स्टॉप सीक्वेंस को जोड़ना।
stopपैरामीटर पास-थ्रू किया जाता है, और एक वैल्यू के अंदर दिखाई देने वाला स्टॉप स्ट्रिंग प्रतिक्रिया को जल्दी काट देगा। - स्ट्रीमिंग के साथ JSON मोड का उपयोग करना और प्रत्येक चंक को पार्स करना। पहले पूरी टेक्स्ट एकत्र करें, फिर अंत में एक बार पार्स करें।
तापमान, top_p, seed और पेनल्टी जैसे सैंपलिंग सेटिंग्स पास-थ्रू किए जाते हैं। एक्सट्रैक्शन कार्य के लिए, 0.2 के आसपास कम तापमान और एक स्थिर seed सबसे अधिक दोहराव योग्य आउटपुट देते हैं। NPC की तरह रचनात्मक जनरेशन के लिए, एक उच्च मान ठीक है जब तक कि आप सत्यापित करते हैं।
टूल कॉलिंग: पूरा लूप
टूल कॉलिंग मॉडल को आपका कोड कुछ करने के लिए पूछने देती है और फिर परिणाम के साथ आगे बढ़ती है। फ्लो में चार चरण हैं: आप टूल्स घोषित करते हैं, मॉडल tool_calls के साथ जवाब देता है, आप उन्हें चलाते हैं, और आप role: "tool" के साथ संदेशों के रूप में परिणाम वापस भेजते हैं।
import json, os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredllmapi.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
)
tools = [{
"type": "function",
"function": {
"name": "lookup_inventory",
"description": "Return the stock count for an item in the shop.",
"parameters": {
"type": "object",
"properties": {"item": {"type": "string"}},
"required": ["item"],
},
},
}]
def lookup_inventory(item):
stock = {"healing potion": 4, "rope": 12}
return {"item": item, "count": stock.get(item.lower(), 0)}
messages = [{"role": "user", "content": "Do you still have healing potions?"}]
for _ in range(4): # hard cap on tool rounds
r = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = r.choices[0].message
if not msg.tool_calls:
print(msg.content)
break
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = lookup_inventory(**args)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
आर्ग्युमेंट्स एक JSON स्ट्रिंग के रूप में आते हैं, जिसे आपको पार्स करना है, और मॉडल कभी-कभी ऐसे आर्ग्युमेंट्स उत्पन्न कर सकता है जो आपकी स्कीमा से मेल नहीं खाते हैं। साइड इफेक्ट्स के साथ कुछ भी चलाने से पहले उन्हें वैलिडेट करें। बिना चेक के उन्हें शेल, SQL स्ट्रिंग या फाइल पाथ में न पास करें।
tool_choice फ़ील्ड आपको व्यवहार को निर्देशित करने देता है। इसे "auto" पर छोड़ दें और मॉडल तय करता है। एक विशिष्ट फ़ंक्शन का नाम दें ताकि एक कॉल अनिवार्य कर दे, जो तब उपयोगी होता है जब आप JSON मोड के बजाय टूल स्कीमा के माध्यम से स्ट्रक्चर्ड एक्सट्रैक्शन चाहते हैं।
Node में स्ट्रीमिंग टूल कॉल्स
stream: true के साथ, टूल कॉल्स टुकड़ों में आते हैं। प्रत्येक चंक फंक्शन नाम या आर्ग्युमेंट स्ट्रिंग के एक टुकड़े को ले जाता है, जिसे पोजीशन द्वारा इंडेक्स किया गया है। आपको पोजीशन के अनुसार टुकड़ों को जोड़ना है और स्ट्रीम समाप्त होने पर ही पार्स करना है।
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredllmapi.com/v1",
apiKey: process.env.UNCENSORED_API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
stream: true,
messages: [{ role: "user", content: "Check stock for rope." }],
tools: [{
type: "function",
function: {
name: "lookup_inventory",
description: "Return the stock count for an item.",
parameters: {
type: "object",
properties: { item: { type: "string" } },
required: ["item"],
},
},
}],
});
const calls = [];
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta;
for (const tc of delta?.tool_calls ?? []) {
const slot = (calls[tc.index] ??= { id: "", name: "", args: "" });
if (tc.id) slot.id = tc.id;
if (tc.function?.name) slot.name += tc.function.name;
if (tc.function?.arguments) slot.args += tc.function.arguments;
}
}
for (const c of calls) {
console.log(c.name, JSON.parse(c.args));
}
याद रखें कि एक स्ट्रीमिंग अनुरोध स्ट्रीम समाप्त होने तक आपकी कन्करेंसी स्लॉट में से एक पकड़े रखता है। एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 की अनुमति देती है, एक ट्रायल कुंजी 2 और 60 की। किसी भी सीमा को पार करने पर HTTP 429 concurrency या rate_limited कोड के साथ आता है। उपयोग के कुल योग स्ट्रीम के अंत में रिपोर्ट किए जाते हैं, जो लागत लॉगिंग के लिए उपयोगी है।
JSON मोड या टूल स्कीमा
दोनों आपको संरचित डेटा देते हैं, तो आपको किसका उपयोग करना चाहिए? निर्णायक प्रश्न यह है कि क्या मॉडल डेटा उत्पन्न कर रहा है या कोई क्रिया चुन रहा है।
JSON मोड का उपयोग तब करें जब आउटपुट स्वयं उत्पाद हो: एक NPC शीट, टैग्स की सूची, आत्मविश्वास फ़ील्ड के साथ एक वर्गीकरण। आप पूरा प्रॉम्प्ट नियंत्रित करते हैं, आपको एक ऑब्जेक्ट वापस मिलता है, और भुगतान के लिए एक ही अनुरोध होता है।
टूल्स का उपयोग करें जब मॉडल को यह तय करना हो कि क्या क्रिया लेनी है, या जब कई अलग-अलग क्रियाएँ संभव हों। फ़ंक्शन के लिए एक स्कीमा अनुबंध का दस्तावेज़ीकरण करता है, tool_choice आपको कॉल को फोर्स या अनुमति देने देता है, और पिछले सेक्शन में लूप मल्टी-स्टेप वर्क को संभालता है। लागत प्रति राउंड एक अतिरिक्त अनुरोध है, और टूल डिफ़िनिशंस को हर बार इनपुट के रूप में गिना जाता है।
एक्सट्रैक्शन के लिए एक व्यावहारिक मध्यम मार्ग: एक टूल घोषित करें जिसके पैरामीटर वे फ़ील्ड हैं जो आप चाहते हैं, और tool_choice को उस फ़ंक्शन पर सेट करें। आपको तर्क JSON मिलता है जो आपकी स्कीमा की आकृति का पालन करता है, बिना कुंजी सूची को प्रॉम्प्ट में लिखे। किसी भी मामले में, उस पर भरोसा करने से पहले परिणाम की सत्यापना करें, और किसी भी अनुरोध के X-Request-Id मान को लॉग करें जिसने कुछ अप्रत्याशित उत्पन्न किया।
इसकी लागत
JSON और टूल कॉल्स किसी अन्य टोकन की तरह बिल किए जाते हैं: $0.15 प्रति 1M इनपुट और $0.50 प्रति 1M आउटपुट। टूल डिफ़िनिशंस हर अनुरोध पर इनपुट के रूप में गिने जाते हैं, और आप जो भी टूल रिजल्ट वापस भेजते हैं, वह अगले अनुरोध के इनपुट में जुड़ जाता है।
उदाहरण: एक टूल-यूज़िंग असिस्टेंट टर्न जिसमें 600-टोकन टूल स्कीमा और प्रॉम्प्ट, एक 150-टोकन मॉडल कॉल, फिर एक दूसरा अनुरोध जिसमें 900 इनपुट टोकन (पिछले संदेश plus एक टूल रिजल्ट) और एक 200-टोकन प्रतिक्रिया शामिल है।
- अनुरोध एक: 600 इनपुट और 150 आउटपुट। इनपुट 600 x $0.15 / 1M = $0.00009। आउटपुट 150 x $0.50 / 1M = $0.000075। सबटोटल $0.000165।
- अनुरोध दो: 900 इनपुट और 200 आउटपुट। इनपुट 900 x $0.15 / 1M = $0.000135। आउटपुट 200 x $0.50 / 1M = $0.0001। सबटोटल $0.000235।
- टर्न के लिए कुल: $0.0004।
उस दर से 1,000 टर्न्स की लागत $0.40 है। क्रेडिट $20 से $500 तक पूर्ण राशि में प्रीपेड होता है (बोनस: $50 से +5%, $100 से +10%, $200 से +15%), जो TRC20 पर USDT या Base पर USDC के साथ क्रिप्टो के माध्यम से भुगतान किया जाता है। वर्तमान आंकड़ों के लिए मूल्य निर्धारण पृष्ठ देखें।
आगे कहाँ जाएँ
प्रत्येक अनुरोध फ़ील्ड का संदर्भ API दस्तावेज़ीकरण में है। यदि आप वास्तविक ट्रैफ़िक के लिए एक एप्लिकेशन तैयार कर रहे हैं, तो प्रोडक्शन चेकलिस्ट पढ़ने के लिए अगला पृष्ठ है, और सहायता एक अनुरोध के अप्रत्याशित व्यवहार में मदद कर सकता है। अपने अनुरोध ID को तैयार रखें, जो X-Request-Id हेडर में वापस आता है।
सर्विस केवल टेक्स्ट है और कॉन्टेक्स्ट विंडो 100,000 टोकन है, जिसमें आपके टूल डिफ़िनिशंस और परिणाम शामिल हैं। नाबालिगों से जुड़ा यौन सामग्री अनुमत नहीं है, और यह संरचित और टूल-ड्रिवन आउटपुट पर वैसा ही लागू होता है जैसा कि साधारण चैट पर।
