TH ▾

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

Unfiltered AI

API LLM แบบ raw และไม่เซ็นเซอร์สำหรับนักพัฒนา

Unfiltered AIรับคีย์ API

แบ็กเอนด์แชทบอทแบบไม่เซ็นเซอร์ด้วย FastAPI และ server-sent events

คู่มือนี้ส่งต่อผลลัพธ์แบบสตรีมมิงของโมเดลผ่านแบ็กเอนด์ FastAPI ขนาดเล็ก เก็บคีย์ไว้ที่เซิร์ฟเวอร์ แยกประวัติการสนทนาตามเซสชัน และจัดการสตรีมที่ขาดหายก่อนแสดงการตอบกลับว่าเสร็จสมบูรณ์

แบ็กเอนด์แชทบอทแบบไม่เซ็นเซอร์ด้วย FastAPI และ server-sent events

ประเด็นสำคัญ

  • ผู้ให้บริการอนุมานเฉพาะทางเช่น Unfiltered AI ให้พฤติกรรมแบบไม่เซ็นเซอร์ที่สม่ำเสมอบนโมเดลเดียว หลีกเลี่ยงความสุ่มจากการจัดเส้นทางโดยตัวรวม
  • ตัวรวมเช่น OpenRouter ให้การเข้าถึงโมเดลหลายตัว แต่อาจมีความแตกต่างในวิธีการใช้ตัวกรองเนื้อหาขึ้นอยู่กับเวอร์ชันโมเดลเฉพาะ
  • Unfiltered AI ใช้โมเดลแบบเปิดน้ำหนักบนฮาร์ดแวร์เฉพาะทางพร้อมหน้าต่างบริบท 100k โดยมีราคา $0.15/$0.50 ต่อหนึ่งล้านโทเคน
  • เพื่อความสม่ำเสมอของ NSFW หรือบทบาทการสวมบทบาทอย่างเคร่งครัด API LLM แบบไม่เซ็นเซอร์เฉพาะทางจะกำจัดความจำเป็นในการวิศวกรรมพรอมต์ที่ซับซ้อนเพื่อข้ามตัวกรองทั่วไป

ระบบในรูปแบบภาพด้วยข้อความ

จินตนาการกล่องสามกล่องเรียงกันและมีลูกศรสองเส้นระหว่างกล่อง ด้านซ้ายคือ browser ตรงกลางคือกระบวนการ FastAPI ของคุณ และด้านขวาคือ endpoint ของโมเดล ที่ https://api.unfilteredaiapi.com/v1 ลูกศรซ้ายส่งข้อความผู้ใช้หนึ่งข้อความและส่งคืนสตรีมของเฟรมข้อความขนาดเล็ก ลูกศรขวาส่งการสนทนาทั้งหมดและส่งคืนเหตุการณ์ที่ส่งจากเซิร์ฟเวอร์ กล่องกลางทำหน้าที่สามอย่างเท่านั้น: เก็บคีย์ API ควบคุมสถานะการสนทนา และแปลงรูปแบบสตรีมหนึ่งเป็นอีกรูปแบบหนึ่ง

การเก็บคีย์ไว้ในกล่องกลางเป็นเหตุผลที่เลเยอร์นี้เกิดขึ้น คีย์ที่ส่งไปยังเบราว์เซอร์คือคีย์ที่เปิดเผยต่อทุกคนที่เปิดเครื่องมือพัฒนา เหตุผลที่สองคือสถานะ: เบราว์เซอร์ส่งเฉพาะข้อความใหม่และ session id ในขณะที่เซิร์ฟเวอร์ตัดสินใจว่าจะเล่นประวัติย้อนหลังมากน้อยเพียงใด การตัดสินใจนี้มีความสำคัญเมื่อการสนทนาขยายใหญ่ขึ้น ซึ่ง บทความเกี่ยวกับหน่วยความจำ ได้กล่าวไว้โดยละเอียด

ทุกอย่างที่นี่ใช้รูปแบบ chat-completions มาตรฐานพร้อม stream: true ดังนั้นให้ติดตั้ง fastapi, uvicorn และ httpx และไม่ต้องติดตั้งอย่างอื่น

สิ่งที่ปรากฏในลูกศรด้านขวา

เมื่อเปิดสตรีมมิง การตอบกลับจะเป็นลำดับบรรทัด แต่ละบรรทัดที่มีประโยชน์จะขึ้นต้นด้วย data: ตามด้วย JSON chunk ที่ choices[0].delta.content เก็บอักขระไม่กี่ตัว บรรทัดจริงสุดท้ายคือ data: [DONE] ก่อนหน้านั้นจะมี usage chunk เพิ่มอัตโนมัติซึ่งมีจำนวนโทเคนแต่ไม่มี choices ดังนั้น relay ต้องตรวจสอบเงื่อนไขนี้ก่อนทำ indexing

