HI ▾

unfilteredaiapi.comhttps://api.unfilteredaiapi.com/v1

Unfiltered AI

विकसकों के लिए कच्चा, बिना सेंसर LLM API।

Unfiltered AIAPI कुंजी पाएँ

Unfiltered AI गेम NPC संवाद और इंटरैक्टिव फिक्शन के लिए

गेम का नियंत्रण इंजन के पास रखें: प्रत्येक NPC की स्थिति संग्रहीत करें, प्रस्तावित टूल कॉल को सत्यापित करें और अनुमत कहानी संक्रमणों को बनाए रखें। यह गाइड उन नियमों को जनरेटेड संवाद पर लागू करती है और दिखाती है कि टोकन लागत का अनुमान कैसे लगाएं।

Unfiltered AI गेम NPC संवाद और इंटरैक्टिव फिक्शन के लिए

मुख्य बिंदु

  • Unfiltered AI जैसे समर्पित इनफरेंस प्रदाता एकल मॉडल पर स्थिर बिना सेंसर व्यवहार प्रदान करते हैं, जो एग्रीगेटर रूटिंग की यादृच्छिकता से बचाते हैं।
  • OpenRouter जैसे एग्रीगेटर कई मॉडल तक पहुंच प्रदान करते हैं, लेकिन विशिष्ट मॉडल संस्करण के आधार पर वे सामग्री फिल्टर को कितनी कठोरता से लागू करते हैं, इसमें भिन्नता हो सकती है।
  • Unfiltered AI एक ओपन-वेट मॉडल का उपयोग करता है जो समर्पित हार्डवेयर पर 100k कॉन्टेक्स्ट विंडो के साथ चलता है, जिसकी कीमत प्रति मिलियन टोकन $0.15/$0.50 है।
  • कठोर NSFW या रोलप्ले स्थिरता के लिए, एक समर्पित बिना सेंसर LLM API सामान्य फिल्टर को बायपास करने के लिए जटिल प्रॉम्प्ट इंजीनियरिंग की आवश्यकता को समाप्त कर देता है।

शब्दों में खींचा गया गेम लूप

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

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

सभी अनुरोध https://api.unfilteredaiapi.com/v1 पर मानक चैट-कम्प्लीशंस एंडपॉइंट का उपयोग करते हैं जिसका मॉडल आईडी uncensored है। टूल OpenAI फ़ंक्शन कॉलिंग प्रारूप का उपयोग करते हैं, इसलिए एक ही कोड आधिकारिक क्लाइंट लाइब्रेरी के साथ काम करता है।

स्कोप और एक वयस्कों-के-लिए-मात्र नोट

वयस्क दर्शकों के लिए इंटरैक्टिव फिक्शन एक वैध उपयोग है। सेवा कानूनी वयस्क सामग्री, गहरे विषयों या कथा में विवादास्पद विषयों को अस्वीकार नहीं करती है। यह 18 वर्ष और उससे अधिक उम्र के वयस्कों के लिए है, और आपको अपने गेम के स्टोर पेज पर यह कहना चाहिए और उसी अनुसार प्रवेश पर रोक लगानी चाहिए।

एक रेखा स्थिर है: नाबालिगों से जुड़ी यौन सामग्री हमेशा 403 के साथ ब्लॉक की जाती है, चाहे वह फिक्शन हो या रोलप्ले। उसी अनुसार डिज़ाइन करें। राज्य रिकॉर्ड में हर पात्र को वयस्क आयु दें, और अपने इंजन को 403 को सहजता से हैंडल करने दें, पुनः प्रयास करने के बजाय संवाद को समाप्त करके।

संरचित NPC स्थिति

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

{
  "name": "Brannoch",
  "role": "ferry smuggler",
  "mood": "wary",
  "trust": 1,
  "inventory": ["brass key", "flask of rum"],
  "knows": ["the harbourmaster takes bribes", "a tunnel runs under the salt warehouse"],
  "will_never": ["name his employer", "leave the dock before dawn"],
  "location": "Gull Quay, pre-dawn"
}

