DE ▾

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

Unfiltered AI

Rohe, unzensierte LLM-API für Entwickler.

Unfiltered AIAPI-Schlüssel erhalten

Node JS AI API: Streaming, Tools und Fehler in Express

Dieses Node.js-KI-API-Tutorial führt dich von einem leeren Ordner zu einer Express-Route, die Chat-Antworten streamt, ein Tool aufruft und Ratenlimit-Fehler behandelt. Du änderst nur die Base URL und den Schlüssel im offiziellen OpenAI-Paket und sendest dann das Modell uncensored.

Hexagonale Zahnräder, verbunden mit einem Server-Rack, das Lichtpartikel in ein Browser-Fenster streamt

Wichtige Punkte

  • Installiere das openai-Paket und setze baseURL auf https://api.unfilteredaiapi.com/v1.
  • Streamen mit stream: true und Weiterleiten von Chunks an den Browser als Server-Sent Events.
  • Tool-Aufrufe kommen als tool_calls an; gib Ergebnisse mit role tool zurück.
  • 429 bedeutet rate_limited, concurrency oder temporäre Überlastung; versuche es nach der Retry-After-Verzögerung erneut.

Einrichtung: Installieren und erste Anfrage senden

Du benötigst Node 18 oder neuer. Erstelle ein Projekt, installiere das SDK und Express und wechsle zu ES-Modulen.

mkdir ai-node && cd ai-node
npm init -y
npm pkg set type=module
npm install openai express
# base URL: https://api.unfilteredaiapi.com/v1   model: uncensored
export AI_API_KEY="YOUR_KEY"

Hole einen Schlüssel von der API-Schlüssel-Seite. Neue Konten können mit einem Klick $0,50 kostenloses Testguthaben beanspruchen, gültig für 7 Tage. Erstelle dann client.js:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unfilteredaiapi.com/v1",
  apiKey: process.env.AI_API_KEY,
});

const res = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me three names for a tavern keeper." }],
});
console.log(res.choices[0].message.content);

Führe es mit node client.js aus. Jeder Code-Abschnitt definiert den Client erneut, damit er eigenständig läuft. Das ist die gesamte Migration, wenn du das OpenAI-Paket bereits nutzt: eine andere baseURL, dein Schlüssel und die Modell-ID. Der Dienst ist OpenAI-kompatibel und nur Text, mit einem 100.000 Token-Kontextfenster. Siehe die Dokumentation für alle unterstützten Methoden.

Antwort streamen

Streaming sendet Token, sobald sie erzeugt werden, sodass Benutzer den Text sofort sehen. Setze stream: true und iteriere über die Chunks:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unfilteredaiapi.com/v1",
  apiKey: process.env.AI_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Describe a rainy harbor town." }],
  stream: true,
  stream_options: { include_usage: true },
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
  if (chunk.usage) console.log("\nusage:", chunk.usage);
}

Die Nutzung kommt im letzten Chunk an, was dir erlaubt, echte Token-Anzahlen pro Anfrage zu protokollieren. Behalte eine Tatsache im Kopf: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn der Client die Verbindung abbricht, brich den Upstream-Aufruf ab, damit der Slot schnell frei wird.

Eine Express-Route, die an den Browser streamt

Hier ist ein kleiner Server mit einer POST /chat-Route. Sie leitet den Stream als Server-Sent Events weiter und bricht die Upstream-Anfrage ab, wenn der Browser die Verbindung schließt.

import express from "express";
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unfilteredaiapi.com/v1",
  apiKey: process.env.AI_API_KEY,
});

const app = express();
app.use(express.json({ limit: "1mb" }));

app.post("/chat", async (req, res) => {
  const { messages } = req.body;
  if (Array.isArray(messages) === false) return res.status(400).json({ error: "messages required" });

  res.set({
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
  });

  const controller = new AbortController();
  req.on("close", () => controller.abort());

  try {
    const stream = await client.chat.completions.create(
      { model: "uncensored", messages, stream: true },
      { signal: controller.signal }
    );
    for await (const chunk of stream) {
      const delta = chunk.choices[0]?.delta?.content;
      if (delta) res.write("data: " + JSON.stringify({ delta }) + "\n\n");
    }
    res.write("data: [DONE]\n\n");
  } catch (err) {
    res.write("data: " + JSON.stringify({ error: err.status || 500 }) + "\n\n");
  } finally {
    res.end();
  }
});

app.listen(3000, () => console.log("listening on 3000"));

Gib den Schlüssel niemals in Browser-Code ein. Die obige Route hält ihn auf dem Server, wo er hingehört. Dasselbe Muster wird im Artikel FastAPI-Chatbot-Backend in Python gezeigt.

Ein Tool aufrufen

Function Calling folgt dem OpenAI-Format: Du beschreibst Funktionen in tools, das Modell antwortet mit tool_calls, du führst die Funktion aus und sendest das Ergebnis als Nachricht mit role: "tool" zurück.

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unfilteredaiapi.com/v1",
  apiKey: process.env.AI_API_KEY,
});

const tools = [{
  type: "function",
  function: {
    name: "roll_dice",
    description: "Roll a die with the given number of sides",
    parameters: {
      type: "object",
      properties: { sides: { type: "integer" } },
      required: ["sides"],
    },
  },
}];

const messages = [{ role: "user", content: "Roll a d20 for my attack." }];
const first = await client.chat.completions.create({
  model: "uncensored", messages, tools, tool_choice: "auto",
});

