PL ▾

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

Unfiltered AI

Surowe, bez cenzury API LLM dla programistów.

Unfiltered AIPobierz klucz API

Backend czatbota bez filtrów w FastAPI i zdarzenia wysyłane przez serwer

Ten przewodnik przekazuje strumieniowy output modelu przez mały backend FastAPI. Przechowuj klucz na serwerze, izoluj historię rozmów według sesji i obsługuj przerwane strumienie przed wyświetleniem odpowiedzi jako kompletnej.

Backend czatbota bez filtrów w FastAPI i zdarzenia wysyłane przez serwer

Kluczowe punkty

  • Specjalizowani dostawcy inferencji, tacy jak Unfiltered AI, oferują spójne zachowanie bez cenzury na jednym modelu, unikając losowości routingu agregatorów.
  • Agregatorzy tacy jak OpenRouter zapewniają dostęp do wielu modeli, ale mogą różnić się pod względem ścisłości stosowania filtrów treści w zależności od konkretnej wersji modelu.
  • Unfiltered AI używa modelu o otwartych wagach na dedykowanym sprzęcie z oknem kontekstu 100k, wycenianego na $0,15/$0,50 za milion tokenów.
  • Dla ścisłej spójności NSFW lub odgrywania ról, dedykowane API LLM bez cenzury eliminuje potrzebę skomplikowanego inżynierii promptów do omijania ogólnych filtrów.

System jako obrazek słowami

Wyobraź sobie trzy pudełka w rzędzie i dwie strzałki między nimi. Po lewej stronie znajduje się browser. Pośrodku Twój proces FastAPI. Po prawej stronie endpoint modelu w https://api.unfilteredaiapi.com/v1. Lewa strzałka przenosi jedną wiadomość użytkownika i zwraca strumień małych ramek tekstu. Prawa strzałka przenosi pełną rozmowę i zwraca zdarzenia wysyłane przez serwer. Środkowe pudełko wykonuje trzy zadania i nic więcej: przechowuje klucz API, zarządza stanem rozmowy i konwertuje jeden format strumienia na drugi.

Trzymanie klucza w środkowym pudełku jest powodem istnienia tej warstwy. Klucz wysłany do przeglądarki to klucz opublikowany dla każdego, kto otworzy narzędzia deweloperskie. Drugim powodem jest stan: przeglądarka wysyła tylko nowy tekst i identyfikator sesji, podczas gdy serwer decyduje, ile historii odtworzyć. Ta decyzja staje się ważna, gdy rozmowy rosną, co artykuł o pamięci omawia szczegółowo.

Wszystko tutaj używa standardowego formatu chat-completions z stream: true, więc zainstaluj fastapi, uvicorn i httpx i nic więcej.

Co pojawia się na prawej strzałce

Przy włączonym strumieniowaniu odpowiedź jest sekwencją linii. Każda użyteczna linia zaczyna się od data: za którym następuje fragment JSON, którego choices[0].delta.content zawiera kilka znaków. Ostatnią prawdziwą linią jest data: [DONE]. Tuż przed tym automatycznie dodawany jest fragment użycia; zawiera on liczniki tokenów i nie ma wpisów choices, więc przekaźnik musi to sprawdzić przed indeksowaniem.

Traktuj strumień jako trzy fazy: cichy początek, podczas gdy model czyta twój prompt, stały przepływ fragmentów i krótkie zakończenie z metadanymi i znacznikiem końca. Powyższy relay odzwierciedla te fazy. Przekazuje fragmenty w miarę ich przybywania, gromadzi je w jeden ciąg i zapisuje ten ciąg do sesji dopiero po zakończeniu strumienia.

Endpoint przekaźnikowy

Sercem jest generator asynchroniczny stream_reply. StreamingResponse FastAPI go konsumuje i wysyła każdy zwrócony ciąg do klienta. Dwie trasy opakowują ten sam generator: POST dla fetch i GET dla 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"},
    )

Przeczytaj generator od góry do dołu. Najpierw dołącza wiadomość użytkownika, więc model ją widzi. Jeśli status upstream nie wynosi 200, usuwa tę wiadomość i emituje zdarzenie error, co utrzymuje historię wolną od nieodpowiednich tur. Po sukcesie emituje każdy fragment jako ciąg JSON, dzięki czemu znaki nowej linii i cudzysłowy przetrwają ramowanie. Po zakończeniu pętli zapisuje tekst asystenta i wysyła zdarzenie done.

Dwa nagłówki mają znaczenie. Cache-Control: no-cache zapobiega zatrzymywaniu strumienia przez pośredników, a X-Accel-Buffering: no mówi proxy w stylu nginx, aby przesyłać bajty natychmiast.

Wybór magazynu sesji

Słownik w przykładzie to najprostszy możliwy magazyn: jedna lista wiadomości na identyfikator sesji. Ma trzy szczere ograniczenia. Zanika przy restarcie, nie jest współdzielony między procesami roboczymi i rośnie nieograniczenie. Wybierz następny krok w zależności od tego, które ograniczenie boli najbardziej.

  1. Pojedynczy proces, krótkie sesje: zachowaj słownik, dodaj czyszczenie czasu życia, które usuwa sesje bezczynne przez godzinę.
  2. Wiele workerów: przenieś listę wiadomości do współdzielonego magazynu klucz-wartość, z identyfikatorem sesji jako kluczem i tablicą JSON jako wartością. Serializuj dostęp na sesję, aby dwa jednoczesne żądania nie mogły się przeplatać.
  3. Trwała historia: zapisz każdą turę w wierszu bazy danych kluczowanym przez sesję i numer sekwencyjny oraz wczytuj końcówkę na żądanie.

