ID ▾

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

Unfiltered AI

API LLM tanpa sensor untuk pengembang.

Unfiltered AIDapatkan kunci API

Backend chatbot tanpa filter dengan FastAPI dan server-sent events

Panduan ini meneruskan output model yang dialirkan melalui backend FastAPI kecil. Simpan kunci di server, isolasi riwayat percakapan berdasarkan sesi, dan tangani stream yang terputus sebelum menampilkan balasan sebagai selesai.

Backend chatbot tanpa filter dengan FastAPI dan server-sent events

Poin kunci

  • Penyedia inferensi khusus seperti Unfiltered AI menawarkan perilaku tanpa sensor yang konsisten pada satu model, menghindari keacakan dari routing agregator.
  • Agregator seperti OpenRouter menyediakan akses ke beberapa model tetapi mungkin bervariasi dalam seberapa ketat mereka menerapkan filter konten tergantung pada versi model tertentu.
  • Unfiltered AI menggunakan model bobot terbuka di perangkat keras khusus dengan jendela konteks 100k, dengan harga $0,15/$0,50 per juta token.
  • Untuk konsistensi NSFW atau roleplay yang ketat, API LLM tanpa sensor khusus menghilangkan kebutuhan rekayasa prompt kompleks untuk melewati filter umum.

Sistem sebagai gambar dalam kata-kata

Bayangkan tiga kotak berjejer dan dua panah di antaranya. Di sebelah kiri, browser. Di tengah, proses FastAPI Anda. Di sebelah kanan, endpoint model di https://api.unfilteredaiapi.com/v1. Panah kiri membawa satu pesan pengguna dan mengembalikan aliran bingkai teks kecil. Panah kanan membawa percakapan lengkap dan mengembalikan server-sent events. Kotak tengah melakukan tiga pekerjaan dan tidak lebih: menyimpan kunci API, memiliki status percakapan, dan mengonversi satu format aliran ke format lainnya.

Menyimpan kunci di kotak tengah adalah alasan lapisan ini ada. Kunci yang dikirim ke browser adalah kunci yang dipublikasikan kepada siapa saja yang membuka alat pengembang. Alasan kedua adalah status: browser hanya mengirim teks baru dan id sesi, sementara server memutuskan berapa banyak riwayat yang akan diputar ulang. Keputusan ini menjadi penting ketika percakapan berkembang, yang artikel memori bahas secara mendalam.

Semua di sini menggunakan format chat-completions standar dengan stream: true, jadi instal fastapi, uvicorn dan httpx dan tidak ada yang lain.

Apa yang tiba di panah sebelah kanan

Dengan streaming aktif, respons adalah urutan baris. Setiap baris yang berguna dimulai dengan data: diikuti oleh potongan JSON yang choices[0].delta.content-nya berisi beberapa karakter. Baris nyata terakhir adalah data: [DONE]. Tepat sebelum itu, potongan penggunaan ditambahkan secara otomatis; potongan ini membawa hitungan token dan tidak memiliki entri choices, sehingga relay harus menguji hal itu sebelum melakukan pengindeksan.

Perlakukan aliran sebagai tiga fase: awal yang tenang saat model membaca prompt Anda, aliran fragmen yang stabil, dan epilog singkat dengan penggunaan dan penanda. Relay di bawah ini meniru fase-fase tersebut. Ia meneruskan fragmen saat tiba, mengumpulkannya menjadi satu string, dan menulis string tersebut ke sesi hanya ketika aliran berakhir.

Endpoint relay

Intinya adalah generator async bernama stream_reply. StreamingResponse FastAPI mengonsumsinya dan mengosongkan setiap string yang dihasilkan ke klien. Dua rute membungkus generator yang sama: POST untuk fetch dan GET untuk 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"},
    )

Baca generator dari atas ke bawah. Ia menambahkan pesan pengguna terlebih dahulu, sehingga model melihatnya. Jika status upstream bukan 200, ia menghapus pesan itu lagi dan memancarkan peristiwa error, yang menjaga riwayat tetap bebas dari giliran yang belum dijawab. Pada keberhasilan, ia memancarkan setiap fragmen sebagai string JSON, yang merupakan cara newline dan kutipan bertahan dalam pembungkusan. Ketika loop berakhir, ia menyimpan teks asisten dan mengirim peristiwa done.

Dua header itu penting. Cache-Control: no-cache mencegah perantara menahan stream, dan X-Accel-Buffering: no memberi tahu proxy bergaya nginx untuk meneruskan byte segera.

Memilih penyimpanan sesi

Kamus dalam contoh adalah penyimpanan paling sederhana: satu daftar pesan per id sesi. Ini memiliki tiga keterbatasan nyata. Hilang saat restart, tidak dibagikan antar proses pekerja, dan tumbuh tanpa batas. Pilih langkah selanjutnya sesuai dengan keterbatasan mana yang paling terasa.

  1. Proses tunggal, sesi singkat: pertahankan kamus, tambahkan pembersihan berdasarkan waktu hidup yang menghapus sesi yang tidak aktif selama satu jam.
  2. Beberapa pekerja: pindahkan daftar pesan ke penyimpanan key-value bersama, dengan id sesi sebagai kunci dan array JSON sebagai nilai. Serialisasi akses per sesi agar dua permintaan simultan tidak dapat berselang-seling.
  3. Riwayat tahan lama: tulis setiap giliran ke baris basis data yang dikunci berdasarkan sesi dan nomor urut, dan muat bagian akhir secara permintaan.