प्रत्येक फ़ील्ड अपना स्थान अर्जित करता है। mood और trust टोन को निर्देशित करते हैं। inventory यह सीमा तय करता है कि क्या दिया जा सकता है। knows यह सीमित करता है कि NPC क्या प्रकट कर सकता है, ताकि खिलाड़ी उन प्लॉट पॉइंट्स को न निकाल सकें जिनका चरित्र के पास रखने का कोई कारण नहीं है। will_never कठोर अस्वीकृतियों की एक छोटी सूची है जो चरित्र को एक रीढ़ प्रदान करती है। लगभग 120 टोकन की लागत, हर टर्न पर लगभग कुछ भी टोकन नहीं लेता है।

गेम क्रियाओं के लिए टूल कॉल

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

import json
import os
from openai import OpenAI

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

TOOLS = [
    {"type": "function", "function": {
        "name": "adjust_trust",
        "description": "Change how much this NPC trusts the player after what was just said.",
        "parameters": {"type": "object", "properties": {
            "delta": {"type": "integer", "minimum": -2, "maximum": 2},
            "reason": {"type": "string"}},
            "required": ["delta"]}}},
    {"type": "function", "function": {
        "name": "give_item",
        "description": "Hand an item from the NPC's inventory to the player.",
        "parameters": {"type": "object", "properties": {
            "item": {"type": "string"}}, "required": ["item"]}}},
    {"type": "function", "function": {
        "name": "offer_choices",
        "description": "Present up to three short dialogue options for the player to pick from.",
        "parameters": {"type": "object", "properties": {
            "choices": {"type": "array", "items": {"type": "string"}, "maxItems": 3}},
            "required": ["choices"]}}},
]

def apply_tool(name, args, state, out):
    if name == "adjust_trust":
        state["trust"] = max(-3, min(5, state["trust"] + int(args.get("delta", 0))))
        return f"trust is now {state['trust']}"
    if name == "give_item":
        item = args.get("item")
        if item in state["inventory"]:
            state["inventory"].remove(item)
            out["items"].append(item)
            return f"gave {item}"
        return "refused: item not in inventory"          # the engine, not the model, decides
    if name == "offer_choices":
        out["choices"] = args.get("choices", [])[:3]
        return "choices shown"
    return "unknown tool"

def npc_turn(state, history, player_line):
    system = {"role": "system", "content": (
        "You voice one NPC in an adults-only interactive story. Stay in character, "
        "at most 80 words per reply, no narration of the player's actions. "
        "Use tools for anything that changes the game; never claim an item was given without calling give_item.\n"
        "NPC state (authoritative): " + json.dumps(state))}
    history.append({"role": "user", "content": player_line})
    out = {"text": "", "items": [], "choices": []}

    for _ in range(4):                                       # cap tool-call rounds
        r = client.chat.completions.create(
            model="uncensored", messages=[system] + history, tools=TOOLS,
            temperature=0.8, max_tokens=300)
        msg = r.choices[0].message
        entry = {"role": "assistant", "content": msg.content}
        if msg.tool_calls:
            entry["tool_calls"] = [{"id": c.id, "type": "function",
                "function": {"name": c.function.name, "arguments": c.function.arguments}}
                for c in msg.tool_calls]
        history.append(entry)
        if msg.content:
            out["text"] += msg.content
        if not msg.tool_calls:
            return out
        for c in msg.tool_calls:
            result = apply_tool(c.function.name, json.loads(c.function.arguments or "{}"), state, out)
            history.append({"role": "tool", "tool_call_id": c.id, "content": result})
    return out

state = json.loads(open("brannoch.json").read())
history = []
print(npc_turn(state, history, "I need to cross before sunrise. Name your price."))

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

प्लॉट खोए बिना शाखाएँ

