DE ▾
API-Schlüssel erhalten

So nutzt du ein LLM-Modell über eine API, Schritt für Schritt

Die Nutzung eines gehosteten Sprachmodells reduziert sich auf einen HTTP-Aufruf mit Schlüssel, Modellname und einer Liste von Nachrichten. Diese Anleitung führt dich von einem leeren Ordner zu Streaming, JSON-Ausgabe und Tool-Aufrufen.

Aktualisiert

Terminal verbunden mit einem Würfel aus Chat-Blasen, Daten streamen zwischen ihnen, repräsentiert einen LLM-API-Aufruf
01

Wichtige Punkte

  • Die API ist OpenAI-kompatibel: Ändere die Base URL und den Schlüssel, behalte dein SDK.
  • Verwende die Modell-ID uncensored mit POST /v1/chat/completions.
  • Streaming, JSON-Modus und Tool Calling funktionieren mit den Standardparametern.
  • Ein 429 bedeutet, dass ein Limit erreicht wurde, und der Fehlercode sagt dir, welches.

Was du vor der ersten Anfrage brauchst

Wenn du wissen möchtest, wie du LLM-Modell-Endpunkte in deinem eigenen Code nutzt, reichen drei Dinge: ein Schlüssel, eine Base URL und ein Modellname. Es muss kein spezieller Client installiert werden. Jedes OpenAI SDK oder Client funktioniert, sobald du es auf eine andere Adresse zeigst.

  • Basis-URL: https://api.llmmodelsapi.com/v1
  • Modell-ID: uncensored
  • Auth: ein Authorization: Bearer YOUR_KEY Header, den die SDKs für dich hinzufügen

Um einen Schlüssel zu erhalten, registriere dich mit Google oder mit E-Mail und Passwort, und öffne dann die API-Schlüssel-Seite. Neue Konten können dort mit einem Klick $0,50 Testguthaben beanspruchen, ohne Kreditkarte, gültig für 7 Tage. Das reicht für alles in diesem Artikel. Der Endpunkt unterstützt zwei Methoden: POST /v1/chat/completions zur Generierung und GET /v1/models zur Auflistung der verfügbaren Modelle.

Es hilft, zu wissen, was das Modell ist, damit deine Erwartungen stimmen. Es ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird und darauf abgestimmt ist, ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle API eines großen Anbieters und verarbeitet nur Text. Es gibt keine Bild- oder Audio-Generierung, keine Embeddings und kein Fine-Tuning.

Schritt 1: Schlüssel mit curl prüfen

Bevor du Anwendungscode schreibst, bestätige, dass der Schlüssel und der Netzwerkpfad funktionieren. Das Auflisten der Modelle ist die günstigste Prüfung, da es nichts generiert.

export LLM_KEY="paste-your-key-here"

# the list should include the model id: uncensored

curl https://api.llmmodelsapi.com/v1/models   -H "Authorization: Bearer $LLM_KEY"

Du solltest eine JSON-Liste erhalten, die uncensored enthält. Wenn du einen 401 siehst, ist der Schlüssel falsch oder das Wort Bearer fehlt. Sende jetzt eine echte Chat-Anfrage.

curl https://api.llmmodelsapi.com/v1/chat/completions   -H "Authorization: Bearer $LLM_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain what a context window is in two sentences."}
    ],
    "max_tokens": 150
  }'

Die Antwort enthält ein choices Array, und der Text steht bei choices[0].message.content. Die Antwort-Header enthalten X-Request-Id und X-Balance-USD, sodass du dein verbleibendes Guthaben bei jedem Aufruf sehen kannst. Das Feld usage zeigt die für die Abrechnung gezählten Token an.

Schritt 2: Aufruf aus Python oder Node

In der Praxis wirst du ein SDK verwenden. Installiere das offizielle OpenAI-Paket und setze dann die Basis-URL, wenn du den Client erstellst. Nichts anderes an deinem Code ändert sich.

Python

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You answer in plain language."},
        {"role": "user", "content": "Give me three names for a fantasy tavern."},
    ],
    temperature=0.9,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Node

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});

console.log(resp.choices[0].message.content);

Bewahre den Schlüssel in einer Umgebungsvariable auf, nicht in der Quelldatei. Wenn ein Schlüssel bekannt wird, ersetze ihn auf der Schlüssel-Seite, dann funktioniert der alte nicht mehr.

