JA ▾

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

Unfiltered AI

開発者向けの生きた、無検閲のLLM API。

Unfiltered AIAPI キーを取得

FastAPIとサーバー送信イベントによる無検閲チャットボットバックエンド

このガイドでは、ストリーミングされたモデルの出力を小さなFastAPIバックエンド経由で中継します。キーをサーバーに保持し、セッションごとに会話履歴を分離し、中断されたストリームを処理してから、返信を完了として表示してください。

FastAPIとサーバー送信イベントによる無検閲チャットボットバックエンド

主要ポイント

  • Unfiltered AIのような専用推論プロバイダーは、アグリゲータールーティングのランダム性を避け、単一モデルで一貫した無検閲動作を提供します。
  • OpenRouterのようなアグリゲーターは複数のモデルにアクセスできますが、特定のモデルバージョンに応じてコンテンツフィルターの適用厳格さが異なる場合があります。
  • Unfiltered AIは専用ハードウェア上で100kのコンテキストウィンドウを持つオープンウェイトモデルを使用し、トークン100万あたり$0.15/$0.50で提供されます。
  • 厳格なNSFWやロールプレイの一貫性が必要な場合、専用無検閲LLM APIを使用することで、汎用フィルターを回避するための複雑なプロンプトエンジニアリングの必要性がなくなります。

システムを言葉で図解

3つの箱と2つの矢印を横に並べた図を想像してください。左側にbrowser、中央にあなたのFastAPIプロセス、右側にhttps://api.unfilteredaiapi.com/v1にあるモデルエンドポイントを配置します。左の矢印は1つのユーザーメッセージを運び、小さなテキストフレームのストリームを返します。右の矢印は会話全体を運び、サーバー送信イベントを返します。中央のボックスは3つの仕事のみを行います:APIキーの保持、会話状態の管理、1つのストリーム形式から別の形式への変換です。

キーを中央のボックスに保持することが、このレイヤーが存在する理由です。ブラウザに配布されたキーは、開発者ツールを開くすべての人に公開されたことになります。2つ目の理由はステートです。ブラウザは新しいテキストとセッションIDのみを送信し、サーバーが履歴をどれくらい再生するかを決定します。この判断はメモリ記事で深く扱われているように、会話の長さが伸びると重要になります。

ここですべての処理はstream: true付きの標準的なchat-completions形式を使用するため、fastapi、uvicorn、httpxをインストールし、それ以外は何もしなくて構いません。

右矢印で何が届くか

ストリーミングを有効にすると、レスポンスは行のシーケンスになります。各有用な行はdata: で始まり、choices[0].delta.contentに数文字分の内容を持つJSONチャンクが続きます。最後の実際の行はdata: [DONE]です。その直前に、トークン数を含む使用量チャンクが自動的に追加されます。このチャンクにはchoicesエントリがないため、インデックスを作成する前にこれを検出する必要があります。

ストリームを3つのフェーズとして扱います:モデルがプロンプトを読んでいる間の静かな開始、断片の安定した流れ、使用量とセンティネルを含む短いエピローグ。以下に示すリレーはこれらのフェーズを反映しています。到着した断片を転送し、1つの文字列に蓄積し、流れが終了したときにのみその文字列をセッションに書き込みます。

リレーエンドポイント

コアとなるのはstream_replyという非同期ジェネレーターです。FastAPIのStreamingResponseはこれを消費し、生成された各文字列をクライアントにフラッシュします。同じジェネレーターをラップする2つのルートがあります: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イベントを送信します。

2つのヘッダーが重要です。Cache-Control: no-cacheはインターメディアがストリームを保持しないようにし、X-Accel-Buffering: noはnginxスタイルのプロキシにバイトをすぐに通過させるよう指示します。

セッションストアの選択

例の辞書は最も単純なストアです。セッションIDごとにメッセージのリストを1つ持ちます。これには3つのありのままの制限があります。再起動時に消去される、ワーカープロセス間で共有されない、そして制限なく成長する。どの制限が最も深刻かによって、次のステップを選択してください。

  1. 単一プロセス、短期セッション:辞書を保持し、1時間アイドル状態のセッションを削除するTTLスイープを追加します。
  2. 複数のワーカー: メッセージリストを共有のキーバリューストアに移動します。セッションIDをキーとし、JSON配列を値とします。セッションごとにアクセスを直列化し、2つの同時リクエストがインターリーブしないようにします。
  3. 永続的な履歴:各ターンをセッションとシーケンス番号をキーとするデータベース行に書き込み、必要に応じてテールをロードします。

何を選択しても、load(session_id)とappend(session_id, message)という2つの関数の背後に隠し、stream_replyがデータがどこにあるかを知らないようにします。また、/sessionルートが行うようにセッションIDをサーバー上で生成し、それらを推測不可能な秘密として扱います。

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で2番目のメッセージを送信し、ナレーターに続編を依頼します。もし停止した場所から再開すれば、ストアは正常に動作しています。もし行が一括で到着する場合、あなたとプロセスの間にバッファリングが発生している可能性があります。通常の疑わしい対象は、レスポンスバッファリングが有効になっているリバースプロキシです。

このテストが通れば、ブラウザページは同じフレームの読み取りのみです。サイトホームとドキュメントは中継に渡すサンプリングオプションのフィールドをリストします。

EventSource版とそのトレードオフ

ブラウザのEventSource APIは、解析と再接続を処理しますが、GETリクエストのみを発行できます。そのためバックエンドには2つ目のルートが用意されています。その代償として、ユーザーのテキストは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はこのキーで1分間に300リクエストを超えた、503でupstream_busyの場合は数秒後に再試行すべきことを示します。リレーはこれらすべてをステータスが添付された1つのerrorイベントとして表示するため、ブラウザはメッセージを選択できます。

ストリーミング中にクライアントが切断すると、ジェネレーターがキャンセルされ、部分的なアシスタントテキストは保存されません。通常これは適切な動作ですが、部分的な返信を保持したい場合は、finallyブロックに保存してください。

コスト計画では、3,000トークンの入力と600トークンの出力を伴うターンを想定してください。100万トークンあたり$0.15および$0.50の場合、1ターンあたり$0.00075と$0.0006、合計約$0.00135となり、1,000ターンのコストは約$1.35です。これらの数値は仮定です。実際の使用量チャンクをご確認ください。料率は料金表、選択肢の概要はチャットボットAPI比較をご覧ください。

質問と回答

ブラウザから直接モデルにリクエストを送らないのはなぜか?

APIキーはすべての訪問者に表示されます。小さなリレーはキーをプライベートに保ち、履歴とレート制限を制御できます。

ストリームにはトークン使用量が含まれますか?

はい。最終的な使用量チャンクが自動的に追加され、choicesエントリが含まれないため、テキスト抽出時にはそれらのチャンクをスキップします。

fetchの代わりにEventSourceを使用するのはいつか?

GETが許容され、組み込みのリコネクションを希望する場合はEventSourceを使用します。POST本文にはfetchを使用します。これにより、プライベートなテキストがURLに含まれないようにします。

1つのAPI キーで何人のユーザーをサポートできますか?

制限はAPI キーあたり1分間あたり300リクエストで、すべてのユーザーで共有されます。リレーにユーザーごとのクールダウンを追加してください。

キーはフォーム 1 つで手に入ります

アカウントを作成し、API キーをコピーし、ベースURLを変更します。これがセットアップのすべてです。

API キーを取得ドキュメントを読む