Um backend de chatbot sem filtros com FastAPI e eventos enviados pelo servidor
Este guia transmite a saída do modelo em streaming por meio de um pequeno backend FastAPI. Mantenha a chave no servidor, isole o histórico de conversas por sessão e trate fluxos interrompidos antes de exibir uma resposta como completa.

AtualizadoUnfiltered AI
Pontos principais
- Provedores de inferência dedicados como Unfiltered AI oferecem comportamento sem censura consistente em um único modelo, evitando a aleatoriedade do roteamento de agregadores.
- Agregadores como OpenRouter fornecem acesso a vários modelos, mas podem variar na aplicação rigorosa de filtros de conteúdo dependendo da versão específica do modelo.
- Unfiltered AI usa um modelo de pesos abertos em hardware dedicado com janela de contexto de 100k, com preço de $0,15/$0,50 por milhão de tokens.
- Para consistência estrita de NSFW ou roleplay, uma API LLM sem censura dedicada elimina a necessidade de engenharia de prompt complexa para contornar filtros genéricos.
O sistema como imagem em palavras
Imagine três caixas em linha e duas setas entre elas. À esquerda, o browser. No meio, seu processo FastAPI. À direita, o endpoint do modelo em https://api.unfilteredaiapi.com/v1. A seta esquerda carrega uma mensagem do usuário e retorna um stream de pequenos quadros de texto. A seta direita carrega a conversa completa e retorna eventos enviados pelo servidor. A caixa do meio faz três trabalhos e nada mais: ela guarda a chave de API, possui o estado da conversa e converte um formato de stream em outro.
Manter a chave na caixa do meio é o motivo de existir essa camada. Uma chave enviada para um navegador é uma chave publicada para todos que abrem as ferramentas de desenvolvedor. A segunda razão é o estado: o navegador envia apenas o novo texto e um id de sessão, enquanto o servidor decide quanto histórico reproduzir. Essa decisão se torna importante quando as conversas crescem, o que o artigo sobre memória trata em profundidade.
Tudo aqui usa o formato padrão de chat-completions com stream: true, então instale fastapi, uvicorn e httpx e nada mais.
O que chega na seta à direita
Com o streaming ativado, a resposta é uma sequência de linhas. Cada linha útil começa com data: seguida por um fragmento JSON cujo choices[0].delta.content contém alguns caracteres. A última linha real é data: [DONE]. Logo antes disso, um fragmento de uso é adicionado automaticamente; ele contém contagens de tokens e não possui entradas de choices, então o intermediário deve testar por isso antes de indexar.
Trate o stream como três fases: um início silencioso enquanto o modelo lê seu prompt, um fluxo constante de fragmentos e um epílogo curto com uso e o marcador. O intermediário abaixo espelha essas fases. Ele encaminha fragmentos conforme chegam, os acumula em uma única string e grava essa string na sessão apenas quando o fluxo termina.
O endpoint intermediário
O núcleo é um gerador assíncrono chamado stream_reply. O StreamingResponse do FastAPI o consome e descarrega cada string gerada para o cliente. Duas rotas envolvem o mesmo gerador: uma POST para fetch e uma 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"},
)Leia o gerador de cima para baixo. Ele anexa a mensagem do usuário primeiro, para que o modelo a veja. Se o status upstream não for 200, ele remove essa mensagem novamente e emite um evento error, o que mantém o histórico livre de turnos sem resposta. Em sucesso, ele emite cada fragmento como uma string JSON, que é como novas linhas e aspas sobrevivem ao framing. Quando o loop termina, ele armazena o texto do assistente e envia um evento done.
Os dois cabeçalhos são importantes. Cache-Control: no-cache impede que intermediários retenham o stream, e X-Accel-Buffering: no diz a um proxy estilo nginx para passar bytes imediatamente.
Escolhendo um repositório de sessões
O dicionário no exemplo é o armazenamento mais simples possível: uma lista de mensagens por id de sessão. Ele tem três limitações honestas. Ele desaparece na reinicialização, não é compartilhado entre processos de trabalho e cresce sem limites. Escolha o próximo passo de acordo com qual limitação dói primeiro.
- Processo único, sessões curtas: mantenha o dicionário, adicione uma varredura de tempo de vida que exclui sessões inativas por uma hora.
- Vários processos de execução: mova a lista de mensagens para um armazenamento de chave-valor compartilhado, com o id de sessão como chave e uma matriz JSON como valor. Serialize o acesso por sessão para que duas requisições simultâneas não se intercalem.
- Histórico durável: grave cada turno em uma linha de banco de dados chaves por sessão e número de sequência, e carregue o final sob demanda.
Qualquer que seja sua escolha, esconda-a atrás de duas funções, load(session_id) e append(session_id, message), para que o stream_reply nunca saiba onde os dados vivem. Além disso, gere ids de sessão no servidor, como a rota /session faz, e trate-os como segredos imprevisíveis.
O lado do cliente com fetch
Na seta à esquerda, o navegador deve ler o corpo de uma POST streaming. O fetch o expõe como um stream legível, e o TextDecoderStream converte bytes em texto. Os quadros são separados por uma linha em branco, então o cliente armazena em buffer o texto recebido e fatia os quadros 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>A página grava com textContent, nunca innerHTML, para que a saída do modelo não injete markup na sua página. Esse é um pequeno hábito com grande retorno quando o modelo está produzindo ficção arbitrária.
Testando o intermediário antes de escrever qualquer front-end
Teste a caixa do meio isoladamente primeiro. Um cliente terminal remove o navegador da equação, então qualquer problema que você ver pertence ao intermediário. A flag -N desativa o buffer de saída do curl; sem ela, você veria toda a resposta chegar de uma vez e concluiria erroneamente que o streaming está quebrado.
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.\"}"Você deve ver linhas começando com data: , cada uma carregando um fragmento entre aspas, seguido por um quadro final event: done. Envie uma segunda mensagem com o mesmo id de sessão e peça ao narrador para continuar; se ele pegar de onde parou, o armazenamento funciona. Se todas as linhas chegarem em um único lote, algo entre você e o processo está fazendo buffer, e o suspeito habitual é um proxy reverso com buffer de resposta ativado.
Depois que isso passar, a página do navegador é apenas uma questão de ler os mesmos quadros. A página inicial do site e a documentação listam os campos da requisição se você quiser passar mais opções de amostragem pelo intermediário.
A variante EventSource e suas desvantagens
A API EventSource do navegador cuida do processamento e reconexão para você, mas só pode emitir requisições GET. É por isso que o backend tem uma segunda rota. O custo é que o texto do usuário viaja na URL, e URLs tendem a acabar em logs de acesso em máquinas que você executa. Para conversas privadas, prefira a abordagem 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());Preste atenção ao listener done. Quando um servidor fecha um stream de eventos, o EventSource assume uma falha de rede e reconecta, o que enviaria a mesma mensagem novamente. Fechar a fonte você mesmo no done e no error quebra esse loop.
Modos de falha e limites para contornar
Percorra as setas mais uma vez e pergunte o que pode quebrar em cada uma. À direita: 401 significa chave inválida, 402 significa o saldo acabou, 403 significa a requisição foi bloqueada, 429 significa que você passou de 300 requisições por minuto nesta chave, e 503 com upstream_busy merece uma nova tentativa após alguns segundos. O relay expõe todos eles como um único evento error com o status anexado, para que o navegador possa escolher uma mensagem.
Um cliente que desconecta no meio do stream cancela o gerador, e o texto parcial do assistente nunca é salvo. Isso geralmente é o comportamento correto; se você preferir manter respostas parciais, armazene-as em um bloco finally.
Para planejamento de custos, assuma uma rodada que envia 3.000 tokens de entrada e retorna 600. A $0,15 e $0,50 por milhão, isso é $0,00075 mais $0,0006, cerca de $0,00135 por rodada, então mil rodadas custam perto de $1,35. Essas figuras são suposições; verifique o fragmento de uso para seus números reais. Para taxas, consulte preços, e para uma visão geral das opções, leia a comparação da API de chatbot.
Mais guias
Perguntas e respostas
Por que não chamar o modelo diretamente do navegador?
A chave de API seria visível para todos os visitantes. Um pequeno intermediário mantém a chave privada e permite que você controle o histórico e os limites de requisições.
O stream inclui uso de tokens?
Sim. Um chunk de uso final é adicionado automaticamente e não possui entradas de choices, então pule chunks sem elas ao extrair texto.
Quando devo usar EventSource em vez de fetch?
Use EventSource quando GET for aceitável e você quiser reconexão integrada. Use fetch para corpos POST, o que mantém o texto privado fora das URLs.
Quantos usuários uma chave pode suportar?
O limite é de 300 requisições por minuto por chave, compartilhado entre todos os seus usuários, então adicione um tempo de espera por usuário no intermediário.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave, altere a base URL. Essa é a configuração inteira.