Welche Modell-ID soll ich verwenden?

Verwende uncensored als Modell-ID in jeder Anfrage. Setze die base URL auf https://api.uncensoredllmhub.com/v1 und sende deinen Schlüssel als Bearer-Token.

Funktioniert es mit meinem bestehenden OpenAI-Code?

Ja. Jedes OpenAI SDK oder jeder Client funktioniert, sobald du die base URL und den Schlüssel änderst. Chat Completions, Streaming, Function Calling und JSON-Modus werden unterstützt.

Kann es Bilder oder Embeddings generieren?

Nein. Es ist eine textbasierte API ohne Bild-, Audio- oder Videogenerierung, ohne Embeddings und ohne Fine-Tuning.

Wie groß kann eine Konversation werden?

Das Kontextfenster umfasst 100.000 Token, geteilt zwischen Prompt und Antwort. Der Request Body kann bis zu 8 MB groß sein.

Uncensored LLM Hub: Ein Endpunkt für Chat und Agents

Wichtige Punkte

Eine Base URL und eine Modell-ID, uncensored, funktionieren mit jedem OpenAI SDK oder Client.
Streaming, Function Calling und JSON-Modus werden unterstützt, mit einem Kontextfenster von 100.000 Token.
Ein Vollkey erlaubt 8 parallele Anfragen und 300 pro Minute, also plane für ausgelastete Apps eine kleine Warteschlange ein.
Die Abrechnung erfolgt mit $0,15 pro 1 Mio. Input-Token und $0,50 pro 1 Mio. Output-Token aus Prepaid-Guthaben, und Prompts werden nicht zum Training verwendet.

Was du von einem Endpunkt erhältst

Nutzer suchen nach dem Uncensored LLM Hub, wenn sie ein Modell wollen, das ohne Inhaltsfilter für die rechtmäßige Erwachsenennutzung antwortet, aber nicht selbst GPUs betreiben wollen. Der Dienst ist eine einfache HTTPS-API. Du richtest einen OpenAI-Client auf https://api.uncensoredllmhub.com/v1 ein, sendest die Modell-ID uncensored und authentifizierst dich mit Authorization: Bearer YOUR_KEY. Es gibt zwei Methoden: POST /v1/chat/completions für Konversationen und GET /v1/models zum Auflisten.

Es hilft, Klarheit darüber zu haben, was sich hinter diesem Endpunkt verbirgt. Es ist ein Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und darauf optimiert, Inhaltsfilter zu überspringen. Es ist nicht die offizielle API eines großen Anbieters und kein Router, der zwischen Modellen wählt. Es verarbeitet nur Text: keine Bilder, Audio, Video, Embeddings oder Fine-Tuning. Eine harte Regel gilt ohne Ausnahme: keine sexuellen Inhalte mit Minderjährigen.

Diese enge Einschränkung ist der Punkt. Ein einziger stabiler Endpunkt ist einfach zu integrieren. Die folgenden Abschnitte zeigen ein kleines Chat-Backend, dann eine Agent-Schleife und schließlich die Limits, für die du planen musst.

Schritt 1: Bestehenden Client verbinden

Da die API dem OpenAI-Format folgt, musst du selten neuen Client-Code schreiben. Öffne dein SDK oder Tool, ändere die Base URL und den Schlüssel und setze das Modell auf uncensored. Melde dich zuerst auf der API-Schlüssel-Seite an (Google, oder E-Mail und Passwort), und beanspruche dann das $0.50 Testguthaben mit einem Klick. Das Testguthaben benötigt keine Karte, dauert 7 Tage und ist auf eine pro Person begrenzt.

Eine minimale Anfrage in Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant for a writing tool."},
        {"role": "user", "content": "Give me three opening lines for a mystery set on a ferry."},
    ],
    temperature=0.9,
    top_p=0.95,
)
print(resp.choices[0].message.content)

Sampling-Einstellungen wie temperature, top_p, stop, seed und die Frequency- und Presence-Penalties werden an das Modell durchgereicht, sodass die Regler, die du von anderen Anbietern kennst, gleich funktionieren. Der gleiche Aufruf funktioniert auch in Tools, die einen benutzerdefinierten OpenAI-kompatiblen Endpunkt akzeptieren, z. B. SillyTavern oder Open WebUI: Base URL einfügen, Schlüssel hinzufügen, Modell-ID manuell eingeben.

Schritt 2: Antworten in eine Chat-Oberfläche streamen

Chat-Apps wirken langsam, wenn der Nutzer in einer leeren Box starrt, bis die vollständige Antwort ankommt. Streaming behebt das. Stelle stream: true ein, und die API sendet die Antwort als Server-Sent Events, mit der Nutzungsmeldung am Ende des Streams. Hier ist eine Node-Version, die Token weiterleitet, sobald sie eintreffen:

import OpenAI from "openai";

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

export async function streamReply(history, onToken, signal) {
  const stream = await client.chat.completions.create(
    { model: "uncensored", messages: history, stream: true },
    { signal }
  );
  let text = "";
  for await (const chunk of stream) {
    const piece = chunk.choices[0]?.delta?.content ?? "";
    if (piece) {
      text += piece;
      onToken(piece);
    }
  }
  return text;
}

Zwei Gewohnheiten sparen später Ärger. Übergebe immer ein Abort-Signal und breche es ab, wenn der Nutzer den Tab schließt oder Stop drückt. Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet, daher fressen verwaiste Streams dein Kontingent auf. Halte außerdem den vollständigen Text, den du zusammengebaut hast, da du ihn als Assistant-Nachricht für den nächsten Durchgang an die Historie anhängst.

