繁中 ▾

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

Unfiltered AI

為開發者打造的原始、無審查 LLM API。

Unfiltered AI取得 API 金鑰

使用 FastAPI 與伺服器發送事件 (SSE) 的無審查聊天機器人後端

本指南透過小型 FastAPI 後端轉發串流的模型輸出。將金鑰保留在伺服器上,依會話隔離對話歷史,並在顯示回覆為完成之前處理中斷的串流。

使用 FastAPI 與伺服器發送事件 (SSE) 的無審查聊天機器人後端

重點摘要

  • 專屬推理供應商(如 Unfiltered AI)在單一模型上提供一致的無審查行為,避免了聚合器路由的隨機性。
  • OpenRouter 等聚合器提供多個模型的存取權,但根據特定模型版本的不同,它們套用內容篩選的嚴格程度可能會有所差異。
  • Unfiltered AI 使用開放權重模型,運行於專用硬體上,擁有 100k 上下文視窗,定價為每百萬 token $0.15/$0.50。
  • 對於嚴格的 NSFW 或角色扮演一致性,專屬的無審查 LLM API 消除了為繞過通用篩選器而進行複雜提示詞工程的必要。

以文字呈現的系統架構

想像一排三個方框與它們之間的兩支箭頭。左側是 browser。中間是你的 FastAPI 程序。右側是位於 https://api.unfilteredaiapi.com/v1 的 模型端點。左側箭頭傳送單筆使用者提示詞,並回傳一串短小的文字框架。右側箭頭傳送完整對話,並回傳伺服器發送的事件。中間方框僅執行三項工作:持有 API 金鑰、管理對話狀態,以及將一種串流格式轉換為另一種。

將金鑰保留在中間方框是此層存在的理由。將金鑰傳送至瀏覽器,等於將金鑰公開給所有開啟開發者工具的人。第二個原因是狀態:瀏覽器僅傳送新文字與工作階段 ID,而伺服器決定要重播多少歷史記錄。一旦對話變長,此決定就變得很重要,記憶體文章對此有深入探討。

此處所有內容均使用標準的 chat-completions 格式並設定 stream: true,因此只需安裝 fastapi、uvicorn 和 httpx 即可,無需其他套件。

右側箭頭接收的內容

啟用串流後,回應是一系列行。每個有效行都以 data: 開頭,後接一個 JSON chunk,其 choices[0].delta.content 包含幾個字元。最後一個有效行是 data: [DONE]。在此之前,系統會自動附加一個用量 chunk;它包含 token 計數且沒有 choices 條目,因此中繼服務必須在索引之前檢查此情況。

將串流視為三個階段:模型讀取提示詞時的靜默開始、穩定的片段流,以及包含用量和哨兵的短暫結尾。下方的中繼服務反映了這些階段。它轉發到達的片段,將它們累積為一個字串,並在流結束時將該字串寫入會話。

中繼端點

核心是一個名為 stream_reply 的非同步生成器。FastAPI 的 StreamingResponse 會消耗它並將每個產生的字串刷新給客戶端。兩個路由包裝了相同的生成器:一個用於 fetch 的 POST,以及一個用於 EventSource 的 GET。

# 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"},
    )

由上至下閱讀產生器。它先附加使用者提示詞,因此模型能看到它。如果上游狀態不是 200,它會再次移除該提示詞並發出 error 事件,藉此保留歷史記錄不含未獲回應的回合。成功時,它會將每個片段作為 JSON 字串發出,這樣換行符號和引號才能在框架中正確傳輸。當迴圈結束時,它會儲存助手文字並發送 done 事件。

這兩個標頭很重要。Cache-Control: no-cache 可防止中繼服務保留串流,而 X-Accel-Buffering: no 則告知類似 nginx 的代理伺服器立即透傳位元組。

選擇會話儲存區

範例中的字典是最簡單的儲存方式:每個工作階段 ID 對應一個訊息列表。它有明顯的限制。重新啟動時會消失,不會在工作程序之間共用,且會無限制增長。根據哪一個限制最讓你困擾來選擇下一步。

  1. 單一程序、短工作階段:保留字典,並加入時間到期掃描,刪除閒置一小時的工作階段。
  2. 多個工作程序:將訊息列表移至共享的鍵值儲存區,以會話 ID 為鍵,JSON 陣列為值。針對每個會話序列化存取,以防止兩個同時請求交錯。
  3. 持久歷史:將每個回合寫入以工作階段和序列號為鍵的資料庫資料列,並在需要時載入最後部分。

