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

अद्यतनUnfiltered AI
मुख्य बिंदु
- Unfiltered AI जैसे समर्पित इनफ़रेंस प्रदाता एकल मॉडल पर स्थिर बिना सेंसर व्यवस्था प्रदान करते हैं, जो एग्रीगेटर रूटिंग की यादृच्छिकता से बचाते हैं।
- OpenRouter जैसे एग्रीगेटर कई मॉडलों तक पहुंच प्रदान करते हैं, लेकिन विशिष्ट मॉडल संस्करण के आधार पर वे सामग्री फ़िल्टर को कितनी सख्ती से लागू करते हैं, इसमें भिन्नता हो सकती है।
- Unfiltered AI एक ओपन-वेट मॉडल का उपयोग समर्पित हार्डवेयर पर करता है जिसकी 100k context window है, जिसका मूल्य प्रति मिलियन टोकन $0.15/$0.50 है।
- कठोर NSFW या रोलप्ले स्थिरता के लिए, एक समर्पित बिना सेंसर LLM API सामान्य फ़िल्टर को बायपास करने के लिए जटिल प्रॉम्प्ट इंजीनियरिंग की आवश्यकता को समाप्त कर देती है।
शब्दों में एक तस्वीर के रूप में सिस्टम
तीनों बक्सों को एक पंक्ति में और उनके बीच दो तीरों की कल्पना करें। बाईं ओर, browser। बीच में, आपका FastAPI प्रक्रिया। दाईं ओर, मॉडल एंडपॉइंट https://api.unfilteredaiapi.com/v1 पर। बाईं तीली एक उपयोगकर्ता संदेश ले जाती है और छोटे पाठ फ्रेमों की एक स्ट्रीम लौटाती है। दाईं तीली पूर्ण संवाद ले जाती है और सर्वर-सेंट इवेंट्स लौटाती है। मध्य बक्सा तीन कार्य करता है और कोई नहीं: यह API कुंजी रखता है, यह संवाद स्थिति का मालिक है, और यह एक स्ट्रीम प्रारूप को दूसरे में परिवर्तित करता है।
कुंजी को मध्य बॉक्स में रखना ही इस परत के अस्तित्व का कारण है। ब्राउज़र में भेजी गई कुंजी वह कुंजी होती है जो डेवलपर टूल्स खोलने वाले हर व्यक्ति के लिए उपलब्ध हो जाती है। दूसरा कारण स्टेट (state) है: ब्राउज़र केवल नया टेक्स्ट और सेशन आईडी भेजता है, जबकि सर्वर तय करता है कि कितना इतिहास रीप्ले करना है। यह निर्णय तब महत्वपूर्ण हो जाता है जब बातचीत बड़ी हो जाती है, जिसे मेमोरी आर्टिकल में गहराई से समझाया गया है।
यहाँ सब कुछ stream: true के साथ मानक chat-completions प्रारूप का उपयोग करता है, इसलिए fastapi, uvicorn और httpx इंस्टॉल करें और कुछ नहीं।
दाहिनी तीली पर क्या आता है
स्ट्रीमिंग चालू होने पर, प्रतिक्रिया लाइनों की एक श्रृंखला होती है। प्रत्येक उपयोगी लाइन data: के साथ शुरू होती है, जिसके बाद एक JSON चंक आता है जिसका choices[0].delta.content कुछ वर्ण रखता है। अंतिम वास्तविक लाइन data: [DONE] है। उससे ठीक पहले, एक उपयोग चंक स्वचालित रूप से जोड़ा जाता है; इसमें टोकन गणना होती है और इसमें choices प्रविष्टियाँ नहीं होतीं, इसलिए रिले को इंडेक्स करने से पहले उसका परीक्षण करना चाहिए।
स्ट्रीम को तीन चरणों के रूप में मानें: एक शांत शुरुआत जब मॉडल आपका प्रॉम्प्ट पढ़ रहा होता है, टुकड़ों का एक निरंतर प्रवाह, और उपयोग और सेन्टिनल के साथ एक छोटा उपसंहार। नीचे दिया गया रिले उन चरणों को प्रतिबिंबित करता है। यह टुकड़ों को आने पर आगे बढ़ाता है, उन्हें एक स्ट्रिंग में जमा करता है, और प्रवाह समाप्त होने पर उस स्ट्रिंग को सत्र में लिखता है।
रिले एंडपॉइंट
कोर एक async जनरेटर है जिसे stream_reply कहा जाता है। FastAPI का StreamingResponse इसे उपभोग करता है और प्रत्येक उत्पन्न स्ट्रिंग को क्लाइंट पर फ्लश करता है। दो रास्ते एक ही जनरेटर को घेरते हैं: fetch के लिए एक POST और EventSource के लिए एक GET।
# app.py
import json
import os
import uuid
import httpx
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
API_URL = "https://api.unfilteredaiapi.com/v1/chat/completions"
SYSTEM = {"role": "system", "content": "You are Corvin, a patient narrator of dark, adult-oriented fiction."}
app = FastAPI()
sessions: dict[str, list[dict]] = {} # session id -> message list
class Turn(BaseModel):
session_id: str
text: str
def sse(data, event=None):
head = f"event: {event}\n" if event else ""
return f"{head}data: {json.dumps(data)}\n\n"
async def stream_reply(session_id: str, text: str):
history = sessions.setdefault(session_id, [])
history.append({"role": "user", "content": text})
payload = {
"model": "uncensored",
"messages": [SYSTEM] + history,
"stream": True,
"max_tokens": 700,
}
headers = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
parts: list[str] = []
async with httpx.AsyncClient(timeout=httpx.Timeout(10.0, read=120.0)) as client:
async with client.stream("POST", API_URL, headers=headers, json=payload) as r:
if r.status_code != 200:
body = (await r.aread()).decode()
history.pop() # do not keep a turn that got no answer
yield sse({"status": r.status_code, "body": body}, event="error")
return
async for line in r.aiter_lines():
if not line.startswith("data: "):
continue
raw = line[6:]
if raw == "[DONE]":
break
chunk = json.loads(raw)
if not chunk.get("choices"): # the final usage chunk
continue
piece = chunk["choices"][0]["delta"].get("content")
if piece:
parts.append(piece)
yield sse(piece)
history.append({"role": "assistant", "content": "".join(parts)})
yield sse({}, event="done")
@app.post("/session")
def new_session():
return {"session_id": uuid.uuid4().hex}
@app.post("/chat")
async def chat(turn: Turn):
return StreamingResponse(
stream_reply(turn.session_id, turn.text),
media_type="text/event-stream",
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
)
@app.get("/chat/stream") # for EventSource, which only does GET
async def chat_get(session_id: str, text: str):
return StreamingResponse(
stream_reply(session_id, text),
media_type="text/event-stream",
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
)जनरेटर को ऊपर से नीचे तक पढ़ें। यह पहले उपयोगकर्ता संदेश जोड़ता है, ताकि मॉडल उसे देख सके। यदि अपस्ट्रीम स्थिति 200 नहीं है, तो यह उस संदेश को फिर से हटा देता है और एक error इवेंट उत्पन्न करता है, जो इतिहास को बिना उत्तर वाले टर्न्स से मुक्त रखता है। सफलता पर यह प्रत्येक टुकड़े को एक JSON स्ट्रिंग के रूप में उत्पन्न करता है, जो नएलाइन और उद्धरण चिह्नों को फ्रेमिंग के माध्यम से जीवित रहने का तरीका है। जब लूप समाप्त होता है, तो यह सहायक पाठ संग्रहीत करता है और एक done इवेंट भेजता है।
दो हेडर महत्वपूर्ण हैं। Cache-Control: no-cache मध्यस्थों को स्ट्रीम को पकड़े रहने से रोकता है, और X-Accel-Buffering: no एक nginx-शैली प्रॉक्सी को बताता है कि बाइट्स को तुरंत आगे बढ़ाया जाए।
सत्र स्टोर चुनना
उदाहरण में डिक्शनरी सबसे सरल संभव स्टोर है: सत्र id के प्रति संदेशों की एक सूची। इसकी तीन ईमानदार सीमाएँ हैं। यह रीस्टार्ट पर गायब हो जाता है, यह वर्कर प्रक्रियाओं के बीच साझा नहीं है, और यह बिना सीमा बढ़ता है। उस सीमा के अनुसार अगला चरण चुनें जो पहले दर्द देती है।
- एकल प्रक्रिया, छोटी सत्र: शब्दावली बनाए रखें, और एक समय-सीमा वाली सफाई जोड़ें जो एक घंसे से निष्क्रिय सत्रों को हटा दे।
- कई वर्कर: संदेश सूची को एक साझा की-वैल्यू स्टोर में ले जाएं, जहाँ सत्र id की है और JSON सरणी मान है। प्रत्येक सत्र के लिए एक्सेस को सीरियलाइज़ करें ताकि दो एक साथ अनुरोध इंटर्लीव न हो सकें।
- स्थिर इतिहास: प्रत्येक पाली को सत्र और क्रम संख्या द्वारा कुंजी वाले डेटाबेस पंक्ति में लिखें, और आवश्यकता पर अंतिम भाग लोड करें।
आप जो भी चुनते हैं, इसे दो फ़ंक्शन्स के पीछे छिपाएं, load(session_id) और append(session_id, message), ताकि stream_reply कभी न जान पाए कि डेटा कहाँ रहता है। सत्र ids को सर्वर पर उत्पन्न करें, जैसे कि /session रास्ता करता है, और उन्हें अटूट रहस्यों के रूप में मानें।
fetch के साथ ब्राउज़र अंत
बाईं तीली पर ब्राउज़र को एक स्ट्रीमिंग POST बॉडी पढ़नी होगी। fetch इसे एक पठनीय स्ट्रीम के रूप में प्रकट करता है, और TextDecoderStream बाइट्स को पाठ में बदलता है। फ्रेम एक खाली लाइन द्वारा अलग किए जाते हैं, इसलिए क्लाइंट आने वाले पाठ को बफर करता है और पूर्ण फ्रेम को काट देता है।
<!doctype html>
<meta charset="utf-8">
<title>Chat</title>
<div id="log"></div>
<form id="f"><input id="t" autocomplete="off" size="50"><button>Send</button></form>
<script>
const sid = localStorage.getItem("sid") ?? (() => {
const id = crypto.randomUUID().replaceAll("-", "");
localStorage.setItem("sid", id);
return id;
})();
const log = document.getElementById("log");
function line(text) {
const p = document.createElement("p");
p.textContent = text;
log.append(p);
return p;
}
document.getElementById("f").addEventListener("submit", async (e) => {
e.preventDefault();
const box = document.getElementById("t");
const text = box.value.trim();
if (!text) return;
box.value = "";
line("You: " + text);
const out = line("");
const res = await fetch("/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ session_id: sid, text }),
});
const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
let buf = "";
while (true) {
const { value, done } = await reader.read();
if (done) break;
buf += value;
let cut;
while ((cut = buf.indexOf("\n\n")) >= 0) {
const frame = buf.slice(0, cut);
buf = buf.slice(cut + 2);
if (frame.startsWith("event: done")) continue;
if (frame.startsWith("event: error")) { out.textContent += " [request failed]"; continue; }
if (frame.startsWith("data: ")) out.textContent += JSON.parse(frame.slice(6));
}
}
});
</script>पेज textContent के साथ लिखता है, कभी भी innerHTML नहीं, इसलिए मॉडल आउटपुट आपके पेज में मार्कअप इंजेक्ट नहीं कर सकता। यह एक छोटी आदत है जिसका बड़ा लाभ तब मिलता है जब मॉडल मनमाना कथा उत्पन्न कर रहा हो।
कोई फ्रंटएंड लिखने से पहले रिले का परीक्षण करना
पहले मध्य बॉक्स को अलग से टेस्ट करें। एक टर्मिनल क्लाइंट ब्राउज़र को समीकरण से हटा देता है, इसलिए यदि आपको कोई समस्या दिखाई देती है तो वह रिले की है। -N फ्लैग curl के आउटपुट बफरिंग को बंद कर देता है; इसके बिना आप पूरा जवाब एक साथ आते हुए देखेंगे और गलत निष्कर्ष निकालेंगे कि स्ट्रीमिंग खराब है।
uvicorn app:app --port 8000 &
SID=$(curl -s -X POST localhost:8000/session | python3 -c "import sys,json; print(json.load(sys.stdin)['session_id'])")
curl -N -X POST localhost:8000/chat -H "Content-Type: application/json" \
-d "{\"session_id\": \"$SID\", \"text\": \"Open with a storm.\"}"आपको data: के साथ शुरू होने वाली लाइनों को देखना चाहिए, प्रत्येक एक उद्धृत टुकड़ा ले जाती है, फिर एक अंतिम event: done फ्रेम। एक ही सत्र id के साथ एक दूसरा संदेश भेजें और कथाकार से जारी रहने के लिए कहें; यदि यह जहाँ रुका था वहाँ से उठाता है, तो स्टोर काम करता है। यदि सभी लाइनें एक ही बर्स्ट में आती हैं, तो आपको और प्रक्रिया के बीच कुछ बफर कर रहा है, और सामान्य संदिग्ध एक रिवर्स प्रॉक्सी है जिसमें रिस्पॉन्स बफरिंग चालू है।
एक बार जब यह पास हो जाता है, तो ब्राउज़र पेज केवल समान फ्रेम पढ़ने का मामला है। साइट होम और दस्तावेज़ अनुरोध फ़ील्ड सूचीबद्ध करते हैं यदि आप रिले के माध्यम से अधिक सैंपलिंग विकल्प पास करना चाहते हैं।
EventSource संस्करण और इसका समझौता
ब्राउज़र का EventSource API आपके लिए पार्सिंग और रिकनेक्शन संभालता है, लेकिन यह केवल GET अनुरोध जारी कर सकता है। इसलिए बैकएंड में एक दूसरा रोड है। इसकी लागत यह है कि उपयोगकर्ता का टेक्स्ट URL में यात्रा करता है, और URL अक्सर उस मशीन पर एक्सेस लॉग में समाप्त हो जाते हैं जिसे आप चलाते हैं। निजी बातचीत के लिए POST और fetch दृष्टिकोण को प्राथमिकता दें।
const q = new URLSearchParams({ session_id: sid, text: "Describe the harbour at dusk." });
const src = new EventSource("/chat/stream?" + q);
const out = document.getElementById("log").appendChild(document.createElement("p"));
src.onmessage = (ev) => { out.textContent += JSON.parse(ev.data); };
src.addEventListener("done", () => src.close()); // without this, EventSource reconnects
src.addEventListener("error", () => src.close());done लिस्नर पर ध्यान दें। जब सर्वर इवेंट स्ट्रीम बंद कर देता है, तो EventSource नेटवर्क त्रुटि मानकर रिकनेक्ट कर लेता है, जिससे वही संदेश फिर से भेजा जाएगा। done और error पर स्रोत को स्वयं बंद करके उस लूप को तोड़ा जा सकता है।
विफलता मोड और डिज़ाइन के लिए सीमाएँ
एक बार तीरों को फिर से देखें और पूछें कि प्रत्येक पर क्या टूट सकता है। दाईं ओर: 401 का अर्थ है खराब कुंजी, 402 का अर्थ है कि बैलेंस खत्म हो गया है, 403 का अर्थ है कि अनुरोध ब्लॉक कर दिया गया था, 429 का अर्थ है कि आपने इस कुंजी पर प्रति मिनट 300 अनुरोध पार कर लिए हैं, और upstream_busy के साथ 503 कुछ सेकंड बाद पुनः प्रयास के योग्य है। रिले इन्हें सभी को एक error इवेंट के रूप में प्रस्तुत करता है जिसमें स्टेटस संलग्न होता है, ताकि ब्राउज़र संदेश चुन सके।
मध्य-स्ट्रीम में डिस्कनेक्ट करने वाला क्लाइंट जनरेटर को रद्द कर देता है, और आंशिक असिस्टेंट टेक्स्ट कभी सेव नहीं होता है। यह आमतौर पर सही व्यवहार है; यदि आप आंशिक जवाब रखना पसंद करते हैं, तो उन्हें finally ब्लॉक में स्टोर करें।
लागत योजना के लिए, एक पाली मानें जो 3,000 इनपुट टोकन भेजती है और 600 लौटाती है। प्रति मिलियन $0.15 और $0.50 पर, यह $0.00075 plus $0.0006, प्रति पाली लगभग $0.00135 है, इसलिए हज़ार पालियों की लागत लगभग $1.35 है। ये आंकड़े मान्यताएँ हैं; अपने वास्तविक आंकड़ों के लिए उपयोग खंड की जाँच करें। दरों के लिए मूल्य निर्धारण देखें, और विकल्पों के अवलोकन के लिए चैटबॉट API तुलना पढ़ें।
अधिक गाइड
प्रश्न और उत्तर
ब्राउज़र से सीधे मॉडल को क्यों नहीं बुलाया जाता?
API कुंजी हर आगंतुक के लिए दृश्यमान होगी। एक छोटा रिले कुंजी को निजी रखता है और आपको इतिहास और रेट लिमिट पर नियंत्रण देने की अनुमति देता है।
क्या स्ट्रीम में टोकन उपयोग शामिल है?
हाँ। एक अंतिम उपयोग चंक स्वचालित रूप से जोड़ा जाता है, और इसमें choices प्रविष्टियाँ नहीं होतीं, इसलिए पाठ निकालते समय उन चंक्स को छोड़ दें जिनमें वे नहीं हैं।
मुझे fetch के बजाय EventSource कब उपयोग करना चाहिए?
GET स्वीकार्य है और आपको बिल्ट-इन रिकनेक्शन चाहिए, तो EventSource का उपयोग करें। POST बॉडीज़ के लिए fetch का उपयोग करें, जिससे निजी टेक्स्ट URLs में नहीं रहता।
एक कुंजी कितने उपयोगकर्ताओं का समर्थन कर सकती है?
प्रति कुंजी प्रति मिनट 300 अनुरोध की सीमा है, जो आपके सभी उपयोगकर्ताओं के लिए साझा है, इसलिए रिले में प्रति-उपयोगकर्ता कूलडाउन जोड़ें।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएं, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।