DE ▾
API-Schlüssel erhalten
OpenAI-kompatible unzensierte API für Entwickler.Aktualisiert

JSON-Modus und Function Calling bei Uncensored LLM API

Der Schalter für den JSON-Modus der unzensierten LLM-API ist derselbe, den du bereits von OpenAI-Clients kennst: Sende response_format mit type json_object und die Antwort kommt als JSON-Objekt zurück. Diese Seite behandelt das sowie Tool Calling mit Code, den du gegen den Live-Endpunkt ausführen kannst.

Leuchtende Klammern, zusammengesetzt aus Würfeln mit einem Roboterarm, illustrieren strukturierte JSON-Ausgabe und Tool-Aufrufe

Schnellstart mit curl

Die kleinste funktionierende JSON-Modus-Anfrage sieht so aus. Sie verwendet die Base URL https://api.uncensoredllmapi.com/v1, das Modell uncensored und deinen Schlüssel als Bearer-Token:

curl https://api.uncensoredllmapi.com/v1/chat/completions   -H "Authorization: Bearer $UNCENSORED_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Reply only with a JSON object."},
      {"role": "user", "content": "Create a tavern NPC with keys name, trade and rumour."}
    ]
  }'

Die Assistant-Nachricht in choices[0].message.content ist ein String, der ein JSON-Objekt enthält. Du musst sie selbst parsen. Überspringe nicht die Anweisung im Prompt: Der JSON-Modus beschränkt die Ausgabe auf ein Objekt, kann aber nicht erraten, welche Schlüssel du möchtest. Die Benennung der Schlüssel und idealerweise ein einzeiliges Beispiel liefern dir eine stabile Struktur.

Wenn du noch keinen Schlüssel hast, gibt es auf der API-Schlüssel-Seite nach der Anmeldung mit einem Klick $0,50 kostenloses Testguthaben. Dieses Guthaben benötigt keine Zahlung, gilt 7 Tage lang und ist pro Person auf einen Anspruch begrenzt.

JSON-Modus in Python mit Validierung

Behandle die Modellausgabe wie jede andere externe Eingabe. Parse sie, prüfe sie gegen ein Schema und wiederhole begrenzt oft bei einem Fehler. Pydantic macht dies kurz:

import json, os
from openai import OpenAI
from pydantic import BaseModel, ValidationError

client = OpenAI(
    base_url="https://api.uncensoredllmapi.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

class Npc(BaseModel):
    name: str
    trade: str
    rumour: str

SYSTEM = (
    "Reply only with a JSON object with exactly these keys: "
    "name, trade, rumour. Each value is a string."
)

def make_npc(setting, tries=3):
    for _ in range(tries):
        r = client.chat.completions.create(
            model="uncensored",
            response_format={"type": "json_object"},
            messages=[
                {"role": "system", "content": SYSTEM},
                {"role": "user", "content": f"Setting: {setting}"},
            ],
            temperature=0.7,
            max_tokens=300,
        )
        choice = r.choices[0]
        if choice.finish_reason == "length":
            continue           # cut off, so the JSON is incomplete
        try:
            return Npc(**json.loads(choice.message.content))
        except (json.JSONDecodeError, ValidationError, TypeError):
            continue
    raise RuntimeError("no valid JSON after retries")

print(make_npc("a river port in a plague year"))

Drei Gewohnheiten in diesem Snippet sind es wert, kopiert zu werden. Der Code prüft finish_reason vor dem Parsing, da eine Antwort, die bei max_tokens endet, mitten im Objekt abbricht. Er verwendet eine moderate Temperatur, da hohe Temperaturen die Wahrscheinlichkeit fehlerhafter Ausgaben erhöhen. Und er begrenzt Retries, damit ein schlechter Prompt nicht endlos läuft. Da fehlgeschlagene oder abgelehnte Anfragen nicht berechnet werden, ist das Retry-Budget eine Latenzfrage und keine Kostenfrage.

Häufige Fehler im JSON-Modus

  • JSON im Prompt anzufordern, aber nicht in response_format. Das Modell wird oft zustimmen, kann das Objekt aber in Text oder einen Code-Fence einbetten. Setze beides.
  • max_tokens zu niedrig setzen. Schätze die längste gültige Antwort und füge Puffer hinzu. Eine lange Liste von Elementen kann leicht 300 Token überschreiten.
  • Ein Array auf oberster Ebene zu erwarten. Der JSON-Modus verlangt ein Objekt. Wenn du eine Liste brauchst, fordere {"items": [...]} an.
  • Eine Stop-Sequenz zu stapeln, die im JSON vorkommt. Der Parameter stop wird durchgereicht, und ein Stop-String, der in einem Wert vorkommt, bricht die Antwort vorzeitig ab.
  • Den JSON-Modus mit Streaming zu verwenden und jeden Chunk zu parsen. Sammle zuerst den gesamten Text und parse dann einmal am Ende.

Sampling-Einstellungen wie Temperatur, top_p, Seed und die Penalties werden durchgereicht. Für Extraktionsaufgaben liefern eine niedrige Temperatur um 0,2 und ein fester seed die wiederholbarste Ausgabe. Für kreative Generierung wie der NPC oben ist ein höherer Wert in Ordnung, solange du validierst.

Tool Calling: Der vollständige Loop

Tool Calling ermöglicht es dem Modell, deinen Code aufzufordern, etwas zu tun, und dann mit dem Ergebnis fortzufahren. Der Ablauf hat vier Schritte: Du definierst Tools, das Modell antwortet mit tool_calls, du führst sie aus und sendest die Ergebnisse als Nachrichten mit role: "tool" zurück.

import json, os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmapi.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_inventory",
        "description": "Return the stock count for an item in the shop.",
        "parameters": {
            "type": "object",
            "properties": {"item": {"type": "string"}},
            "required": ["item"],
        },
    },
}]