無論你選擇什麼,都將它封裝在兩個函式之後,load(session_id) 與 append(session_id, message),這樣 stream_reply 就永遠不會知道資料存在哪裡。此外,請在伺服器上產生 session id,就像 /session 路由那樣,並將它們視為不可猜測的密碼。

使用 fetch 的瀏覽器端

在左側箭頭上,瀏覽器必須讀取串流 POST 主體。fetch 將其暴露為可讀取串流,而 TextDecoderStream 將位元組轉換為文字。框架由空行分隔,因此用戶端會緩衝收到的文字並切出完整的框架。

<!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>

頁面使用 textContent 寫入,而非 innerHTML,因此模型輸出無法在頁面中注入標記。這是一個小習慣,但當模型產生任意虛構內容時,回報卻很大。

在編寫任何前端之前測試中繼服務

首先單獨測試中間方框。終端機客戶端將瀏覽器排除在變數之外,因此你看到的任何問題都屬於中繼服務。-N 旗標會關閉 curl 的輸出緩衝;否則你會看到整個回覆同時到達,並錯誤地認為串流已損壞。

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.\"}"

你應該看到以 data: 開頭的行,每行攜帶一個引用的片段,然後是最終的 event: done 框架。使用相同的工作階段 ID 發送第二則訊息,並要求敘述者繼續;如果它從停止的地方繼續,則儲存區運作正常。如果所有行都同時到達,則你與程序之間的某個地方正在緩衝,而常見的嫌疑對象是開啟了回應緩衝的反向代理伺服器。

一旦通過此測試,瀏覽器頁面僅需讀取相同的框架即可。網站首頁 和 文件 列出了請求欄位,如果你想透過中繼服務傳遞更多採樣選項。

EventSource 變體及其權衡

瀏覽器的 EventSource API 會為你處理解析和重新連線,但它只能發出 GET 請求。這就是後端有第二個路由的原因。代價是使用者的文字會出現在 URL 中,而 URL 往往會出現在你運行的機器的存取記錄中。對於私密對話,請優先使用 POST 和 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());

注意 done 監聽器。當伺服器關閉事件串流時,EventSource 會假設是網路故障並重新連線,這會再次發送相同的訊息。在 done 和 error 上自行關閉來源會打破該迴圈。

失效模式與設計考量

再次檢查箭頭並詢問每處可能出現的問題。右側:401 表示金鑰錯誤,402 表示餘額已用完,403 表示請求被阻止,429 表示你已超過此金鑰每分鐘 300 個請求的限制,而帶有 upstream_busy 的 503 則值得在幾秒後重試。中繼服務會將所有這些情況作為帶有狀態附加的單一 error 事件呈現,以便瀏覽器選擇訊息。

在串流中斷時斷開連線的客戶端會取消產生器,導致部分助手文字不會被儲存。這通常是正確的行為;如果你偏好保留部分回覆,請將它們儲存在 finally 區塊中。

為了成本規劃,請假設一輪對話傳送 3,000 個輸入 token 並回傳 600 個 token。以每百萬個 token $0.15 與 $0.50 計算,這代表 $0.00075 加上 $0.0006,每輪約為 $0.00135,因此一千輪的成本接近 $1.35。這些數值是假設值;請查看用量區塊以取得你的實際數據。關於費率請見 定價,關於選項概覽請閱讀 聊天機器人 API 比較。

問答

為什麼不直接從瀏覽器呼叫模型?

API 金鑰將對所有訪客可見。小型中繼服務可保護金鑰隱私,並讓你控制歷史記錄與速率限制。

串流輸出是否包含 token 用量?

是的。最後一個用量區塊會自動附加,且該區塊沒有 choices 項目,因此在提取文字時,請跳過沒有該項目的區塊。

我應該在什麼時候使用 EventSource 而不是 fetch?

當 GET 可接受且需要內建重新連線功能時,請使用 EventSource。使用 fetch 處理 POST 主體,可將私密文字保留在 URL 之外。

一個金鑰能支援多少使用者?

限制為每分鐘每支金鑰 300 個請求,所有使用者共用,因此請在中繼服務中為每個使用者加入冷卻時間。

只差一張表單,即可取得金鑰

建立帳戶、複製金鑰、更改 Base URL。這就是完整的設定。

取得 API 金鑰閱讀文件