Un backend de chatbot sin filtros con FastAPI y eventos enviados por el servidor
Esta guía retransmite la salida del modelo en streaming a través de un pequeño backend FastAPI. Mantén la clave en el servidor, aísla el historial de conversación por sesión y maneja las transmisiones interrumpidas antes de mostrar una respuesta como completa.

ActualizadoUnfiltered AI
Puntos clave
- Proveedores de inferencia dedicados como Unfiltered AI ofrecen comportamiento sin censura consistente en un único modelo, evitando la aleatoriedad del enrutamiento de agregadores.
- Los agregadores como OpenRouter proporcionan acceso a múltiples modelos, pero pueden variar en la estrictitud de sus filtros de contenido según la versión específica del modelo.
- Unfiltered AI utiliza un modelo de pesos abiertos en hardware dedicado con una ventana de contexto de 100k tokens, a $0,15/$0,50 por millón de tokens.
- Para una consistencia estricta de NSFW o roleplay, una API LLM sin censura dedicada elimina la necesidad de ingeniería de prompts compleja para eludir filtros genéricos.
El sistema como imagen en palabras
Dibuja tres cajas en fila y dos flechas entre ellas. A la izquierda, el browser. En el medio, tu proceso FastAPI. A la derecha, el endpoint del modelo en https://api.unfilteredaiapi.com/v1. La flecha izquierda transporta un mensaje del usuario y devuelve un streaming de pequeños fragmentos de texto. La flecha derecha transporta la conversación completa y devuelve eventos enviados por el servidor. La caja del medio hace tres trabajos y nada más: guarda la clave de API, gestiona el estado de la conversación y convierte un formato de streaming en otro.
Mantener la clave en la caja central es la razón de existir de esta capa. Una clave enviada al navegador es una clave publicada para todos los que abran las herramientas de desarrollo. La segunda razón es el estado: el navegador envía solo el texto nuevo y un id de sesión, mientras que el servidor decide cuánto historial reproducir. Esta decisión se vuelve importante cuando las conversaciones crecen, algo que el artículo de memoria trata en profundidad.
Todo aquí usa el formato estándar de chat-completions con stream: true, así que instala fastapi, uvicorn y httpx y nada más.
Lo que llega en la flecha derecha
Con streaming activado, la respuesta es una secuencia de líneas. Cada línea útil comienza con data: seguido de un fragmento JSON cuyo choices[0].delta.content contiene unos pocos caracteres. La última línea real es data: [DONE]. Justo antes, se añade automáticamente un fragmento de uso; contiene conteos de tokens y no tiene entradas en choices, por lo que el intermediario debe verificar eso antes de indexar.
Trata el flujo como tres fases: un inicio tranquilo mientras el modelo lee tu prompt, un flujo constante de fragmentos y un breve epílogo con el uso y la señal final. El intermediario de abajo refleja esas fases. Reenvía los fragmentos a medida que llegan, los acumula en una sola cadena y escribe esa cadena en la sesión solo cuando termina el flujo.
El endpoint del intermediario
El núcleo es un generador asíncrono llamado stream_reply. StreamingResponse de FastAPI lo consume y envía cada cadena generada al cliente. Dos rutas envuelven el mismo generador: una POST para fetch y una GET para 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"},
)Lee el generador de arriba a abajo. Añade primero el mensaje del usuario para que el modelo lo vea. Si el estado upstream no es 200, elimina ese mensaje de nuevo y emite un evento error, lo que mantiene el historial libre de turnos sin responder. En éxito emite cada fragmento como una cadena JSON, que es cómo los saltos de línea y comillas sobreviven al enmarcado. Cuando el bucle termina, guarda el texto del asistente y envía un evento done.
Los dos encabezados importan. Cache-Control: no-cache evita que los intermediarios retengan el flujo, y X-Accel-Buffering: no indica a un proxy estilo nginx que pase los bytes de inmediato.
Elegir un almacén de sesiones
El diccionario en el ejemplo es el almacén más simple posible: una lista de mensajes por id de sesión. Tiene tres limitaciones honestas. Desaparece en el reinicio, no se comparte entre procesos worker y crece sin límites. Elige el siguiente paso según qué limitación duela primero.
- Proceso único, sesiones cortas: mantén el diccionario, añade un barrido de tiempo de vida que elimine sesiones inactivas durante una hora.
- Varios workers: mueve la lista de mensajes a un almacén de clave-valor compartido, con el id de sesión como clave y una matriz JSON como valor. Serializa el acceso por sesión para que dos peticiones simultáneas no se entrelacen.
- Historial persistente: escribe cada turno en una fila de base de datos con clave por sesión y número de secuencia, y carga el final bajo demanda.
Lo que elijas, ocúltalo detrás de dos funciones, load(session_id) y append(session_id, message), para que stream_reply nunca sepa dónde viven los datos. También genera los ids de sesión en el servidor, como hace la ruta /session, y trátalos como secretos difíciles de adivinar.
El extremo del navegador con fetch
En la flecha de la izquierda, el navegador debe leer un cuerpo POST de streaming. fetch lo expone como un flujo legible, y TextDecoderStream convierte bytes en texto. Los frames se separan por una línea en blanco, por lo que el cliente almacena en búfer el texto entrante y extrae los frames completos.
<!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 página escribe con textContent, nunca innerHTML, por lo que la salida del modelo no puede inyectar marcado en tu página. Ese es un pequeño hábito con un gran beneficio cuando el modelo produce ficción arbitraria.
Probando el intermediario antes de escribir cualquier frontend
Prueba primero el cuadro central de forma aislada. Un cliente de terminal elimina el navegador de la ecuación, por lo que cualquier problema que veas pertenece al intermediario. La bandera -N desactiva el almacenamiento en búfer de salida de curl; sin ella verías llegar toda la respuesta de golpe y concluirías erróneamente que el streaming está roto.
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.\"}"Deberías ver líneas que comienzan con data: , cada una con un fragmento entre comillas, y luego un frame event: done. Envía un segundo mensaje con el mismo id de sesión y pide al narrador que continúe; si retoma donde se detuvo, la tienda funciona. Si todas las líneas llegan de golpe, algo entre tú y el proceso está almacenando en búfer, y el sospechoso habitual es un proxy inverso con almacenamiento en búfer de respuesta activado.
Una vez que esto pase, la página del navegador solo consiste en leer los mismos frames. La página de inicio y la documentación enumeran los campos de petición si quieres pasar más opciones de muestreo a través del intermediario.
La variante EventSource y sus compensaciones
La API EventSource del navegador maneja el análisis y la reconexión por ti, pero solo puede emitir peticiones GET. Por eso el backend tiene una segunda ruta. El costo es que el texto del usuario viaja en la URL, y las URLs tienden a terminar en registros de acceso en máquinas que ejecutas. Para conversaciones privadas prefiere el enfoque POST y 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 atención al oyente done. Cuando un servidor cierra un stream de eventos, EventSource asume un fallo de red y se reconecta, lo que enviaría el mismo mensaje de nuevo. Cierra la fuente tú mismo en done y en error para romper ese bucle.
Modos de fallo y límites a considerar
Recorre las flechas una vez más y pregunta qué puede romperse en cada una. A la derecha: un 401 significa una clave incorrecta, un 402 significa que el saldo se agotó, un 403 significa que la petición fue bloqueada, un 429 significa que superaste 300 peticiones por minuto en esta clave, y un 503 con upstream_busy merece un reintento después de unos segundos. El relay expone todos ellos como un único evento error con el estado adjunto, para que el navegador pueda elegir un mensaje.
Un cliente que se desconecta a mitad del stream cancela el generador, y el texto parcial del asistente nunca se guarda. Eso suele ser el comportamiento correcto; si prefieres guardar respuestas parciales, guárdalas en un bloque finally.
Para la planificación de costos, asume un turno que envía 3.000 tokens de entrada y devuelve 600. A $0,15 y $0,50 por millón, eso es $0,00075 más $0,0006, aproximadamente $0,00135 por turno, por lo que mil turnos cuestan cerca de $1,35. Estas cifras son suposiciones; consulta el fragmento de uso para tus números reales. Para las tarifas, consulta la estructura de precios, y para una visión general de las opciones, lee la comparación de APIs de chatbot.
Más guías
Preguntas y respuestas
¿Por qué no llamar al modelo directamente desde el navegador?
La clave de API sería visible para todos los visitantes. Un pequeño intermediario mantiene la clave privada y te permite controlar la historia y los límites de peticiones.
¿Incluye el stream el uso de tokens?
Sí. Se añade automáticamente un fragmento de uso final, que no tiene entradas de choices, así que omite los fragmentos sin ellas al extraer el texto.
¿Cuándo debo usar EventSource en lugar de fetch?
Usa EventSource cuando GET sea aceptable y quieras reconexión automática. Usa fetch para cuerpos POST, lo que mantiene el texto privado fuera de las URLs.
¿Cuántos usuarios puede soportar una clave?
El límite es de 300 peticiones por minuto por clave, compartido entre todos tus usuarios, por lo que añade un enfriamiento por usuario en el intermediario.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la base URL. Eso es toda la configuración.