Ein unzensiertes Chatbot-Backend mit FastAPI und Server-Sent Events
Dieser Leitfaden leitet die gestreamte Modellausgabe über ein kleines FastAPI-Backend weiter. Halte den Schlüssel auf dem Server, trenne den Gesprächsverlauf nach Sitzung und behandle unterbrochene Streams, bevor du eine Antwort als abgeschlossen anzeigst.

AktualisiertUnfiltered AI
Wichtige Punkte
- Dedizierte Inferenzanbieter wie Unfiltered AI bieten konsistentes unzensiertes Verhalten auf einem einzelnen Modell und vermeiden die Zufälligkeit von Aggregator-Routing.
- Aggregatoren wie OpenRouter bieten Zugriff auf mehrere Modelle, können sich jedoch darin unterscheiden, wie streng sie Inhaltsfilter je nach spezifischer Modellversion anwenden.
- Unfiltered AI verwendet ein Open-Weight-Modell auf dedizierter Hardware mit einem 100k-Kontextfenster, zum Preis von $0,15/$0,50 pro Million Token.
- Für strenge NSFW- oder Rollenspiel-Konsistenz eliminiert eine dedizierte unzensierte LLM-API die Notwendigkeit komplexer Prompt-Engineering-Methoden, um generische Filter zu umgehen.
Das System als Bild in Worten
Stell dir drei Boxen in einer Reihe und zwei Pfeile dazwischen vor. Links: browser. In der Mitte: dein FastAPI-Prozess. Rechts: der Modell-Endpunkt bei https://api.unfilteredaiapi.com/v1. Der linke Pfeil überträgt eine Benutzer-Nachricht und gibt einen Stream kleiner Textrahmen zurück. Der rechte Pfeil überträgt das vollständige Gespräch und gibt Server-Sent Events zurück. Die mittlere Box erledigt drei Aufgaben und nichts weiter: Sie hält den API-Schlüssel, sie besitzt den Gesprächszustand und sie konvertiert ein Stream-Format in ein anderes.
Den Schlüssel in der mittleren Box zu halten, ist der Grund, warum diese Ebene existiert. Ein Schlüssel, der an einen Browser gesendet wird, ist ein Schlüssel, der an jeden veröffentlicht wird, der die Entwickler-Tools öffnet. Der zweite Grund ist Zustand: Der Browser sendet nur den neuen Text und eine Session-ID, während der Server entscheidet, wie viel Verlauf wiedergegeben wird. Diese Entscheidung wird wichtig, sobald Gespräche wachsen, was der Memory-Artikel ausführlich behandelt.
Alles hier verwendet das Standard-Chat-Completions-Format mit stream: true, also installiere fastapi, uvicorn und httpx und nichts anderes.
Was am rechten Pfeil ankommt
Bei aktiviertem Streaming ist die Antwort eine Sequenz von Zeilen. Jede relevante Zeile beginnt mit data: gefolgt von einem JSON-Block, in dem choices[0].delta.content einige Zeichen enthält. Die letzte echte Zeile ist data: [DONE]. Direkt davor wird automatisch ein Nutzungsblock hinzugefügt; er enthält Token-Anzahlen und hat keine choices-Einträge, daher muss das Relay darauf testen, bevor es indiziert.
Behandle den Stream als drei Phasen: eine ruhige Startphase, während das Modell deinen Prompt liest, einen gleichmäßigen Fluss von Fragmenten und eine kurze Endphase mit Nutzung und dem Sentinel. Das unten stehende Relay spiegelt diese Phasen wider. Es leitet Fragmente weiter, sobald sie eintreffen, sammelt sie zu einem String und schreibt diesen String erst in die Session, wenn der Fluss endet.
Der Relay-Endpunkt
Der Kern ist ein asynchroner Generator namens stream_reply. FastAPIs StreamingResponse verbraucht ihn und überträgt jeden yielded String an den Client. Zwei Routen umschließen denselben Generator: ein POST für fetch und ein GET für 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"},
)Lies den Generator von oben nach unten. Er hängt die Benutzer-Nachricht zuerst an, damit das Modell sie sieht. Wenn der Upstream-Status nicht 200 ist, entfernt er diese Nachricht wieder und sendet ein error-Ereignis, was den Verlauf von unbeantworteten Zügen frei hält. Bei Erfolg sendet er jedes Fragment als JSON-String, so überleben Newlines und Anführungszeichen das Framing. Wenn die Schleife endet, speichert er den Assistenten-Text und sendet ein done-Ereignis.
Die zwei Header sind wichtig. Cache-Control: no-cache verhindert, dass Intermediäre den Stream halten, und X-Accel-Buffering: no weist einen nginx-ähnlichen Proxy an, Bytes sofort durchzulassen.
Wahl des Session-Speichers
Das Dictionary im Beispiel ist der denkbar einfachste Speicher: eine Liste von Nachrichten pro Session-ID. Es hat drei ehrliche Einschränkungen. Es verschwindet beim Neustart, es wird nicht zwischen Worker-Prozessen geteilt und es wächst unbegrenzt. Wähle den nächsten Schritt basierend darauf, welche Einschränkung am meisten schmerzt.
- Einzelner Prozess, kurze Sessions: behalte das Dictionary, füge einen Time-to-Live-Sweep hinzu, der Sessions löscht, die seit einer Stunde inaktiv sind.
- Mehrere Worker: verschiebe die Nachrichtenliste zu einem gemeinsamen Key-Value-Store, mit der Session-ID als Schlüssel und einem JSON-Array als Wert. Serialisiere den Zugriff pro Session, damit zwei gleichzeitige Anfragen nicht ineinander verschachtelt werden können.
- Dauerhafter Verlauf: schreibe jede Runde in eine Datenbankzeile, die nach Session und Sequenznummer keyt, und lade den Schwanz bei Bedarf.
Was auch immer du wählst, verberge es hinter zwei Funktionen, load(session_id) und append(session_id, message), damit stream_reply nie erfährt, wo die Daten leben. Generiere auch Session-IDs auf dem Server, wie es die /session-Route tut, und behandle sie als nicht erratbare Geheimnisse.
Das Browser-Ende mit fetch
Am linken Pfeil muss der Browser einen Streaming-POST-Körper lesen. fetch stellt ihn als lesbaren Stream bereit, und TextDecoderStream wandelt Bytes in Text um. Frames sind durch eine Leerzeile getrennt, also puffert der Client eingehenden Text und schneidet vollständige Frames ab.
<!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>Die Seite schreibt mit textContent, niemals innerHTML, damit Modellausgabe kein Markup in deine Seite injizieren kann. Das ist eine kleine Gewohnheit mit großer Auswirkung, wenn das Modell beliebige Fiktion erzeugt.
Das Relay testen, bevor du ein Frontend schreibst
Teste die mittlere Box isoliert. Ein Terminal-Client entfernt den Browser aus der Gleichung, also gehört jedes Problem, das du siehst, zum Relay. Die -N-Flagge schaltet das Output-Buffering von curl aus; ohne sie würdest du die gesamte Antwort gleichzeitig eintreffen sehen und fälschlicherweise schließen, dass Streaming kaputt ist.
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.\"}"Du solltest Zeilen sehen, die mit data: beginnen, jede mit einem zitierten Fragment, dann einen finalen event: done-Frame. Sende eine zweite Nachricht mit derselben Session-ID und bitte den Erzähler fortzufahren; wenn er dort weitermacht, wo er aufgehört hat, funktioniert der Speicher. Wenn alle Zeilen in einem Burst eintreffen, puffert etwas zwischen dir und dem Prozess, und der übliche Verdächtige ist ein Reverse-Proxy mit aktivtem Response-Buffering.
Sobald das besteht, ist die Browser-Seite nur noch eine Frage des Lesens derselben Frames. Die Seitenstartseite und die Dokumentation listen die Anfragefelder auf, wenn du mehr Sampling-Optionen durch das Relay leiten möchtest.
Die EventSource-Variante und ihr Kompromiss
Die EventSource-API des Browsers übernimmt Parsing und Wiederherstellung für dich, aber sie kann nur GET-Anfragen ausstellen. Deshalb hat das Backend eine zweite Route. Der Preis ist, dass der Text des Benutzers in der URL reist, und URLs landen tendenziell in Access-Logs auf Maschinen, die du betreibst. Für private Gespräche bevorzuge den POST- und fetch-Ansatz.
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());Achte auf den done-Listener. Wenn ein Server einen Event-Stream schließt, nimmt EventSource einen Netzwerkfehler an und stellt wieder her, was dieselbe Nachricht erneut sendet. Schließe die Quelle selbst bei done und bei error, um diese Schleife zu durchbrechen.
Ausfallmodi und Grenzen, die man umgehen kann
Gehe die Pfeile noch einmal durch und frage, was an jedem brechen kann. Rechts: 401 bedeutet ein falscher Schlüssel, 402 bedeutet, dass das Guthaben aufgebraucht ist, 403 bedeutet, dass die Anfrage blockiert wurde, 429 bedeutet, dass du 300 Anfragen pro Minute mit diesem Schlüssel überschritten hast, und 503 mit upstream_busy verdient einen Retry nach einigen Sekunden. Das Relay gibt alle als ein error-Ereignis mit dem Status aus, damit der Browser eine Nachricht wählen kann.
Ein Client, der während des Streams die Verbindung abbricht, bricht den Generator ab, und der teilweise Assistenten-Text wird nie gespeichert. Das ist normalerweise das richtige Verhalten; wenn du partielle Antworten behalten möchtest, speichere sie in einem finally-Block.
Für die Kostenplanung gehe von einem Turn aus, der 3.000 Input-Token sendet und 600 zurückgibt. Bei $0,15 und $0,50 pro Million sind das $0,00075 plus $0,0006, also etwa $0,00135 pro Turn, sodass tausend Turns in der Nähe von $1,35 kosten. Diese Werte sind Annahmen; prüfe den Nutzungsblock für deine echten Zahlen. Zu den Preisen siehst du pricing, und einen Überblick über die Auswahl findest du in the chatbot API comparison.
Weitere Anleitungen
Fragen und Antworten
Warum das Modell nicht direkt vom Browser aus aufrufen?
Der API-Schlüssel wäre für jeden Besucher sichtbar. Ein kleines Relay hält den Schlüssel privat und ermöglicht dir, Verlauf und Ratenlimits zu steuern.
Enthält das Streaming Token-Nutzung?
Ja. Ein finaler Usage-Chunk wird automatisch angehängt und enthält keine choices-Einträge, also überspringe Chunks ohne diese beim Extrahieren von Text.
Wann sollte ich EventSource statt fetch verwenden?
Verwende EventSource, wenn GET akzeptabel ist und du eine eingebaute Wiederverbindung möchtest. Verwende fetch für POST-Body-Daten, damit private Texte nicht in URLs landen.
Wie viele Nutzer kann ein einzelner Schlüssel unterstützen?
Das Limit liegt bei 300 Anfragen pro Minute pro Schlüssel, geteilt mit allen deinen Nutzern. Füge daher eine pro-Nutzer-Wartezeit im Relay hinzu.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel und ändere die Base URL. Das ist die gesamte Einrichtung.