def lookup_inventory(item):
    stock = {"healing potion": 4, "rope": 12}
    return {"item": item, "count": stock.get(item.lower(), 0)}

messages = [{"role": "user", "content": "Do you still have healing potions?"}]

for _ in range(4):                      # hard cap on tool rounds
    r = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools, tool_choice="auto"
    )
    msg = r.choices[0].message
    if not msg.tool_calls:
        print(msg.content)
        break
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = lookup_inventory(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

Die Argumente kommen als JSON-String an, den du parsen musst, und das Modell kann gelegentlich Argumente produzieren, die nicht zu deinem Schema passen. Validiere sie, bevor du Aktionen mit Seiteneffekten ausführst. Übergebe sie niemals ohne Prüfungen an eine Shell, eine SQL-Zeichenkette oder einen Dateipfad.

Das Feld tool_choice ermöglicht es dir, das Verhalten zu steuern. Lass es auf "auto" und das Modell entscheidet. Benenne eine bestimmte Funktion, um einen Aufruf zu erzwingen, was nützlich ist, wenn du strukturierte Extraktion über ein Tool-Schema statt über den JSON-Modus möchtest.

Tool-Aufrufe streamen in Node

Mit stream: true kommen Tool-Aufrufe in Stücken an. Jeder Chunk enthält ein Fragment des Funktionsnamens oder des Argumentenstrings, indiziert nach Position. Du musst die Fragmente pro Index verketten und erst am Ende des Streams parsen.

import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  stream: true,
  messages: [{ role: "user", content: "Check stock for rope." }],
  tools: [{
    type: "function",
    function: {
      name: "lookup_inventory",
      description: "Return the stock count for an item.",
      parameters: {
        type: "object",
        properties: { item: { type: "string" } },
        required: ["item"],
      },
    },
  }],
});

const calls = [];
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta;
  for (const tc of delta?.tool_calls ?? []) {
    const slot = (calls[tc.index] ??= { id: "", name: "", args: "" });
    if (tc.id) slot.id = tc.id;
    if (tc.function?.name) slot.name += tc.function.name;
    if (tc.function?.arguments) slot.args += tc.function.arguments;
  }
}

for (const c of calls) {
  console.log(c.name, JSON.parse(c.args));
}

Denke daran, dass eine gestreamte Anfrage einen deiner Concurrency-Slots belegt, bis der Stream endet. Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 pro Minute, ein Trial-Schlüssel 2 und 60. Das Erreichen eines Limits gibt HTTP 429 mit dem Code concurrency oder rate_limited zurück. Die Nutzungsgesamtmengen werden am Ende des Streams gemeldet, was praktisch für das Logging der Kosten ist.

JSON-Modus oder ein Tool-Schema

Beides liefert dir strukturierte Daten, also welches sollst du verwenden? Die entscheidende Frage ist, ob das Modell Daten erzeugt oder eine Aktion auswählt.

Verwende den JSON-Modus, wenn die Ausgabe selbst das Produkt ist: ein NPC-Bogen, eine Liste von Tags, eine Klassifizierung mit einem Confidence-Feld. Du kontrollierst den gesamten Prompt, erhältst ein Objekt zurück und zahlst nur für eine Anfrage.