ให้มองสตรีมเป็นสามระยะ: ช่วงเริ่มต้นเงียบขณะที่โมเดลอ่านพรอมต์ของคุณ ช่วงไหลอย่างต่อเนื่องของเศษข้อความ และช่วงสรุปสั้นๆ พร้อมข้อมูลการใช้งานและตัวส่งสัญญาณ รีเลย์ด้านล่างจะจำลองระยะเหล่านี้ โดยส่งต่อเศษข้อความเมื่อได้รับ สะสมเป็นสตริงเดียว และเขียนสตริงนั้นไปยังเซสชันเฉพาะเมื่อการไหลสิ้นสุดลง

เอนด์พอยต์รีเลย์

แกนหลักคือ async generator ชื่อ stream_reply FastAPI's StreamingResponse จะอ่านค่าและ flush สตริงที่ yield ออกมาแต่ละชิ้นไปยังไคลเอนต์ เส้นทางสองเส้นทางห่อหุ้ม generator เดียวกัน: POST สำหรับ fetch และ GET สำหรับ 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"},
    )

อ่าน generator จากบนลงล่าง มันจะเพิ่มข้อความผู้ใช้เป็นอันดับแรกเพื่อให้โมเดลเห็น หากสถานะจาก upstream ไม่ใช่ 200 มันจะลบข้อความนั้นออกอีกครั้งและปล่อยเหตุการณ์ error ซึ่งช่วยเก็บประวัติให้ปราศจากการสนทนาที่ไม่มีคำตอบ เมื่อสำเร็จจะปล่อยแต่ละส่วนเป็นสตริง JSON ซึ่งเป็นวิธีที่ newline และเครื่องหมายคำพูดจะรอดพ้นจากการจัดเฟรม เมื่อลูปสิ้นสุดลง มันจะเก็บข้อความผู้ช่วยและส่งเหตุการณ์ done

หัวเรื่องสองรายการนี้สำคัญ Cache-Control: no-cache ป้องกันตัวกลางจากการเก็บสตรีม และ X-Accel-Buffering: no บอกให้ proxy แบบ nginx ส่งไบต์ผ่านทันที

การเลือกที่เก็บเซสชัน

ดิกชันนารีในตัวอย่างคือที่เก็บที่ง่ายที่สุด: รายการข้อความหนึ่งรายการต่อไอดีเซสชัน มีข้อจำกัดที่จริงใจสามประการ: หายไปเมื่อรีสตาร์ท ไม่สามารถแชร์ระหว่างกระบวนการ worker ได้ และเติบโตโดยไม่จำกัด เลือกขั้นตอนถัดไปตามข้อจำกัดที่ทำให้คุณเจ็บปวดที่สุด

  1. กระบวนการเดียวและเซสชันสั้น: เก็บ dictionary เพิ่มการสแกน time-to-live เพื่อลบเซสชันที่ idle เป็นเวลาหนึ่งชั่วโมง
  2. หลาย worker: ย้ายรายการข้อความไปยัง key-value store ร่วมกัน โดย session id เป็น key และ JSON array เป็น value จัดการการเข้าถึงแบบเรียงลำดับต่อเซสชันเพื่อให้คำขอพร้อมกันสองคำขอไม่สามารถสลับกันได้
  3. ประวัติที่ทนทาน: เขียนแต่ละการสนทนาไปยังแถวฐานข้อมูลที่ keyed โดย session และลำดับ และโหลดส่วนท้ายเมื่อต้องการ

ไม่ว่าคุณจะเลือกอะไร ให้ซ่อนไว้หลังฟังก์ชันสองตัว load(session_id) และ append(session_id, message) เพื่อให้ stream_reply ไม่รู้ที่อยู่ที่เก็บข้อมูล นอกจากนี้สร้าง session ids บนเซิร์ฟเวอร์ตามวิธีที่เส้นทาง /session ทำ และพิจารณาว่าเป็นความลับที่คาดเดาไม่ได้

ฝั่งเบราว์เซอร์ด้วย fetch

ทางลูกศรซ้ายเบราว์เซอร์ต้องอ่าน body ของ 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 ดังนั้นผลลัพธ์ของโมเดลจึงไม่สามารถแทรก markup เข้าไปในหน้าเว็บของคุณได้ นี่คือนิสัยเล็กๆ ที่ให้ผลตอบแทนใหญ่เมื่อโมเดลกำลังสร้างเรื่องแต่งแบบ arbitrary

ทดลองใช้รีเลย์ก่อนเขียนส่วนหน้าบ้าน

ทดสอบกล่องกลางแยกต่างหากก่อน เครื่องมือ terminal ลบเบราว์เซอร์ออกจากสมการ ดังนั้นปัญหาที่คุณเห็นจึงเป็นของ relay เท่านั้น แฟลก -N ปิดการ buffer output ของ 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 สุดท้าย ส่งข้อความที่สองด้วย session id เดียวกันและขอให้ผู้บรรยายทำต่อ; หากมันดำเนินการต่อจากจุดที่หยุด เซตข้อมูลทำงาน หากบรรทัดทั้งหมดมาถึงพร้อมกัน มีบางอย่างระหว่างคุณและกระบวนการกำลัง buffer และตัวต้องสงสัยทั่วไปคือ reverse proxy ที่เปิดการ buffer การตอบกลับไว้