Schritt 3: Ausgabe mit Parametern formen

Das Modell ist ein Textprädiktor, daher ist es genauso wichtig, wie du die Anfrage formulierst, wie die Parameter. Einige Gewohnheiten lohnen sich sofort.

  • Verwende die Systemnachricht für stehende Regeln. Lege Tonfall, Format und Rolle dort fest und behalte die Benutzernachricht für die eigentliche Aufgabe.
  • Sei spezifisch bezüglich der Länge. Fordere "drei Aufzählungspunkte" oder "unter 120 Wörter". Das ist zuverlässiger, als nur max_tokens zu senken, was den Text mitten im Satz abschneidet.
  • Stelle die Temperatur auf den Job ein. Rund 0,2 eignet sich für Extraktion und Klassifizierung. Rund 0,8 bis 1,0 eignet sich für Fiktion und Roleplay.
  • Gib nur das, was du brauchst. top_p, stop, seed und die Häufigkeits- und Vorhandenseins-Strafen werden an das Modell weitergegeben.

Das Kontextfenster umfasst 100.000 Token, einschließlich Prompt und Antwort zusammen. Du musst max_tokens nicht setzen, da die Antwort den verbleibenden Platz nutzen kann. Das Setzen ist dennoch eine gute Möglichkeit, die Kosten zu begrenzen.

Eine praktische Methode, diese Einstellungen zu lernen, ist, denselben Prompt dreimal bei verschiedenen Temperaturen auszuführen und die Ergebnisse zu vergleichen. Ändere pro Durchlauf nur einen Wert und halte den Rest konstant, verwende dabei wo möglich denselben seed. Nach zehn Minuten solcher Tests kennst du das Verhalten des Modells für deine Aufgabe viel besser als jede Beschreibung es könnte, und die Kosten für das Experiment betragen nur einen Bruchteil eines Cents.

Die Preise liegen bei $0,15 pro Million Input-Token und $0,50 pro Million Output-Token. Eine Anfrage mit 1.500 Input-Token und 400 Output-Token kostet 1.500 × 0,15 / 1.000.000 = $0,000225 plus 400 × 0,50 / 1.000.000 = $0,0002, also insgesamt $0,000425. Die Preisseite enthält die Optionen zum Aufladen.

Schritt 4: Antwort streamen

Das Warten auf eine vollständige Antwort fühlt sich in einer interaktiven App langsam an. Mit stream: true sendet der Server Token als Server-Sent Events, und deine UI kann sie ausgeben, wenn sie eintreffen. Die Nutzung wird am Ende des Streams gemeldet.

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short story opening about a lighthouse."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Eine Sache, an die du dich erinnern solltest: Eine gestreamte Anfrage belegt ihren Slot, bis der Stream endet. Ein voller Schlüssel erlaubt 8 gleichzeitige Anfragen, ein Test-Schlüssel erlaubt 2. Wenn du einen Stream im Browser öffnest und ihn nie schließt, bleibt dieser Slot belegt.

Schritt 5: JSON-Modus und Tool-Calling

Wenn ein anderes Programm die Antwort lesen muss, wird Freitext zu einem Problem. Der JSON-Modus bittet das Modell, ein gültiges JSON-Objekt zurückzugeben.

import json
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
    ],
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Beschreibe auch im Prompt die gewünschte Struktur, da der JSON-Modus gültige Syntax garantiert, aber nicht deine exakten Feldnamen. Packe das Parsing in einen try-Block und versuche es bei einem Fehler einmal erneut.

Tool Calling lässt das Modell deinen Code eine Funktion ausführen lassen. Du beschreibst die Tools, das Modell antwortet mit einem tool_calls Eintrag, du führst ihn aus und sendest das Ergebnis als Nachricht mit role: "tool" zurück.

import json
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Return the current time for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"time": "14:05"}),
})

final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

In der Produktion solltest du prüfen, ob tool_calls vorhanden ist, bevor du darauf zugreifst, da das Modell direkt antworten kann, anstatt die Funktion aufzurufen. Der Parameter tool_choice lässt dich einen Aufruf erzwingen oder verbieten, wenn du das brauchst.

Eine Konversation am Laufen halten