Verwende Tools, wenn das Modell entscheiden muss, ob es handelt, oder wenn mehrere verschiedene Aktionen möglich sind. Ein Schema pro Funktion dokumentiert den Vertrag, tool_choice ermöglicht es dir, einen Aufruf zu erzwingen oder zu erlauben, und der Loop im vorherigen Abschnitt behandelt mehrstufige Arbeiten. Die Kosten sind eine zusätzliche Anfrage pro Runde plus die Tool-Definitionen, die jedes Mal als Input gezählt werden.

Ein praktischer Mittelweg für Extraktion: Definiere ein Tool, dessen Parameter die Felder sind, die du möchtest, und setze tool_choice auf diese Funktion. Du erhältst Argument-JSON, das der Struktur deines Schemas folgt, ohne die Schlüsselliste in den Prompt schreiben zu müssen. Validiere das Ergebnis in jedem Fall, bevor du ihm vertraust, und logge den X-Request-Id-Wert jeder Anfrage, die etwas Unerwartetes erzeugt hat.

Was es kostet

JSON und Tool-Aufrufe werden wie alle anderen Token abgerechnet: $0,15 pro 1M Input und $0,50 pro 1M Output. Tool-Definitionen zählen bei jeder Anfrage als Input, und jedes Tool-Ergebnis, das du zurücksendest, erhöht den Input der nächsten Anfrage.

Beispiel: Ein Tool-nutzender Assistant-Turn mit einem 600-Token-Tool-Schema und Prompt, einem 150-Token-Modellaufruf, dann einer zweiten Anfrage mit 900 Input-Token (vorherige Nachrichten plus ein Tool-Ergebnis) und einer 200-Token-Antwort.

  • Anfrage eins: 600 Input und 150 Output. Input 600 x $0,15 / 1M = $0,00009. Output 150 x $0,50 / 1M = $0,000075. Zwischensumme $0,000165.
  • Anfrage zwei: 900 Input und 200 Output. Input 900 x $0,15 / 1M = $0,000135. Output 200 x $0,50 / 1M = $0,0001. Zwischensumme $0,000235.
  • Gesamt für den Turn: $0,0004.

Bei dieser Rate kosten 1.000 Turns 0,40 $. Das Guthaben wird im Voraus in ganzen Beträgen von 20 $ bis 500 $ aufgeladen (Bonus: +5 % ab 50 $, +10 % ab 100 $, +15 % ab 200 $), bezahlt mit Krypto, USDT auf TRC20 oder USDC auf Base. Schau dir die Preisseite für aktuelle Werte an.

Nächste Schritte

Die Referenz für jedes Anfragefeld findest du in der API-Dokumentation. Wenn du eine Anwendung für den Live-Betrieb vorbereitest, ist die Produktions-Checkliste die nächste Seite zum Lesen, und der Support hilft dir, falls eine Anfrage unerwartet reagiert. Halte deine Anfrage-ID bereit, die im X-Request-Id-Header zurückgegeben wird.

Der Dienst ist nur Text und das Kontextfenster umfasst 100.000 Token, einschließlich deiner Tool-Definitionen und -Ergebnisse. Sexuelle Inhalte mit Minderjährigen sind nicht erlaubt, und das gilt für strukturierte und tool-gesteuerte Ausgaben genau so wie für normalen Chat.

Fragen und Antworten

Garantiert der JSON-Modus mein exaktes Schema?

Nein. Er macht die Antwort zu einem JSON-Objekt, aber die Schlüssel stammen aus deinem Prompt. Validiere das Ergebnis mit einer Schema-Bibliothek und wiederhole, wenn es fehlschlägt.

Wie sende ich Tool-Ergebnisse zurück?

Füge die Assistant-Nachricht mit den tool_calls an und füge dann für jeden Aufruf eine Nachricht mit role: tool, der passenden tool_call_id und dem Ergebnis als String hinzu.

Kann ich Tool-Aufrufe streamen?

Ja. Bei aktiviertem Stream (stream=true) kommen die tool_calls fragmentiert an. Verkette die Namen- und Argument-Strings nach Index und analysiere sie, sobald der Stream endet.

Werden ungültige JSON-Antworten berechnet?

Eine Antwort, die abgeschlossen ist, wird berechnet, auch wenn dein Parser sie ablehnt. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet.

Dein Schlüssel ist nur ein Formular entfernt

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