Wenn du während des Streamings vage Fehler in deinem Frontend siehst, behandelt unsere Notiz zur Diagnose von Streaming-Ausfällen die üblichen Ursachen, wie eine falsche base URL, einen Proxy, der Events puffert, und die beiden 429-Codes.

Schritt 3: Den langen Kontext gezielt nutzen

Das Kontextfenster ist 100.000 Token groß, geteilt zwischen Prompt und Completion. Für ein Storywriting-Tool, einen Character-Chat oder einen Dokumenten-Assistenten bietet das Platz für eine lange Historie, einen großen System-Prompt und Referenzmaterial gleichzeitig. Du musst max_tokens nicht einstellen; die Completion kann den Rest verwenden.

Langer Kontext ist zu diesen Preisen günstig zum Ausprobieren. Das Füllen des gesamten Fensters mit Input kostet 0,1 × 0,15 $ = 0,015 $ für 100.000 Input-Token. Füge eine Antwort mit 2.000 Token hinzu (0,002 × 0,50 $ = 0,001 $), und ein fast volles Request kostet 0,016 $. Du wirst das Fenster trotzdem verwalten wollen, aus drei Gründen: Die Latenz steigt mit der Prompt-Größe, jeder Durchgang sendet die Historie erneut, sodass sich die Kosten über eine Sitzung summieren, und sehr lange Historien verwässern die Anweisungen oben.

Eine einfache Richtlinie funktioniert gut:

Halte den System-Prompt und jedes feste Referenzmaterial am Anfang.
Behalte die neuesten Schritte wortwörtlich.
Wenn die Historie einen von dir gewählten Schwellenwert überschreitet, z. B. 60.000 Token, bitte das Modell, den ältesten Teil in eine kurze Zusammenfassung zu fassen und ersetze diese Durchgänge dadurch.
Lese usage.prompt_tokens aus jeder Antwort, um zu wissen, wie groß der nächste Request sein wird, anstatt nach Zeichen zu schätzen.

Schritt 4: Tools und strukturierte Ausgabe für Agents

Agents brauchen zwei Dinge von einem Modell: eine Möglichkeit, Funktionen aufzurufen, und eine Ausgabe, die du parsen kannst. Beides wird unterstützt. Tool Calling nutzt die Standardparameter tools und tool_choice, Tool Calls können gestreamt werden, und Ergebnisse gehen als Nachrichten mit role: "tool" zurück. Ein einzelner Roundtrip sieht so aus:

import json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_order",
        "description": "Find an order by its number.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup goes here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Validiere die Argumente immer, bevor du etwas mit Seiteneffekten ausführst. Ein Modell kann einen fehlerhaften oder unerwarteten Wert erzeugen, und dein Code ist die letzte Verteidigungslinie.

Für reine strukturierte Ausgabe ohne Tools verwende den JSON-Modus mit response_format auf {"type": "json_object"}. Beschreibe die gewünschte Form auch im Prompt und parsee die Antwort in einem try-Block, damit eine schlechte Antwort einen Retry auslöst statt eines Crashes.

curl https://api.uncensoredllmhub.com/v1/chat/completions   -H "Authorization: Bearer $API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Reply with JSON: {"title": string, "tags": [string]}"},
      {"role": "user", "content": "Describe a noir story set in a rainy port city."}
    ]
  }'

Grenzen, die du beachten musst

Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Trial-Schlüssel erlaubt 2 und 60. Der Body kann bis zu 8 MB groß sein. Jede Antwort enthält X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests und X-RateLimit-Limit-Concurrency, die sich zum Loggen eignen.

Wenn du ein Limit überschreitest, gibt die API HTTP 429 zurück. Der Code ist rate_limited für zu viele Anfragen pro Minute und concurrency für zu viele gleichzeitig. Eine temporäre Überlastung gibt ebenfalls 429 zurück, mit Retry-After: 5. Für eine Multi-User-App setze eine kleine Warteschlange vor die API: einen Semaphore, der unter dem Concurrency-Limit liegt, und einen Retry, der Retry-After beachtet. Für einen Agenten, der in parallele Tool Calls aufteilt, begrenze das Fan-Out auf dieselbe Anzahl.

Die vollständige Parameterliste und das Fehlerformat findest du in der API-Dokumentation.

Kosten, Aufladungen und Datenverarbeitung

Die Preise liegen bei 0,15 $ pro 1 Mio. Input-Token und 0,50 $ pro 1 Mio. Output-Token, vom Prepaid-Guthaben. Es gibt kein Abonnement, das Guthaben verfällt nie, und fehlgeschlagene oder abgelehnte Requests werden nicht berechnet. Ein Chat-Durchgang mit 1.500 Input- und 500 Output-Token kostet 0,0015 × 0,15 $ + 0,0005 × 0,50 $ = 0,000225 $ + 0,00025 $ = 0,000475 $, also decken 20 $ Kredit etwa 42.000 solcher Durchgänge.

Du kannst jeden beliebigen Gesamtbetrag von $20 bis $500 aufladen. Der Bonus beträgt +5 % ab $50, +10 % ab $100 und +15 % ab $200. Bezahle mit der Karte (Visa, Mastercard, Apple Pay, Google Pay) oder Krypto (USDT auf TRC20, USDC auf Base). Die Preisseite enthält die aktuelle Tabelle.

Zu den Daten: Prompts werden nicht zum Training verwendet. Lies die Datenschutzerklärung für die vollständige Formulierung. Du bleibst verantwortlich für das, was du mit dem Modell baust, und der Service ist nur für die rechtmäßige Erwachsenennutzung gedacht.