Cokolwiek wybierzesz, ukryj to za dwiema funkcjami, load(session_id) i append(session_id, message), tak aby stream_reply nie wiedział, gdzie znajdują się dane. Generuj również identyfikatory sesji na serwerze, jak robi to trasa /session, i traktuj je jako nieodgadniane sekrety.

Strona przeglądarki z fetch

Na lewej strzałce przeglądarka musi odczytać ciało POST strumieniowania. fetch wystawia je jako strumień do odczytu, a TextDecoderStream zamienia bajty na tekst. Ramki są oddzielone pustą linią, więc klient buforuje przychodzący tekst i odcina kompletne ramki.

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

Strona pisze za pomocą textContent, nigdy innerHTML, więc output modelu nie może wstrzyknąć znaczników do Twojej strony. To mała nawyk, który przynosi dużą korzyść, gdy model generuje dowolną fikcję.

Przetestuj przekaźnik przed napisaniem jakiegokolwiek frontendu

Przetestuj środkowe pudełko w izolacji najpierw. Klient terminalowy usuwa przeglądarkę z równania, więc każdy problem, który widzisz, należy do serwera przekaźnikowego. Flaga -N wyłącza buforowanie wyjścia curl; bez niej zobaczyłbyś całą odpowiedź przychodzącą naraz i błędnie wnioskowałbyś, że strumieniowanie jest zepsute.

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

Powinieneś zobaczyć linie zaczynające się od data: , każda niosąca cytowany fragment, a następnie ramkę event: done. Wyślij drugą wiadomość z tym samym identyfikatorem sesji i poproś narratora o kontynuację; jeśli zacznie tam, gdzie skończył, magazyn działa. Jeśli linie przychodzą w jednym pakiecie, coś między Tobą a procesem buforuje, a typowym podejrzanym jest reverse proxy z włączonym buforowaniem odpowiedzi.

Po pomyślnym przejściu strona przeglądarki sprowadza się do odczytywania tych samych ramek. Na stronie głównej i dokumentacji wymieniono pola zapytania, jeśli chcesz przekazać więcej opcji próbkowania przez relay.

Wariant EventSource i jego kompromis

API EventSource przeglądarki zajmuje się za Ciebie parsowaniem i ponownym łączeniem, ale może wysyłać tylko żądania GET. Dlatego backend ma drugą trasę. Kosztuje to, że tekst użytkownika podróżuje w URL, a URL mają tendencję do lądowania w logach dostępu na serwerach, które uruchamiasz. Dla prywatnych rozmów preferuj podejście POST i 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());

Zwróć uwagę na nasłuchiwanie done. Gdy serwer zamyka strumień zdarzeń, EventSource zakłada awarię sieci i ponownie się łączy, co wyśle tę samą wiadomość ponownie. Zamknięcie źródła przez Ciebie na done i na error przerywa tę pętlę.

Tryby awarii i limity do projektowania wokół

Przejdź raz jeszcze przez strzałki i zapytaj, co może się zepsuć w każdej z nich. Po prawej stronie: 401 oznacza zły klucz, 402 oznacza, że saldo zostało wyczerpane, 403 oznacza, że zapytanie zostało zablokowane, 429 oznacza, że przekroczyłeś 300 zapytań na minutę na tym kluczu, a 503 z upstream_busy zasługuje na ponowną próbę po kilku sekundach. Serwer przekaźnikowy ujawnia wszystkie z nich jako jedno zdarzenie error z dołączonym statusem, więc przeglądarka może wybrać wiadomość.

Klient, który rozłączy się w trakcie strumienia, anuluje generator, a częściowy tekst asystenta nie zostanie zapisany. To zwykle jest właściwe zachowanie; jeśli wolisz zachować częściowe odpowiedzi, przechowuj je w bloku finally.

Do planowania kosztów przyjmij turę, która wysyła 3000 tokenów wejściowych i zwraca 600. Przy cenie $0,15 i $0,50 za milion, to $0,00075 plus $0,0006, około $0,00135 na turę, więc tysiąc tur kosztuje około $1,35. Te dane to założenia; sprawdź sekcję zużycia, aby uzyskać rzeczywiste liczby. Aby zobaczyć stawki, przejdź do pricing, a aby uzyskać przegląd opcji, przeczytaj the chatbot API comparison.

Pytania i odpowiedzi

Dlaczego nie wywołać modelu bezpośrednio z przeglądarki?

Klucz API byłby widoczny dla każdego odwiedzającego. Mały serwer przekaźnikowy utrzymuje prywatność klucza i pozwala kontrolować historię oraz limity zapytań.

Czy strumień zawiera zużycie tokenów?

Tak. Ostateczny fragment użycia jest automatycznie dołączany i nie zawiera wpisów choices, więc pomijaj fragmenty bez nich podczas ekstrakcji tekstu.

Kiedy użyć EventSource zamiast fetch?

Użyj EventSource, gdy metoda GET jest akceptowalna i chcesz wbudowanego ponownego łączenia. Użyj fetch dla ciał POST, co utrzymuje prywatne dane poza URL.

Ilu użytkowników może obsługiwać jeden klucz?

Limit to 300 zapytań na minutę na klucz, dzielony między wszystkich użytkowników, więc dodaj cooldown na użytkownika w serwerze przekaźnikowym.

Twój klucz jest o jeden formularz stąd

Utwórz konto, skopiuj klucz, zmień bazowy URL. To jest cała konfiguracja.

Uzyskaj klucz APIPrzeczytaj dokumentację