เมื่อผ่านจุดนี้แล้ว หน้าเบราว์เซอร์จะอ่านเฟรมเดียวกันเท่านั้น หน้าเว็บไซต์หลักและเอกสารระบุฟิลด์คำขอหากคุณต้องการส่งตัวเลือกการสุ่มตัวอย่างเพิ่มเติมผ่านรีเลย์

รูปแบบ EventSource และข้อเสียเปรียบ

API EventSource ของเบราว์เซอร์จัดการการแยกวิเคราะห์และการเชื่อมต่อใหม่ให้คุณ แต่สามารถส่งคำขอ GET ได้เท่านั้น นี่คือเหตุผลที่แบ็กเอนด์มีเส้นทางที่สอง ข้อเสียคือข้อความของผู้ใช้จะอยู่ใน URL และ URL มักจะปรากฏใน access logs บนเครื่องที่คุณใช้งาน สำหรับบทสนทนาส่วนตัวควรใช้ 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 listener เมื่อสตรีมปิด EventSource จะ reconnect ส่งข้อความซ้ำ การปิดที่ done และ error จะตัดลูปนี้

รูปแบบความล้มเหลวและข้อจำกัดที่ต้องออกแบบรอบ

เดินตามลูกศรอีกครั้งและถามว่าอะไรจะเสียในแต่ละด้าน ด้านขวา: 401 หมายถึงคีย์ผิด 402 หมายถึงยอดเงินหมด 403 หมายถึงคำขอถูกบล็อก 429 หมายถึงคุณส่งเกิน 300 คำขอต่อนาทีบนคีย์นี้ และ 503 พร้อม upstream_busy ควรลองใหม่หลังจากผ่านไปไม่กี่วินาที Relay แสดงผลทั้งหมดนี้เป็นเหตุการณ์ error เดียวพร้อมสถานะที่แนบมา เพื่อให้เบราว์เซอร์สามารถเลือกข้อความได้

ไคลเอนต์ที่ตัดการเชื่อมต่อระหว่างสตรีมจะยกเลิก generator และข้อความผู้ช่วยบางส่วนจะไม่ถูกบันทึก นั่นมักจะเป็นพฤติกรรมที่ถูกต้อง; หากคุณต้องการเก็บการตอบกลับบางส่วน ให้เก็บไว้ในบล็อก finally

สำหรับการวางแผนต้นทุน ให้สมมติว่าการสนทนาหนึ่งส่ง 3,000 input tokens และส่งคืน 600 ที่ราคา $0.15 และ $0.50 ต่อล้าน จะเท่ากับ $0.00075 บวก $0.0006 ประมาณ $0.00135 ต่อการสนทนา ดังนั้นการสนทนาหนึ่งพันครั้งจะมีค่าใช้จ่ายใกล้เคียง $1.35 ตัวเลขเหล่านี้เป็นสมมติฐาน; ตรวจสอบส่วนการใช้งานสำหรับตัวเลขจริงของคุณ สำหรับอัตราดูที่ pricing และสำหรับภาพรวมของการเลือกอ่าน การเปรียบเทียบ API แชทบอท

ถาม-ตอบ

ทำไมไม่เรียกโมเดลโดยตรงจากเบราว์เซอร์?

คีย์ API จะมองเห็นได้โดยผู้เข้าชมทุกคน รีเลย์ขนาดเล็กช่วยเก็บคีย์ให้เป็นส่วนตัวและอนุญาตให้คุณควบคุมประวัติและขีดจำกัดอัตรา

สตรีมรวมถึงการใช้งานโทเคนหรือไม่?

ใช่ มีการเพิ่มข้อมูลการใช้งานสุดท้ายโดยอัตโนมัติ ซึ่งไม่มีรายการ choices ดังนั้นให้ข้ามข้อมูลที่ไม่มีรายการนี้เมื่อแยกข้อความ

ฉันควรใช้ EventSource แทน fetch เมื่อไหร่?

ใช้ EventSource เมื่อใช้ GET ได้และต้องการการเชื่อมต่อใหม่ในตัว ใช้ fetch สำหรับ body ของ POST ซึ่งช่วยเก็บข้อความส่วนตัวไม่ให้ปรากฏใน URL

คีย์หนึ่งรองรับผู้ใช้ได้กี่คน

ขีดจำกัดคือ 300 คำขอต่อนาทีต่อคีย์ ซึ่งใช้ร่วมกันโดยผู้ใช้ทั้งหมดของคุณ ดังนั้นจึงควรเพิ่มการรอคอยต่อผู้ใช้ในรีเลย์

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ แล้วเปลี่ยน base URL เพียงเท่านี้ก็พร้อมใช้งาน

รับคีย์ APIอ่านเอกสาร