VI ▾

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

Unfiltered AI

API LLM nguyên bản, không kiểm duyệt dành cho nhà phát triển.

Unfiltered AILấy khóa API

Backend chatbot không kiểm duyệt với FastAPI và sự kiện gửi từ máy chủ

Hướng dẫn này chuyển tiếp đầu ra mô hình đã stream thông qua một backend FastAPI nhỏ. Giữ khóa trên máy chủ, cô lập lịch sử hội thoại theo phiên và xử lý các stream bị ngắt trước khi hiển thị phản hồi là hoàn tất.

Backend chatbot không kiểm duyệt với FastAPI và sự kiện gửi từ máy chủ

Điểm chính

  • Các nhà cung cấp suy luận chuyên dụng như Unfiltered AI cung cấp hành vi không kiểm duyệt nhất quán trên một mô hình, tránh tính ngẫu nhiên của việc định tuyến qua bộ tổng hợp.
  • Các bộ tổng hợp như OpenRouter cung cấp quyền truy cập vào nhiều mô hình nhưng có thể khác nhau về cách chúng áp dụng bộ lọc nội dung tùy thuộc vào phiên bản mô hình cụ thể.
  • Unfiltered AI sử dụng mô hình trọng số mở trên phần cứng chuyên dụng với cửa sổ ngữ cảnh 100k token, giá $0,15/$0.50 cho mỗi triệu token.
  • Đối với tính nhất quán NSFW hoặc đóng vai nghiêm ngặt, một API LLM không kiểm duyệt chuyên dụng loại bỏ nhu cầu về kỹ thuật prompt phức tạp để vượt qua các bộ lọc chung.

Hệ thống dưới dạng hình ảnh bằng lời

Hãy tưởng tượng ba hộp xếp hàng ngang và hai mũi tên giữa chúng. Bên trái là browser. Ở giữa là quá trình FastAPI của bạn. Bên phải là endpoint mô hình tại https://api.unfilteredaiapi.com/v1. Mũi tên bên trái mang một prompt người dùng và trả về một luồng các khung văn bản nhỏ. Mũi tên bên phải mang toàn bộ hội thoại và trả về các sự kiện gửi từ máy chủ (SSE). Hộp giữa thực hiện ba nhiệm vụ và không hơn: nó giữ khóa API, quản lý trạng thái hội thoại và chuyển đổi một định dạng luồng sang định dạng khác.

Việc giữ khóa ở hộp giữa là lý do tồn tại lớp này. Một khóa được gửi đến trình duyệt là một khóa được công khai cho mọi ai mở công cụ nhà phát triển. Lý do thứ hai là trạng thái: trình duyệt chỉ gửi văn bản mới và một id phiên, trong khi máy chủ quyết định phải phát lại bao nhiêu lịch sử. Quyết định đó trở nên quan trọng khi các cuộc hội thoại trở nên dài, điều mà bài viết về bộ nhớ xử lý chuyên sâu.

Tất cả ở đây sử dụng định dạng chat-completions tiêu chuẩn với stream: true, vì vậy hãy cài đặt fastapi, uvicorn và httpx và không có gì khác.

Điều đến trên mũi tên bên phải

Khi bật streaming, phản hồi là một chuỗi các dòng. Mỗi dòng hữu ích bắt đầu bằng data: theo sau là một chunk JSON mà choices[0].delta.content chứa một vài ký tự. Dòng thực cuối cùng là data: [DONE]. Ngay trước đó, một chunk sử dụng được thêm tự động; nó chứa số lượng token và không có mục choices nào, vì vậy endpoint chuyển tiếp phải kiểm tra điều đó trước khi truy cập chỉ mục.

Hãy coi dòng dữ liệu là ba giai đoạn: một khởi đầu yên tĩnh trong khi mô hình đọc prompt của bạn, một dòng chảy ổn định của các mảnh, và một phần phụ ngắn với việc sử dụng và dấu hiệu. Máy chuyển tiếp dưới đây sao chép các giai đoạn đó. Nó chuyển tiếp các mảnh khi chúng đến, tích lũy chúng thành một chuỗi duy nhất và ghi chuỗi đó vào phiên chỉ khi dòng chảy kết thúc.

Endpoint chuyển tiếp