इंजन को कहानी ग्राफ का मालिक बनाएं और मॉडल को वाक्यों का मालिक बनाएं। एक नोड सूचीबद्ध करता है कि कौन सा NPC बोल रहा है, किस गेट को पार करना है, और प्रत्येक विकल्प कहाँ ले जाता है। जब मॉडल offer_choices कॉल करता है, तो आप प्रत्येक विकल्प को एक नोड कुंजी से मैप करते हैं; अनमेल स्वतंत्र पाठ वर्तमान नोड पर वापस आ जाता है।

{
  "id": "quay_negotiation",
  "npc": "brannoch",
  "gate": {"trust_at_least": 2},
  "on_choice": {
    "pay_double":   {"next": "crossing_fast", "set": {"gold": -40}},
    "threaten":     {"next": "quay_standoff", "trust_delta": -2},
    "ask_about_tunnel": {"next": "warehouse_tunnel", "requires_fact": "tunnel"}
  },
  "fallback": "quay_negotiation"
}

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

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

लंबे प्लेट्रू में स्मृति

दस घंटे पहले मिले एक NPC को एक अपमान को याद रखना चाहिए। दस घंटे के संवाद को दोहराएं नहीं। प्रत्येक NPC के लिए एक दो-वाक्य का सारांश संग्रहीत करें, जब संवाद समाप्त हो जाए तो इसे अपडेट करें, और इसे memories फ़ील्ड के रूप में स्थिति रिकॉर्ड में जोड़ें। सारांश बनाने और बजट बनाने के तंत्र 100k स्मृति लेख में कवर किए गए हैं, और यही ट्रिमिंग प्रत्येक NPC के रोलिंग संवाद पर लागू होती है।

यदि आप एक ब्राउज़र गेम सर्व करते हैं, तो स्ट्रीम को अपने सर्वर के माध्यम से रिले करें, जैसा कि the FastAPI article में है, ताकि कुंजी क्लाइंट तक न पहुँचे।

NPC को उसी तरह टेस्ट करना जैसे आप कोड टेस्ट करते हैं

मॉडल से संवाद संभाव्य होता है, लेकिन उसके आसपास के नियम नहीं, और यही वह जगह है जहाँ परीक्षण होने चाहिए। ऊपर बताई गई स्थिति रिकॉर्ड को brannoch.json के रूप में सहेजें, फिर साहित्यिक भाषा के बजाय इंजन के खिलाफ जाँच लिखें।

  1. टूल वैलिडेशन टेस्ट। apply_tool को सीधे उस आइटम के साथ कॉल करें जिसके पास NPC के पास नहीं है, 99 का भरोसा डेल्टा, और अमान्य तर्क। प्रत्येक मामले में राज्य कानूनी रहना चाहिए।
  2. ग्राफ़ टेस्ट। प्रत्येक नोड लोड करें, पुष्टि करें कि प्रत्येक next लक्ष्य मौजूद है, और API को कॉल किए बिना पहले नोड से प्रत्येक अंत तक एक पथ वॉक करें।
  3. रिप्ले टेस्ट। एक वास्तविक बातचीत को एक बार रिकॉर्ड करें, जिसमें टूल कॉल और परिणाम शामिल हों, फिर इंजन के खिलाफ टूल संदेशों को रीप्ले करें ताकि यह जांचा जा सके कि अंतिम स्टेट आपकी उम्मीद के अनुसार मेल खाता है या नहीं।
  4. सोख परीक्षण। एक स्क्रिप्टेड खिलाड़ी को कम तापमान पर पचास लाइनों के माध्यम से चलाएं और यह सुनिश्चित करें कि NPC कभी भी वह आइटम न दे जिसके पास उसके पास नहीं है और न ही विश्वास की सीमाओं से अधिक जाए।

उन रन के लिए तापमान को लगभग 0.3 तक कम करें, फिर खेल के लिए 0.8 पर वापस जाएं। परीक्षण के दौरान कम हैरानियाँ का मतलब है कि एक विफलता आपके कोड की ओर इशारा करती है, न कि सैंपलिंग शोर की ओर। जब लाइव प्ले में कोई बग दिखाई देता है, तो उस अपराधी आदान-प्रदान को रीप्ले सेट में जोड़ें ताकि वह अनदेखा न हो।

