Un backend chatbot senza filtri con FastAPI e server-sent events
Questa guida trasmette l'output del modello in streaming attraverso un piccolo backend FastAPI. Mantieni la chiave sul server, isola la cronologia delle conversazioni per sessione e gestisci gli stream interrotti prima di visualizzare una risposta come completa.

AggiornatoUnfiltered AI
Punti chiave
- Provider di inferenza dedicati come Unfiltered AI offrono un comportamento senza censura coerente su un singolo modello, evitando la casualità del routing degli aggregator.
- Aggregator come OpenRouter forniscono accesso a più modelli ma possono variare nella rigorosità dell'applicazione dei filtri sui contenuti a seconda della versione specifica del modello.
- Unfiltered AI utilizza un modello a pesi aperti su hardware dedicato con una finestra di contesto di 100.000 token, al prezzo di $0,15/$0,50 per milione di token.
- Per una coerenza NSFW rigorosa o per il roleplay, un'API LLM dedicata senza censura elimina la necessità di complesse tecniche di prompt engineering per aggirare i filtri generici.
Il sistema come immagine in parole
Immagina tre caselle in fila e due frecce tra di esse. A sinistra, browser. Al centro, il tuo processo FastAPI. A destra, l'endpoint del modello su https://api.unfilteredaiapi.com/v1. La freccia sinistra trasporta un messaggio utente e restituisce uno stream di piccoli frame di testo. La freccia destra trasporta l'intera conversazione e restituisce server-sent events. La casella centrale svolge tre compiti e nient'altro: conserva la chiave API, gestisce lo stato della conversazione e converte un formato di stream in un altro.
Mantenere la chiave nella casella centrale è il motivo per cui questo strato esiste. Una chiave inviata a un browser è una chiave pubblicata a tutti coloro che aprono gli strumenti per sviluppatori. La seconda ragione riguarda lo stato: il browser invia solo il nuovo testo e un ID di sessione, mentre il server decide quanto storico replayare. Questa decisione diventa importante quando le conversazioni crescono, come trattato in profondità l'articolo sulla memoria.
Tutto qui utilizza il formato standard chat-completions con stream: true, quindi installa fastapi, uvicorn e httpx e nient'altro.
Cosa arriva sulla freccia di destra
Con lo streaming attivo, la risposta è una sequenza di righe. Ogni riga utile inizia con data: seguita da un chunk JSON il cui choices[0].delta.content contiene alcuni caratteri. L'ultima riga reale è data: [DONE]. Proprio prima, viene aggiunto automaticamente un chunk di utilizzo; contiene i conteggi dei token e non ha voci choices, quindi il relay deve verificare questa condizione prima di indicizzare.
Tratta lo streaming come tre fasi: un avvio tranquillo mentre il modello legge il tuo prompt, un flusso costante di frammenti e un breve epilogo con i dettagli d'uso e il sentinella. Il relay qui sotto riflette quelle fasi. Inoltra i frammani man mano che arrivano, li accumula in una stringa e scrive quella stringa nella sessione solo quando il flusso termina.
L'endpoint relay
Il nucleo è un generatore asincrono chiamato stream_reply. StreamingResponse di FastAPI lo consuma e invia in flush ogni stringa restituita al client. Due route avvolgono lo stesso generatore: una POST per fetch e una GET per 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"},
)Leggi il generatore dall'alto verso il basso. Aggiunge prima il messaggio dell'utente, così il modello lo vede. Se lo stato upstream non è 200, rimuove di nuovo quel messaggio ed emette un evento error, mantenendo la cronologia libera dai turni senza risposta. In caso di successo, emette ogni frammento come stringa JSON, che è il modo in cui i newline e le virgolette sopravvivono al framing. Quando il ciclo termina, memorizza il testo dell'assistente e invia un evento done.
I due header sono importanti. Cache-Control: no-cache impedisce agli intermediari di trattenere lo stream, e X-Accel-Buffering: no dice a un proxy stile nginx di passare i byte immediatamente.
Scegliere un archivio di sessione
Il dizionario nell'esempio è il store più semplice possibile: una lista di messaggi per ogni session id. Ha tre limitazioni oneste. Scompare al riavvio, non è condiviso tra i processi worker e cresce senza limiti. Scegli il prossimo passo in base a quale limitazione ti dà più fastidio.
- Singolo processo, sessioni brevi: mantieni il dizionario, aggiungi una scansione time-to-live che elimina le sessioni inattive da un'ora.
- Più worker: sposta la lista dei messaggi in un store key-value condiviso, con il session id come chiave e un array JSON come valore. Serializza l'accesso per sessione in modo che due richieste simultanee non possano interleave.
- Cronologia durevole: scrivi ogni turno in una riga di database indicizzata per sessione e numero di sequenza, e carica la coda su richiesta.
Qualunque cosa tu scelga, nascondila dietro due funzioni, load(session_id) e append(session_id, message), così stream_reply non sa mai dove risiedono i dati. Genera anche gli ID sessione sul server, come fa la route /session, e trattali come segreti non indovinabili.
Il lato browser con fetch
Sulla freccia sinistra il browser deve leggere un corpo POST in streaming. fetch lo espone come stream leggibile, e TextDecoderStream converte i byte in testo. I frame sono separati da una riga vuota, quindi il client memorizza nella cache il testo in arrivo e taglia i frame completi.
<!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 pagina scrive con textContent, mai innerHTML, quindi l'output del modello non può iniettare markup nella tua pagina. Questa è una piccola abitudine con un grande vantaggio quando il modello produce narrativa arbitraria.
Provare il relay prima di scrivere il frontend
Testa la casella centrale in isolamento prima. Un client terminale rimuove il browser dall'equazione, quindi qualsiasi problema che vedi appartiene al relay. Il flag -N disabilita il buffering dell'output di curl; senza di esso vedresti l'intera risposta arrivare in una volta e concludere erroneamente che lo streaming è rotto.
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.\"}"Dovresti vedere righe che iniziano con data: , ciascuna che trasporta un frammento tra virgolette, poi un frame finale event: done. Invia un secondo messaggio con lo stesso ID sessione e chiedi al narratore di continuare; se riprende da dove si è fermato, l'archivio funziona. Se tutte le righe arrivano in un'unica raffica, qualcosa tra te e il processo sta facendo buffering, e il sospettato abituale è un reverse proxy con il buffering della risposta ancora attivo.
Una volta superato questo, la pagina browser è solo una questione di lettura degli stessi frame. La home del sito e la documentazione elencano i campi di richiesta se vuoi passare più opzioni di campionamento attraverso il relay.
La variante EventSource e i suoi compromessi
L'API EventSource del browser gestisce la parsing e la riconnessione per te, ma può emettere solo richieste GET. Ecco perché il backend ha una seconda route. Il costo è che il testo dell'utente viaggia nell'URL, e gli URL tendono a finire nei log di accesso sulle macchine che gestisci. Per conversazioni private preferisci l'approccio POST e 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());Presta attenzione all'ascoltatore done. Quando un server chiude uno stream di eventi, EventSource assume un errore di rete e si riconnette, il che invierebbe di nuovo lo stesso messaggio. Chiudi tu stesso la source su done e su error per interrompere quel ciclo.
Casi di errore e limiti da considerare nella progettazione
Percorri di nuovo le frecce e chiediti cosa può rompersi su ciascuna. A destra: un 401 significa una chiave errata, un 402 significa che il saldo è esaurito, un 403 significa che la richiesta è stata bloccata, un 429 significa che hai superato 300 richieste al minuto su questa chiave, e un 503 con upstream_busy merita un retry dopo qualche secondo. Il relay espone tutti questi come un unico evento error con lo status allegato, così il browser può scegliere un messaggio.
Un client che si disconnette a metà stream cancella il generatore e il testo parziale dell'assistente non viene mai salvato. Di solito è il comportamento corretto; se preferisci mantenere le risposte parziali, memorizzale in un blocco finally.
Per la pianificazione dei costi, supponi un turno che invia 3.000 token di input e restituisce 600. A $0,15 e $0,50 per milione, sono $0,00075 più $0,0006, circa $0,00135 per turno, quindi mille turni costano circa $1,35. Queste cifre sono assunzioni; controlla il chunk di utilizzo per i tuoi numeri reali. Per i tassi vedi i prezzi, e per una panoramica delle scelte leggi il confronto API chatbot.
Altre guide
Domande e risposte
Perché non chiamare il modello direttamente dal browser?
La chiave API sarebbe visibile a tutti i visitatori. Un piccolo relay mantiene la chiave privata e ti permette di controllare la cronologia e i limiti di richiesta.
Lo streaming include l'utilizzo di token?
Sì. Un ultimo chunk di utilizzo viene aggiunto automaticamente e non contiene voci choices, quindi salta i chunk privi di esse quando estrai il testo.
Quando devo usare EventSource invece di fetch?
Usa EventSource quando è accettabile GET e vuoi la riconnessione integrata. Usa fetch per i corpi POST, che mantiene il testo privato fuori dagli URL.
Quanti utenti può supportare una chiave?
Il limite è di 300 richieste al minuto per chiave, condiviso tra tutti i tuoi utenti, quindi aggiungi un cooldown per utente nel relay.
La tua chiave è a un modulo di distanza
Crea un account, copia la chiave, cambia l'URL di base. È tutta la configurazione.