Lõi là một bộ tạo không đồng bộ được gọi là stream_reply. StreamingResponse của FastAPI tiêu thụ nó và làm trống mỗi chuỗi được tạo ra cho máy khách. Hai tuyến bao bọc cùng một bộ tạo: một POST cho fetch và một GET cho 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"},
    )

Đọc trình tạo từ trên xuống dưới. Nó thêm prompt người dùng vào đầu tiên, vì vậy mô hình sẽ thấy nó. Nếu trạng thái upstream không phải 200, nó sẽ xóa prompt đó và phát ra sự kiện error, giúp lịch sử không chứa các lượt chưa được trả lời. Khi thành công, nó phát từng phần dưới dạng chuỗi JSON, đây là cách các ký tự xuống dòng và dấu ngoặc kép tồn tại qua quá trình đóng khung. Khi vòng lặp kết thúc, nó lưu văn bản trợ lý và gửi sự kiện done.

Hai tiêu đề rất quan trọng. Cache-Control: no-cache ngăn các trung gian giữ dòng dữ liệu, và X-Accel-Buffering: no báo cho proxy kiểu nginx chuyển byte ngay lập tức.

Chọn kho lưu trữ phiên

Từ điển trong ví dụ là kho lưu trữ đơn giản nhất có thể: một danh sách các thông điệp cho mỗi id phiên. Nó có ba hạn chế trung thực. Nó biến mất khi khởi động lại, nó không được chia sẻ giữa các quy trình worker và nó phát triển không giới hạn. Hãy chọn bước tiếp theo dựa trên hạn chế nào gây đau nhất.

  1. Một quy trình đơn, phiên ngắn: giữ từ điển, thêm một quy trình quét thời gian sống (TTL) để xóa các phiên không hoạt động trong một giờ.
  2. Nhiều worker: di chuyển danh sách tin nhắn đến kho lưu trữ khóa-giá trị chia sẻ, với id phiên làm khóa và mảng JSON làm giá trị. Tuần tự hóa truy cập theo phiên để hai yêu cầu đồng thời không thể xen kẽ.
  3. Lịch sử bền vững: ghi mỗi lượt vào một hàng cơ sở dữ liệu được đánh khóa theo phiên và số thứ tự, và tải phần đuôi khi cần.

Bất kể bạn chọn phương án nào, hãy ẩn nó đằng sau hai hàm, load(session_id) và append(session_id, message), để stream_reply không bao giờ biết dữ liệu được lưu ở đâu. Ngoài ra, hãy tạo id phiên trên máy chủ, như cách mà route /session làm, và coi chúng là các bí mật không thể đoán được.

Phần trình duyệt với fetch

Ở mũi tên bên trái, trình duyệt phải đọc thân POST truyền phát (streaming). fetch expose nó dưới dạng readable stream, và TextDecoderStream chuyển đổi byte thành văn bản. Các frame được phân tách bằng một dòng trống, vì vậy máy khách sẽ đệm văn bản đến và cắt các frame hoàn chỉnh.

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

Trang ghi bằng textContent, không bao giờ là innerHTML, vì vậy đầu ra của mô hình không thể chèn markup vào trang của bạn. Đó là một thói quen nhỏ nhưng mang lại lợi ích lớn khi mô hình tạo ra các câu chuyện tùy ý.

Thử nghiệm máy chuyển tiếp trước khi viết giao diện người dùng

Đầu tiên hãy kiểm tra hộp ở giữa một cách độc lập. Một terminal client loại bỏ trình duyệt khỏi phương trình, vì vậy mọi vấn đề bạn thấy đều thuộc về relay. Cờ -N tắt bộ đệm đầu ra của curl; nếu không, bạn sẽ thấy toàn bộ phản hồi đến cùng một lúc và kết luận sai rằng streaming bị lỗi.

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

Bạn sẽ thấy các dòng bắt đầu bằng data: , mỗi dòng mang một đoạn trích được trích dẫn, sau đó là khung event: done cuối cùng. Gửi một tin nhắn thứ hai với cùng id phiên và yêu cầu người kể chuyện tiếp tục; nếu nó tiếp nối nơi nó đã dừng lại, kho lưu trữ hoạt động. Nếu các dòng đến cùng một lúc, thứ gì đó giữa bạn và quá trình đang đệm, và nghi phạm thường xuyên là một proxy ngược có bộ đệm phản hồi được bật.

