PT ▾

unfilteredaiapi.comhttps://api.unfilteredaiapi.com/v1

Unfiltered AI

API LLM sem filtros e sem censura para desenvolvedores.

Unfiltered AIObter chave de API

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.

Um backend de chatbot sem filtros com FastAPI e eventos enviados pelo servidor

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.

  1. Processo único, sessões curtas: mantenha o dicionário, adicione uma varredura de tempo de vida que exclui sessões inativas por uma hora.
  2. 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.
  3. 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.

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.

Obter chave de APILer a documentação