Un backend de chatbot sans filtre avec FastAPI et les événements envoyés par le serveur
Ce guide relaie la sortie du modèle en streaming via un petit backend FastAPI. Gardez la clé sur le serveur, isolez l'historique des conversations par session et gérez les flux interrompus avant d'afficher une réponse comme complète.

Mis à jourUnfiltered AI
Points clés
- Les fournisseurs d'inférence dédiés comme Unfiltered AI offrent un comportement sans censure cohérent sur un modèle unique, évitant l'aléa du routage par agrégateur.
- Les agrégateurs comme OpenRouter donnent accès à plusieurs modèles, mais la façon dont ils appliquent strictement les filtres de contenu peut varier selon la version spécifique du modèle.
- Unfiltered AI utilise un modèle à poids ouverts sur du matériel dédié avec une fenêtre de contexte de 100k tokens, au prix de 0,15 $ / 0,50 $ par million de tokens.
- Pour une cohérence stricte en NSFW ou en jeu de rôle, une API LLM sans censure dédiée élimine le besoin d'un ingénierie de prompt complexe pour contourner les filtres génériques.
Le système en images et mots
Imaginez trois boîtes alignées et deux flèches entre elles. À gauche, le browser. Au milieu, votre processus FastAPI. À droite, l'endpoint du modèle à https://api.unfilteredaiapi.com/v1. La flèche de gauche transporte un message utilisateur et renvoie un flux de petits fragments de texte. La flèche de droite transporte la conversation complète et renvoie des événements envoyés par le serveur. La boîte du milieu accomplit trois tâches et rien de plus : elle conserve la clé API, elle gère l'état de la conversation, et elle convertit un format de flux en un autre.
Conserver la clé dans la boîte du milieu est la raison d'être de cette couche. Une clé envoyée au navigateur est une clé publiée pour tous ceux qui ouvrent les outils de développement. La deuxième raison est l'état : le navigateur n'envoie que le nouveau texte et un identifiant de session, tandis que le serveur décide combien d'historique rejouer. Cette décision devient importante lorsque les conversations s'allongent, ce que l'article sur la mémoire traite en profondeur.
Tout cela utilise le format standard chat-completions avec stream: true, donc installez fastapi, uvicorn et httpx et rien d'autre.
Ce qui arrive sur la flèche de droite
Avec le streaming activé, la réponse est une séquence de lignes. Chaque ligne utile commence par data: suivie d'un chunk JSON dont choices[0].delta.content contient quelques caractères. La dernière ligne réelle est data: [DONE]. Juste avant cela, un chunk d'utilisation est ajouté automatiquement ; il contient des compteurs de tokens et n'a pas d'entrées choices, donc le relais doit tester cette absence avant d'indexer.
Traitez le flux comme trois phases : un début calme pendant que le modèle lit votre prompt, un flux régulier de fragments, et un épilogue court avec l'utilisation et le sentinel. Le relais ci-dessous reflète ces phases. Il transmet les fragments à leur arrivée, les accumule en une seule chaîne, et écrit cette chaîne dans la session uniquement lorsque le flux se termine.
L'endpoint relais
Le cœur est un générateur asynchrone appelé stream_reply. Le StreamingResponse de FastAPI le consomme et vide chaque chaîne produite vers le client. Deux routes enveloppent le même générateur : une POST pour fetch et une GET pour 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"},
)Lisez le générateur de haut en bas. Il ajoute d'abord le message utilisateur, afin que le modèle le voie. Si le statut en amont n'est pas 200, il retire ce message et émet un événement error, ce qui garde l'historique exempt de tours sans réponse. En cas de succès, il émet chaque fragment sous forme de chaîne JSON, ce qui permet aux sauts de ligne et aux guillemets de survivre au formatage. Lorsque la boucle se termine, il stocke le texte de l'assistant et envoie un événement done.
Les deux en-têtes sont importants. Cache-Control: no-cache empêche les intermédiaires de conserver le flux, et X-Accel-Buffering: no indique à un proxy de style nginx de transmettre les octets immédiatement.
Choisir un magasin de sessions
Le dictionnaire dans l'exemple est le magasin le plus simple possible : une liste de messages par identifiant de session. Il présente trois limitations honnêtes. Il disparaît au redémarrage, il n'est pas partagé entre les processus workers, et il croît sans limite. Choisissez l'étape suivante en fonction de quelle limitation vous gêne le plus.
- Processus unique, sessions courtes : conservez le dictionnaire, ajoutez un balayage avec une durée de vie qui supprime les sessions inactives depuis une heure.
- Plusieurs workers : déplacez la liste de messages vers un magasin clé-valeur partagé, avec l'identifiant de session comme clé et un tableau JSON comme valeur. Sérialisez l'accès par session pour que deux requêtes simultanées ne s'entremêlent pas.
- Historique durable : écrivez chaque tour dans une ligne de base de données indexée par session et numéro de séquence, et chargez la fin à la demande.
Quel que soit votre choix, cachez-le derrière deux fonctions, load(session_id) et append(session_id, message), afin que stream_reply ignore où sont stockées les données. Générez également les identifiants de session sur le serveur, comme le fait la route /session, et traitez-les comme des secrets inviolables.
Le côté navigateur avec fetch
Sur la flèche de gauche, le navigateur doit lire un corps POST en streaming. fetch l'expose comme un flux lisible, et TextDecoderStream convertit les octets en texte. Les frames sont séparés par une ligne vide, donc le client met en mémoire tampon le texte entrant et découpe les frames complètes.
<!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>La page écrit avec textContent, jamais innerHTML, afin que la sortie du modèle ne puisse pas injecter de balises dans votre page. C'est une petite habitude avec un grand avantage lorsque le modèle produit des fictions arbitraires.
Tester le relais avant d'écrire le front-end
Testez la boîte du milieu isolément. Un client terminal retire le navigateur de l'équation, donc tout problème que vous voyez appartient au relais. Le drapeau -N désactive la mise en mémoire tampon de sortie de curl ; sans cela, vous verriez toute la réponse arriver d'un coup et concluriez à tort que le streaming est cassé.
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.\"}"Vous devriez voir des lignes commençant par data: , chacune transportant un fragment entre guillemets, puis une frame finale event: done. Envoyez un deuxième message avec le même identifiant de session et demandez au narrateur de continuer ; s'il reprend là où il s'est arrêté, le magasin fonctionne. Si toutes les lignes arrivent en une seule rafale, quelque chose entre vous et le processus met en mémoire tampon, et le suspect habituel est un proxy inverse avec la mise en mémoire tampon de réponse activée.
Une fois cela validé, la page du navigateur n'est qu'une question de lecture des mêmes frames. L'accueil du site et la documentation listent les champs de requête si vous souhaitez transmettre plus d'options d'échantillonnage via le relais.
La variante EventSource et ses compromis
L'API EventSource du navigateur gère l'analyse et la reconnexion pour vous, mais elle ne peut émettre que des requêtes GET. C'est pourquoi le backend a une deuxième route. Le coût est que le texte de l'utilisateur voyage dans l'URL, et les URL finissent souvent dans les journaux d'accès des machines que vous gérez. Pour les conversations privées, préférez l'approche POST et 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());Faites attention à l'écouteur done. Lorsqu'un serveur ferme un flux d'événements, EventSource suppose une erreur réseau et se reconnecte, ce qui enverrait le même message à nouveau. Fermez vous-même la source sur done et sur error pour briser cette boucle.
Modes de défaillance et limites à anticiper
Parcourez les flèches une fois de plus et demandez ce qui peut casser à chaque étape. À droite : un 401 signifie une clé invalide, un 402 signifie que le solde est épuisé, un 403 signifie que la requête a été bloquée, un 429 signifie que vous avez dépassé 300 requêtes par minute sur cette clé, et un 503 avec upstream_busy mérite une nouvelle tentative après quelques secondes. Le relais expose tous ces cas comme un seul événement error avec le statut joint, afin que le navigateur puisse choisir un message.
Un client qui se déconnecte en milieu de flux annule le générateur, et le texte partiel de l'assistant n'est jamais sauvegardé. C'est généralement le comportement souhaité ; si vous préférez conserver les réponses partielles, stockez-les dans un bloc finally.
Pour la planification des coûts, supposez un tour qui envoie 3 000 tokens d'entrée et en retourne 600. À 0,15 $ et 0,50 $ par million, cela représente 0,00075 $ plus 0,0006 $, soit environ 0,00135 $ par tour, donc mille tours coûtent près de 1,35 $. Ces chiffres sont des hypothèses ; vérifiez le chunk d'utilisation pour vos vrais chiffres. Pour les débits, consultez les tarifs, et pour un aperçu des choix, lisez la comparaison des API de chatbot.
Plus de guides
Questions et réponses
Pourquoi ne pas appeler le modèle directement depuis le navigateur ?
La clé API serait visible par tous les visiteurs. Un petit relais garde la clé privée et vous permet de contrôler l'historique et les limites de débit.
Le streaming inclut-il l'utilisation de tokens ?
Oui. Un dernier chunk d'utilisation est ajouté automatiquement et ne contient pas d'entrées choices, donc ignorez les chunks sans ces entrées lors de l'extraction du texte.
Quand dois-je utiliser EventSource plutôt que fetch ?
Utilisez EventSource lorsque GET est acceptable et que vous souhaitez une reconnexion intégrée. Utilisez fetch pour les corps de requête POST, ce qui garde les textes privés hors des URL.
Combien d'utilisateurs une clé peut-elle supporter ?
La limite est de 300 requêtes par minute par clé, partagée entre tous vos utilisateurs ; ajoutez donc un délai d'attente par utilisateur dans le relais.
Votre clé n'est qu'à un formulaire d'ici
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute l'installation.