Khi điều này hoạt động, trang trình duyệt chỉ là vấn đề đọc các khung giống nhau. trang chủ và tài liệu liệt kê các trường yêu cầu nếu bạn muốn truyền thêm các tùy chọn lấy mẫu qua endpoint chuyển tiếp.

Biến thể EventSource và sự đánh đổi của nó

API EventSource của trình duyệt xử lý việc phân tích cú pháp và kết nối lại cho bạn, nhưng nó chỉ có thể gửi các yêu cầu GET. Đó là lý do tại sao backend có một tuyến đường thứ hai. Cái giá là văn bản của người dùng được truyền trong URL, và URL thường kết thúc trong các nhật ký truy cập trên các máy mà bạn vận hành. Đối với các cuộc trò chuyện riêng tư, hãy ưu tiên phương pháp POST và 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());

Hãy chú ý đến trình lắng nghe done. Khi một máy chủ đóng luồng sự kiện, EventSource giả định lỗi mạng và kết nối lại, điều này sẽ gửi lại cùng một tin nhắn. Đóng chính nguồn sự kiện trên done và trên error sẽ phá vỡ vòng lặp đó.

Các chế độ lỗi và các giới hạn cần thiết kế để tránh

Hãy xem xét các mũi tên một lần nữa và hỏi những gì có thể bị lỗi trên mỗi điểm. Ở bên phải: 401 có nghĩa là khóa không hợp lệ, 402 có nghĩa là số dư đã hết, 403 có nghĩa là yêu cầu bị chặn, 429 có nghĩa là bạn đã vượt quá 300 yêu cầu mỗi phút trên khóa này, và 503 với upstream_busy nên thử lại sau vài giây. Endpoint chuyển tiếp hiển thị tất cả chúng dưới dạng một sự kiện error duy nhất với trạng thái được đính kèm, vì vậy trình duyệt có thể chọn một thông báo.

Một máy khách ngắt kết nối giữa chừng sẽ hủy bộ tạo, và văn bản trợ lý một phần sẽ không bao giờ được lưu. Đó thường là hành vi đúng; nếu bạn muốn giữ các phản hồi một phần, hãy lưu chúng trong khối finally.

Để lập kế hoạch chi phí, hãy giả sử một lượt gửi 3.000 token đầu vào và trả về 600. Ở mức $0,15 và $0,50 cho mỗi triệu, đó là $0,00075 cộng $0,0006, khoảng $0,00135 cho mỗi lượt, vì vậy một nghìn lượt tốn gần $1,35. Những con số này là giả định; hãy kiểm tra chunk sử dụng để có số liệu thực tế của bạn. Để biết tốc độ, hãy xem giá cả, và để có cái nhìn tổng quan về các lựa chọn, hãy đọc so sánh API chatbot.

Hỏi đáp

Tại sao không gọi mô hình trực tiếp từ trình duyệt?

Khóa API sẽ hiển thị với mọi khách truy cập. Một endpoint chuyển tiếp nhỏ giữ khóa ở chế độ riêng tư và cho phép bạn kiểm soát lịch sử và giới hạn tốc độ.

Luồng có bao gồm sử dụng token không?

Có. Một chunk sử dụng cuối cùng được thêm tự động, và nó không có mục choices, vì vậy hãy bỏ qua các chunk không có chúng khi trích xuất văn bản.

Khi nào tôi nên sử dụng EventSource thay vì fetch?

Sử dụng EventSource khi phương thức GET là chấp nhận được và bạn muốn tính năng tự động kết nối lại. Sử dụng fetch cho thân POST, giúp giữ văn bản riêng tư khỏi URL.

Một khóa API có thể hỗ trợ bao nhiêu người dùng?

Giới hạn là 300 yêu cầu mỗi phút trên mỗi khóa, dùng chung cho tất cả người dùng của bạn, vì vậy hãy thêm thời gian chờ cho mỗi người dùng trong relay.

Khóa của bạn chỉ cách một biểu mẫu

Tạo tài khoản, sao chép khóa, thay đổi base URL. Đó là toàn bộ quy trình thiết lập.

Lấy khóa APIĐọc tài liệu