const msg = first.choices[0].message;
if (msg.tool_calls) {
  messages.push(msg);
  for (const call of msg.tool_calls) {
    const { sides } = JSON.parse(call.function.arguments);
    const result = 1 + Math.floor(Math.random() * sides);
    messages.push({ role: "tool", tool_call_id: call.id, content: String(result) });
  }
  const second = await client.chat.completions.create({ model: "uncensored", messages, tools });
  console.log(second.choices[0].message.content);
}

Parst arguments in echtem Code immer in einem try-Block, da Modelle gelegentlich ungültiges JSON zurückgeben können. Für strukturierte Ausgabe ohne Tools setze response_format: { type: "json_object" } und erwähne JSON in deinem Prompt. Spielszenen, die Würfel- oder Inventarfunktionen aufrufen, werden in Spiel-NPCs und interaktive Fiktion erstellen behandelt.

Fehler und Ratenlimits behandeln

Die API gibt HTTP 429 in drei Situationen zurück. Fehlercode rate_limited bedeutet zu viele Anfragen pro Minute: 300 für einen Vollschlüssel, 60 für einen Trial-Schlüssel. Code concurrency bedeutet zu viele gleichzeitig: 8 für einen Vollschlüssel, 2 für einen Trial-Schlüssel. Bei temporärer Überlastung erhältst du ebenfalls 429 mit einem Retry-After: 5-Header. Das SDK stellt den Status auf dem ausgelösten Fehler bereit, sodass ein kleiner Wrapper alle drei Fälle behandelt:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.unfilteredaiapi.com/v1",
  apiKey: process.env.AI_API_KEY,
});

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function chatWithRetry(params, tries = 4) {
  for (let i = 0; i < tries; i++) {
    try {
      return await client.chat.completions.create({ model: "uncensored", ...params });
    } catch (err) {
      if (err.status === 429 && i < tries - 1) {
        const wait = Number(err.headers?.["retry-after"]) || 2 ** i;
        await sleep(wait * 1000);
        continue;
      }
      throw err;
    }
  }
}

Der Wrapper wartet auf die vom Server angegebene Verzögerung und fällt bei Bedarf auf exponentielle Backoff-Strategie zurück. Beachte, dass das OpenAI-Paket einige Fehler auch selbst erneut versucht; setze maxRetries auf dem Client, wenn du dies steuern möchtest. Andere Statuscodes wie 401 für einen falschen Schlüssel sollten nicht erneut versucht werden. Eine tiefere Betrachtung der Limits findest du in der FAQ.

Route ausführen und testen

Starte den Server mit node server.js und teste ihn von einem zweiten Terminal aus. Die -N-Option schaltet die Curl-Pufferung ab, damit du siehst, wie Ereignisse nacheinander eintreffen:

# the server calls https://api.unfilteredaiapi.com/v1 with model uncensored
curl -N http://localhost:3000/chat   -H "Content-Type: application/json"   -d '{"messages":[{"role":"user","content":"Write a two-line riddle."}]}'

Lese im Browser den Stream mit fetch und einem Reader oder mit einer kleinen SSE-Hilfsbibliothek. Da die Route ein POST ist, passt das native EventSource-Objekt nicht, also verwende fetch und dekodiere die Chunks selbst.

Produktionsgewohnheiten

  • Halte den Schlüssel in einer Umgebungsvariable oder einem Secret-Store, niemals im Repository.
  • Begrenze den Anforderungstext. Die API akzeptiert bis zu 8 MB, aber deine eigene Route sollte deutlich weniger akzeptieren.
  • Begrenze die Historie, die du sendest. Kürze alte Nachrichten, bevor sie Geld kosten oder das 100.000-Token-Fenster füllen.
  • Warte zusätzliche Arbeit in eine Warteschlange ein oder lehne sie ab, wenn du bereits 8 Streams offen hast, anstatt die API deine Nutzer mit 429 antworten zu lassen.
  • Protokolliere den X-Request-Id-Antwortheader, damit Support eine einzelne Anfrage nachverfolgen kann.

Deinen Kontostand und die Kosten prüfen

Jede Antwort enthält einen X-Balance-USD-Header, und GET /v1/balance gibt das Guthaben direkt zurück. Der Preis beträgt $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, belastet vom Prepaid-Guthaben; fehlgeschlagene oder abgelehnte Anfragen sind kostenlos. Ein Chat-Turn mit 800 Input- und 250 Output-Token kostet $0,000245, also kosten 10.000 Turns $2,45. Protokolliere usage aus jeder Antwort, und du kannst deine Rechnung auf wenige Cent genau vorhersagen. Die Preisseite listet Aufladungen von $20 bis $500 auf.

Fragen und Antworten

Welches npm-Paket soll ich verwenden?

Das offizielle openai-Paket funktioniert. Setze baseURL auf https://api.unfilteredaiapi.com/v1, übergebe deinen Schlüssel und verwende die Modell-ID uncensored.

Kann ich Antworten von Node streamen?

Ja. Übergebe stream: true und iteriere mit for await. Füge stream_options mit include_usage hinzu, um Token-Anzahlen im letzten Chunk zu erhalten.

Unterstützt die API Function Calling?

Ja. Sende tools und tool_choice, lese tool_calls aus der Antwort und gib Ergebnisse als Nachrichten mit role tool zurück.

Was sollte mein Server bei HTTP 429 tun?

Warte auf den Retry-After-Wert, falls vorhanden, andernfalls wende exponentielles Backoff an und versuche es dann einige Male. Reduziere parallele Anfragen, wenn der Fehlercode concurrency ist.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhaltenLies die Dokumentation