एक आखिरी आदत: प्रत्येक NPC के लिए एक छोटे पैराग्राफ में चरित्र की आवाज़ रखें और नियमों को स्थिति रिकॉर्ड में रखें। आवाज़ को लेखकों द्वारा स्वतंत्र रूप से समायोजित किया जा सकता है; नियम केवल कोड रिव्यू के साथ बदले जाते हैं। उन्हें एकल ब्लॉब में मिलाना इस बात का कारण बनता है कि NPC की व्यक्तित्व के पुनर्लेखन के दौरान एक आइटम अनजाने में अनलॉक हो जाए।

लागत गणना, धारणाएँ स्पष्ट के साथ

कीमतें प्रति मिलियन इनपुट टोकन $0.15 और प्रति मिलियन आउटपुट टोकन $0.50 हैं। नीचे दिए गए आंकड़े मापन नहीं, योजना के लिए धारणाएँ हैं। मानें कि एक NPC लाइन की लागत है: सिस्टम इन्स्ट्रक्शन्स और स्टेट 350 टोकन, हालिया संवाद 1,000 टोकन, टूल डिफिनिशन्स 250 टोकन, तो 1,600 इनपुट टोकन; रिप्लाई 100 आउटपुट टोकन।

आइटमगणनालागत
प्रति पंक्ति इनपुट1,600 x $0.15 / 1M$0.0004
प्रति पंक्ति आउटपुट100 x $0.50 / 1M$0.0001
एक पंक्तियोग$0.0005
एक सत्र, 60 पंक्तियाँ60 x $0.0005$0.03
10,000 सत्र10,000 x $0.03$300

एक टूल-कॉल राउंड ट्रिप एक अतिरिक्त अनुरोध जोड़ता है: लगभग 1,700 इनपुट टोकन और 40 आउटपुट, जो लगभग $0.00047 का है। यदि प्रत्येक तीसरी पंक्ति एक टूल ट्रिगर करती है, तो औसत में उसका एक तिहाई जोड़ें। सीलिंग चेक भी महत्वपूर्ण हैं: प्रति कुंजी प्रति मिनट 300 अनुरोधों की सीमा पर, एकल कुंजी सभी समानांतर खिलाड़ियों के लिए प्रति मिनट लगभग 300 NPC पंक्तियों का समर्थन करती है, इसलिए बड़े लॉन्च में कतारबद्धता की आवश्यकता होती है। दरें मूल्य निर्धारण पृष्ठ पर सारांशित हैं।

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

क्या API गेम एक्शन के लिए फ़ंक्शन कॉलिंग का समर्थन करता है?

हाँ। टूल OpenAI प्रारूप में स्वीकार किए जाते हैं, इसलिए आप फ़ंक्शन घोषित करते हैं, टूल कॉल प्राप्त करते हैं और परिणाम टूल संदेशों के रूप में वापस भेजते हैं।

एक NPC संवाद की लागत कितनी है?

यह आपके प्रॉम्प्ट पर निर्भर करता है। माने गए 1,600 इनपुट और 100 आउटपुट टोकन प्रति पंक्ति के साथ, एक पंक्ति की लागत प्रकाशित दरों पर लगभग $0.0005 है।

क्या मेरे गेम के चरित्र यौन दृश्यों में किशोर हो सकते हैं?

नहीं। नाबालिगों से जुड़ी यौन सामग्री हमेशा 403 के साथ ब्लॉक की जाती है, फिक्शन सहित। सेवा 18 वर्ष और उससे अधिक आयु के वयस्कों के लिए है।

मैं NPC को प्लॉट के राज़ खुलते हुए कैसे रोकूँ?

अपने कोड में स्टेट रिकॉर्ड में वह सूचीबद्ध करें जो वह जानता है और वह कभी नहीं करेगा, और आइटम व फ्लैग परिवर्तनों को लागू करें।

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

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

API कुंजी प्राप्त करेंदस्तावेज़ पढ़ें