Die API hat kein Gedächtnis zwischen Aufrufen. Wenn du möchtest, dass das Modell sich daran erinnert, was vor zwei Runden gesagt wurde, sendest du diese Runden erneut. Eine Chat-App ist daher eine Liste, die wächst: Du hängst die Benutzernachricht an, rufst die API auf, hängst die Assistenten-Antwort an und wiederholst das.

from openai import OpenAI

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]

def say(text):
    history.append({"role": "user", "content": text})
    resp = client.chat.completions.create(model="uncensored", messages=history, max_tokens=300)
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))

Da jeder Aufruf die gesamte Liste enthält, steigen Kosten und Latenz mit der Konversation. Wenn die Historie lang wird, entferne die ältesten Runden oder ersetze sie durch eine Zusammenfassung in einem Absatz. Du hast viel Platz, da 100.000 Token etwa der Länge eines kurzen Romans entspricht, aber es gibt keinen Grund, für Token zu zahlen, die der Antwort nicht mehr helfen.

Aus dem gleichen Grund halte die Systemnachricht kurz und stabil. Sie wird bei jedem Aufruf gesendet, also sind 1.000 Token System-Prompt über 500 Anfragen 500.000 Input-Token, was allein 500.000 x 0,15 / 1.000.000 = $0,075 kostet.

Fehler, die Anfänger machen

  • Das Vergessen, die Assistenten-Antwort anzuhängen. Das Modell sieht dann nur deine Fragen und verliert den Faden.
  • Geheimnisse im Frontend zu platzieren. Ein Schlüssel im Browser-Code ist für jeden sichtbar. Rufe die API von deinem Server aus auf und exponiere stattdessen deinen eigenen Endpunkt.
  • Fakten von einem Textprädiktor erwarten. Das Modell kann falsche Details mit Sicherheit behaupten. Gib ihm den Quelltext im Prompt, wenn Genauigkeit wichtig ist, und prüfe wichtige Ausgaben.
  • Freitext parsen. Wenn Code die Antwort lesen muss, verwende den JSON-Modus oder einen Tool Call statt regulärer Ausdrücke.

Fehler, Limits und der weitere Weg

Die meisten Probleme fallen in eine kurze Liste.

SymptomWahrscheinliche UrsacheLösung
401-AntwortFehlender oder falscher SchlüsselPrüfe den Bearer-Header und den Schlüssel auf der Schlüssel-Seite
429, Code rate_limitedÜber 300 Anfragen pro Minute (60 auf einem Test-Schlüssel)Verlangsame oder warte Anfragen
429, Code concurrencyÜber 8 gleichzeitige Anfragen (2 auf einem Test-Schlüssel)Begrenze parallele Worker, schließe offene Streams
429 mit Retry-After: 5Vorübergehende ÜberlastungWarte 5 Sekunden und versuche es erneut
Anfrage zu großKörper über 8 MBSende weniger Text pro Aufruf

Ein einfacher Retry mit kurzer Verzögerung behandelt 429-Fälle. Fehlgeschlagene Anfragen werden nicht berechnet, daher verursacht ein Retry keine zusätzlichen Kosten. Prompts werden nicht zum Training verwendet.

Von hier aus listet die API-Dokumentation jeden Parameter auf, und die Pay-per-Token-Übersicht erklärt, für wen der Service gedacht ist. Eine Regel gilt überall: Sexuelle Inhalte mit Minderjährigen sind niemals erlaubt.

02

Fragen und Antworten

Welche Modell-ID sende ich in der Anfrage?

Verwende uncensored als Modellwert in jeder Anfrage. Du kannst dies bestätigen, indem du GET /v1/models aufrufst.

Brauche ich ein spezielles SDK?

Nein. Jedes OpenAI SDK oder jeder Client funktioniert, sobald du die Base URL auf https://api.llmmodelsapi.com/v1 änderst und deinen eigenen Schlüssel verwendest.

Kann ich es ohne Kreditkarte nutzen?

Ja, zum Testen. Neue Nutzer können nach der Registrierung mit einem Klick $0,50 Testguthaben beanspruchen, ohne Kreditkarte, gültig für 7 Tage.

Wie groß kann mein Prompt sein?

Das Kontextfenster ist 100.000 Token groß für Prompt und Completion zusammen, und der Request Body kann bis zu 8 MB groß sein.

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 erhalten