Apa pun pilihan Anda, sembunyikan di balik dua fungsi, load(session_id) dan append(session_id, message), sehingga stream_reply tidak pernah tahu di mana data berada. Juga hasilkan id sesi di server, seperti yang dilakukan rute /session, dan perlakukan sebagai rahasia yang tidak dapat ditebak.

Bagian browser dengan fetch

Pada panah sebelah kiri, browser harus membaca body POST streaming. fetch mengeksposnya sebagai aliran yang dapat dibaca, dan TextDecoderStream mengubah byte menjadi teks. Bingkai dipisahkan oleh baris kosong, sehingga klien menyangga teks masuk dan memotong bingkai lengkap.

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

Halaman menulis dengan textContent, bukan innerHTML, sehingga output model tidak dapat menyuntikkan markup ke halaman Anda. Itu adalah kebiasaan kecil dengan imbalan besar ketika model menghasilkan fiksi sembarangan.

Mencoba relay sebelum menulis antarmuka depan

Uji kotak tengah secara terisolasi terlebih dahulu. Klien terminal menghapus browser dari persamaan, sehingga masalah apa pun yang Anda lihat milik relay. Opsi -N mematikan buffering output curl; tanpanya Anda akan melihat seluruh balasan tiba sekaligus dan salah menyimpulkan bahwa streaming rusak.

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

Anda harus melihat baris yang dimulai dengan data: , masing-masing membawa fragmen yang dikutip, lalu bingkai event: done akhir. Kirim pesan kedua dengan id sesi yang sama dan minta narator melanjutkan; jika ia melanjutkan dari mana ia berhenti, penyimpanan berfungsi. Jika semua baris tiba dalam satu ledakan, sesuatu di antara Anda dan proses melakukan buffering, dan tersangka umum adalah proxy terbalik dengan buffering respons yang masih aktif.

Setelah ini berhasil, halaman browser hanya perlu membaca frame yang sama. beranda situs dan dokumentasi mencantumkan bidang permintaan jika Anda ingin meneruskan lebih banyak opsi pengambilan sampel melalui relay.

Varian EventSource, dan komprominya

API EventSource browser menangani parsing dan koneksi ulang untuk Anda, tetapi hanya dapat mengeluarkan permintaan GET. Itulah sebabnya backend memiliki rute kedua. Biayanya adalah teks pengguna berjalan di URL, dan URL cenderung berakhir di log akses di mesin yang Anda jalankan. Untuk percakapan pribadi, lebih baik gunakan pendekatan POST dan 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());

Perhatikan pendengar done. Ketika server menutup stream event, EventSource mengasumsikan kesalahan jaringan dan terhubung kembali, yang akan mengirim pesan yang sama lagi. Menutup sumber sendiri pada done dan pada error memutus loop itu.

Mode kegagalan dan batas yang perlu dirancang di sekitarnya

Jalankan panah sekali lagi dan tanyakan apa yang dapat rusak di setiap sisi. Di sebelah kanan: 401 berarti kunci buruk, 402 berarti saldo habis, 403 berarti permintaan diblokir, 429 berarti Anda melewati 300 permintaan per menit pada kunci ini, dan 503 dengan upstream_busy layak dicoba lagi setelah beberapa detik. Relay menampilkannya semua sebagai satu acara error dengan status yang melekat, sehingga browser dapat memilih pesan.

Klien yang terputus di tengah stream membatalkan generator, dan teks asisten parsial tidak pernah disimpan. Itu biasanya perilaku yang tepat; jika Anda lebih suka menyimpan balasan parsial, simpan di blok finally.

Untuk perencanaan biaya, asumsikan satu giliran yang mengirim 3.000 token input dan mengembalikan 600. Pada $0,15 dan $0,50 per juta, itu adalah $0,00075 ditambah $0,0006, sekitar $0,00135 per giliran, sehingga seribu giliran biaya mendekati $1,35. Angka-angka ini adalah asumsi; periksa bagian penggunaan untuk angka asli Anda. Untuk tarif lihat harga, dan untuk gambaran pilihan baca perbandingan API chatbot.

Tanya jawab

Mengapa tidak memanggil model langsung dari browser?

Kunci API akan terlihat oleh setiap pengunjung. Relay kecil menjaga kunci tetap privat dan memungkinkan Anda mengontrol riwayat serta batas laju.

Apakah stream mencakup penggunaan token?

Ya. Chunk penggunaan akhir ditambahkan secara otomatis dan tidak memiliki entri choices, jadi lewati chunk tanpa entri tersebut saat mengekstrak teks.

Kapan saya harus menggunakan EventSource daripada fetch?

Gunakan EventSource ketika GET dapat diterima dan Anda menginginkan reconnection bawaan. Gunakan fetch untuk body POST, yang menjaga teks pribadi tetap keluar dari URL.

Berapa banyak pengguna yang dapat didukung satu kunci?

Batasnya adalah 300 permintaan per menit per kunci, dibagi di antara semua pengguna Anda, jadi tambahkan jeda waktu per pengguna di relay.

Kunci Anda hanya selangkah lagi dari satu formulir

Buat akun, salin kuncinya, ubah base URL. Itu saja seluruh penyiapannya.

Dapatkan kunci APIBaca dokumentasi