Een ongecensureerde chatbot-backend met FastAPI en server-sent events
Deze handleiding stuurt de gestreamde modeloutput door via een kleine FastAPI-backend. Houd de sleutel op de server, isoleer de gespreksgeschiedenis per sessie en verwerk onderbroken streams voordat je een antwoord als voltooid weergeeft.

BijgewerktUnfiltered AI
Belangrijkste punten
- Gespecialiseerde inference providers zoals Unfiltered AI bieden consistente ongecensureerde gedrag op één model, waardoor je de willekeurigheid van aggregator routing vermijdt.
- Aggregators zoals OpenRouter bieden toegang tot meerdere modellen, maar kunnen variëren in hoe streng ze content filters toepassen afhankelijk van de specifieke modelversie.
- Unfiltered AI gebruikt een open-weight model op dedicated hardware met een contextvenster van 100k tokens, geprijsd op $0,15/$0,50 per miljoen tokens.
- Voor strikte NSFW- of roleplay-consistentie elimineert een dedicated ongecensureerd LLM API de behoefte aan complexe prompt engineering om generieke filters te omzeilen.
Het systeem als een plaatje in woorden
Stel je drie vakjes in een rij voor met twee pijlen ertussen. Links: de browser. Midden: je FastAPI proces. Rechts: het model endpoint op https://api.unfilteredaiapi.com/v1. De linkse pijl draagt één gebruikersbericht en retourneert een stream van kleine tekstframes. De rechtse pijl draagt het volledige gesprek en retourneert server-sent events. Het middelste vakje doet drie taken en niets meer: het houdt de API-sleutel, het beheert de gesprekstoestand en het zet de ene streamformaat om in het andere.
De sleutel in het middelste vakje houden is de reden dat deze laag bestaat. Een sleutel die naar een browser wordt gestuurd, is een sleutel die aan iedereen bekend is die de ontwikkelaarshulpmiddelen opent. De tweede reden is staat: de browser stuurt alleen de nieuwe tekst en een sessie-id, terwijl de server beslist hoeveel geschiedenis hij moet herhalen. Die beslissing wordt belangrijk zodra gesprekken groeien, wat het geheugenartikel diepgaand behandelt.
Alles hier gebruikt de standaard chat-completions formaat met stream: true, dus installeer fastapi, uvicorn en httpx en niets anders.
Wat aankomt op de rechterpijl
Met streaming aan is het antwoord een reeks regels. Elke nuttige regel begint met data: gevolgd door een JSON-chunk waarvan choices[0].delta.content een paar karakters bevat. De laatste echte regel is data: [DONE]. Net daarvoor wordt automatisch een verbruik-chunk toegevoegd; deze bevat token-tellingen en heeft geen choices-items, dus de relay moet daarop testen voordat hij indexeert.
Behandel de stream als drie fasen: een stille start terwijl het model je prompt leest, een constante stroom van fragmenten, en een korte epiloog met verbruik en de sentinel. De onderstaande relay spiegelt die fasen. Hij stuurt fragmenten door zodra ze aankomen, verzamelt ze tot één string en schrijft die string pas naar de sessieopslag wanneer de stroom eindigt.
Het relay endpoint
De kern is een async generator genaamd stream_reply. FastAPI's StreamingResponse verwerkt deze en spoelt elke opgeleverde string naar de client. Twee routes omhullen dezelfde generator: een POST voor fetch en een GET voor EventSource.
# 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"},
)Lees de generator van boven naar beneden. Hij voegt eerst de gebruikersboodschap toe, zodat het model die ziet. Als de upstream-status niet 200 is, verwijdert hij die boodschap weer en zendt een error-gebeurtenis uit, waardoor de geschiedenis vrij blijft van onbeantwoorde beurten. Bij succes zendt hij elk fragment uit als een JSON-string, waardoor nieuwe regels en aanhalingstekens de framing overleven. Wanneer de lus eindigt, slaat hij de assistant-tekst op en stuurt een done-gebeurtenis.
De twee headers zijn belangrijk. Cache-Control: no-cache voorkomt dat tussenpersonen de stream vasthouden, en X-Accel-Buffering: no vertelt een nginx-achtige proxy om bytes direct door te sturen.
Kiezen van een sessieopslag
De dictionary in het voorbeeld is de eenvoudigst mogelijke opslag: één lijst van berichten per sessie-id. Deze heeft drie eerlijke beperkingen. Hij verdwijnt bij een herstart, hij wordt niet gedeeld tussen worker-processen en hij groeit zonder limiet. Kies de volgende stap op basis van welke beperking het meest pijn doet.
- Eén proces, korte sessies: houd de dictionary aan, voeg een time-to-live-sweep toe die sessies verwijdert die een uur inactief zijn geweest.
- Meerdere workers: verplaats de berichtenlijst naar een gedeelde key-value-opslag, met de sessie-id als sleutel en een JSON-array als waarde. Serializeer de toegang per sessie zodat twee gelijktijdige verzoeken elkaar niet kunnen verstrengelen.
- Duurzame geschiedenis: schrijf elke beurt naar een database rij gekoppeld aan sessie en volgnummer, en laad de staart op aanvraag.
Wat je ook kiest, verberg het achter twee functies, load(session_id) en append(session_id, message), zodat stream_reply nooit weet waar de data leeft. Genereer ook sessie-ids op de server, zoals de /session route doet, en behandel ze als niet-geraadselbare geheimen.
De browserkant met fetch
Bij de pijl naar links moet de browser een streaming POST-lichaam lezen. fetch stelt dit beschikbaar als een leesbare stream, en TextDecoderStream zet bytes om in tekst. Frames worden gescheiden door een lege regel, dus de client buffer inkomende tekst en knipt complete frames eraf.
<!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>De pagina schrijft met textContent, nooit innerHTML, zodat model output geen markup in je pagina kan injecteren. Dat is een kleine gewoonte met een grote opbrengst wanneer het model willekeurige fictie produceert.
De relay testen voordat je een frontend schrijft
Test het middelste blok eerst op zichzelf. Een terminalclient verwijdert de browser uit de vergelijking, dus elk probleem dat je ziet, behoort toe aan de relay. De -N-vlag zet de uitvoerbuffering van curl uit; zonder deze zou je zien dat het hele antwoord in één keer aankomt en ten onrechte concluderen dat streaming kapot is.
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.\"}"Je zou regels moeten zien die beginnen met data: , elk met een geciteerd fragment, gevolgd door een laatste event: done-frame. Stuur een tweede bericht met dezelfde sessie-id en vraag de narrator om door te gaan; als hij oppakt waar hij stopte, werkt de opslag. Als de regels allemaal in één keer aankomen, bufferd er iets tussen jou en het proces, en de gebruikelijke verdachte is een reverse proxy met response buffering aan.
Zodra dit slaagt, is de browserpagina slechts een kwestie van het lezen van dezelfde frames. De site home en de docs vermelden de request-velden als je meer sampling opties via de relay wilt sturen.
De EventSource variant, en de afweging
De EventSource-API van de browser verzorgt parsing en reconnectie voor je, maar deze kan alleen GET-verzoeken uitvoeren. Daarom heeft de backend een tweede route. De prijs is dat de tekst van de gebruiker in de URL reist, en URLs belanden vaak in access logs op machines die jij runt. Voor privégesprepen geef je de voorkeur aan de POST- en fetch-aanpak.
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());Let op de done listener. Wanneer een server een event stream sluit, gaat EventSource uit van een netwerkfout en herverbindt, wat hetzelfde bericht opnieuw zou sturen. Sluit de bron zelf op done en op error breek die lus.
Foutmodi en limieten om rond te ontwerpen
Loop de pijlen nog eens na en vraag wat er op elk stuk kan breken. Rechts: een 401 betekent een slechte sleutel, een 402 betekent dat het saldo op is, een 403 betekent dat het verzoek is geblokkeerd, een 429 betekent dat je 300 verzoeken per minuut op deze sleutel hebt gepasseerd, en een 503 met upstream_busy verdient een retry na een paar seconden. De relay surfaceert ze allemaal als één error event met de status eraan, zodat de browser een bericht kan kiezen.
Een client die midden in de stream disconnecteert, annuleert de generator, en de gedeeltelijke assistant tekst wordt nooit opgeslagen. Dat is meestal het juiste gedrag; als je gedeeltelijke antwoorden wilt bewaren, sla ze dan op in een finally blok.
Voor kostenplanning, neem aan dat een beurt 3.000 input tokens stuurt en 600 retourneert. Bij $0,15 en $0,50 per miljoen is dat $0,00075 plus $0,0006, ongeveer $0,00135 per beurt, dus duizend beurten kosten bijna $1,35. Deze cijfers zijn aannames; controleer de usage chunk voor je echte getallen. Voor rates zie pricing, en voor een overzicht van keuzes lees de chatbot API vergelijking.
Meer handleidingen
Vragen en antwoorden
Waarom niet direct het model aanroepen vanuit de browser?
De API-sleutel is dan zichtbaar voor elke bezoeker. Een kleine relay houdt de sleutel privé en stelt je in staat geschiedenis en rate limits te beheren.
Bevat de stream token-gebruik?
Ja. Er wordt automatisch een laatste usage chunk toegevoegd; deze heeft geen choices entries, dus sla chunks zonder deze over bij het extraheren van tekst.
Wanneer gebruik ik EventSource in plaats van fetch?
Gebruik EventSource als GET acceptabel is en je ingebouwde herverbinding wilt. Gebruik fetch voor POST-lichamen, zodat privétekst niet in URL's terechtkomt.
Hoeveel gebruikers kan één sleutel ondersteunen?
De limiet is 300 verzoeken per minuut per sleutel, gedeeld door al je gebruikers, dus voeg een per-gebruiker cooldown in de relay toe.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.