LLM Inference APIAnleitung
LLM Inference API: Streaming, Tools und JSON-Modus
Eine LLM-Inferenz-API ermöglicht es dir, einen Prompt über HTTPS zu senden und generierten Text zurückzuerhalten, ohne dass du eine GPU benötigst. Diese Seite zeigt eine funktionierende Einrichtung gegen einen OpenAI-kompatiblen Endpunkt, von der ersten Anfrage über Streaming, Tools, JSON-Modus bis hin zu Ratenlimits.
Aktualisiert:

Wichtige Punkte
- Richte ein beliebiges OpenAI SDK auf https://api.llminferenceapi.com/v1, ein, verwende die Modell-ID uncensored und sende deinen Schlüssel als Bearer-Token.
- Zwei Endpunkte sind verfügbar: POST /v1/chat/completions und GET /v1/models.
- Streaming, Function Calling und JSON-Modus funktionieren über die Standard-Anfragefelder.
- Ein Voll-Key erlaubt 8 parallele Anfragen und 300 pro Minute; eine 429-Antwort zeigt dir, welches Limit du erreicht hast.
Was du vor dem ersten Aufruf brauchst
Du brauchst drei Dinge: eine Base URL, einen Schlüssel und einen Modellnamen. Die Base URL ist https://api.llminferenceapi.com/v1, die Modell-ID ist uncensored, und den Schlüssel erhältst du auf der API-Schlüssel-Seite nach der Anmeldung mit Google oder E-Mail und Passwort. Neue Nutzer können dort mit einem Klick $0,50 an Testguthaben beanspruchen. Es wird keine Karte benötigt, es gilt 7 Tage lang und ist auf eine Person beschränkt.
Der Dienst ist nur für Text. Er stellt POST /v1/chat/completions und GET /v1/models bereit. Es gibt keine Embeddings-Route, keine Bild- oder Audio-Generierung und kein Fine-Tuning. Es läuft ein Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und optimiert, um ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle API eines Modell-Anbieters. Eine harte Regel gilt: Inhalte, die Minderjährige sexualisieren, sind nicht erlaubt.
Bewahre den Schlüssel in einer Umgebungsvariable auf, anstatt ihn in den Quellcode zu schreiben. Die folgenden Beispiele lesen ihn aus API_KEY, wo die Sprache es erlaubt.
Deine erste Anfrage
Beginne mit curl, da es genau zeigt, was über die Leitung geht.
curl https://api.llminferenceapi.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses of a message queue."}
],
"temperature": 0.7
}'
Die Antwort ist das übliche Chat-Completion-Objekt: choices[0].message.content enthält den Text und usage enthält die Token-Anzahlen. Du kannst auch Modelle auflisten mit GET /v1/models, was ein schneller Weg ist, um zu bestätigen, dass Schlüssel und URL korrekt sind, bevor du etwas anderes debuggst.
In Python mit dem offiziellen OpenAI SDK ändert sich nur der Konstruktor:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.llminferenceapi.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)
Und in Node:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llminferenceapi.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);
Die Completion kann alles verwenden, was vom 100.000-Token-Fenster nach deinem Prompt übrig ist, daher ist max_tokens optional. Setze es trotzdem, wenn du eine harte Obergrenze für Kosten oder Länge willst. Sampling-Steuerungen wie temperature, top_p, stop, seed und die Frequenz- und Präsenzstrafen werden durchgereicht.
Zwei Einstellungen sind von Anfang an wichtig zu kennen. seed macht das Sampling für Tests wiederholbar, was hilft, wenn du zwei Versionen eines Prompts vergleichst und willst, dass der Unterschied vom Prompt stammt und nicht vom Zufall. stop nimmt einen oder mehrere Strings, die die Generierung beenden, sobald das Modell sie schreibt, eine günstige Möglichkeit, eine Antwort an einem Trennzeichen abzuschneiden und nicht für Token zu bezahlen, die du verwerfen würdest.
Streaming-Antworten
Mit stream: true antwortet der Server über Server-Sent Events und sendet den Text in kleinen Deltas. Nutzer sehen die ersten Wörter schnell, was in Chat-Oberflächen wichtig ist. Nutzungsdaten kommen am Ende des Streams an.
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem 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("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Zwei Punkte sind leicht zu übersehen. Erstens kann das letzte Datenpaket Nutzungsdaten und eine leere choices-Liste enthalten, also prüfe, ob choices nicht leer ist, bevor du darauf zugreifst. Zweitens hält eine gestreamte Anfrage ihren Parallelitäts-Slot, bis der Stream endet. Wenn ein Client einen Stream öffnet und ihn nie bis zum Ende liest, bleibt dieser Slot belegt und deine späteren Anfragen können einen concurrency-Fehler auslösen. Schließe Streams immer oder verbrauche sie vollständig.
Function Calling
Tool Calling ermöglicht es dem Modell, deinen Code aufzurufen, um eine Funktion auszuführen, und das Ergebnis zu nutzen. Du beschreibst die Funktionen in tools, steuerst die Auswahl optional mit tool_choice, führst aus, was das Modell anfordert, und sendest die Ausgabe als Nachricht mit role: "tool" zurück.
import json
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up the status of an order by its id.",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
},
}]
messages = [{"role": "user", "content": "Where is order A-1043?"}]
first = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"order_id": args["order_id"], "status": "shipped"}
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)
Parst function.arguments immer defensiv. Es ist ein JSON-String, der von einem Sprachmodell erzeugt wurde, und in seltenen Fällen kann er fehlerhaft sein oder ein Feld enthalten, das du nicht definiert hast. Validiere es, bevor du darauf reagierst, besonders wenn die Funktion Daten ändert. Tool Calls funktionieren auch mit Streaming, wobei die tool_calls als Fragmente ankommen, die du nach Index verknüpfen musst, bevor du sie parst.
Verwaltung des Konversationsverlaufs
Die API ist zustandslos. Sie erinnert sich nicht an frühere Anfragen, daher funktioniert ein Multi-Turn-Chat nur, weil dein Code die früheren Nachrichten jedes Mal erneut sendet. Halte eine Liste von Nachrichten, hänge die neue Nachricht des Benutzers an, rufe den Endpunkt auf und hänge dann die Antwort des Assistenten an, bevor die nächste Nachricht kommt.
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(model="uncensored", messages=history)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))
Da jede Nachricht den Verlauf erneut sendet, wachsen die Input-Token mit der Länge des Chats. Das Fenster fasst 100.000 Token, was für die meisten Konversationen reicht, aber die Kosten steigen deutlich, bevor du das Limit erreichst. Ein häufiges Muster ist, die Systemnachricht und die letzten mehreren Nachrichten zu behalten und ältere Nachrichten durch eine kurze Zusammenfassung zu ersetzen, die das Modell selbst schreibt. Lies usage.prompt_tokens nach jedem Aufruf, um zu sehen, wie groß der Verlauf geworden ist.
JSON-Modus
Wenn du maschinenlesbare Ausgaben brauchst, setze response_format auf {"type": "json_object"} und sage im Prompt, dass du JSON willst. Die Beschreibung der erwarteten Keys macht das Ergebnis deutlich stabiler.
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
{"role": "user", "content": "Describe a short story about a lost robot."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Der JSON-Modus lässt die Ausgabe als JSON parsen, erzwingt aber nicht dein Schema. Prüfe die Keys im Code und halte eine Fallback-Lösung für den Fall bereit, wo ein Wert fehlt. Wenn die Antwort abgeschnitten wird, weil sie ein Token-Limit erreicht hat, ist das JSON unvollständig, also setze max_tokens für strukturierte Ausgaben nicht zu niedrig.
Eine kurze Checkliste bei Fehlern
Die meisten Probleme am ersten Tag stammen von einer Handvoll Ursachen, die du nacheinander ausschließen kannst.
- Base URL. Sie muss auf
/v1enden. Das SDK hängt/chat/completionsselbst an, daher funktioniert eine URL mit bereits enthaltenem Pfad nicht. - Key-Header. Der Schlüssel kommt in
Authorization: Bearergefolgt vom Schlüssel. Ein versehentlicher Leer- oder Zeilenumbruch, der mit dem Schlüssel kopiert wird, ist eine häufige Ursache für Authentifizierungsfehler. - Modell-ID. Verwende
uncensoredexakt. Namen der Modelle anderer Anbieter sind hier nicht gültig. - Anfragegröße. Die Body-Grenze beträgt 8 MB, und Prompt plus Completion müssen in 100.000 Tokens passen.
- Guthaben. Schau dir den
X-Balance-USD-Header auf jeder Antwort an, um zu sehen, ob das Guthaben das Problem ist. - Zitiere die Request-ID. Wenn du Support kontaktierst, füge den
X-Request-Id-Wert der fehlgeschlagenen Antwort bei, damit die Anfrage gefunden werden kann.
Behalte im Hinterkopf, dass eine Ablehnung nicht dasselbe ist wie ein Fehler. Da das Modell darauf abgestimmt ist, Inhaltsablehnungen bei gesetzlich zulässiger Erwachsennutzung zu vermeiden, wirst du weniger davon sehen als bei gefilterten Diensten, aber das Modell kann immer noch ablehnen oder eine schwache Antwort auf einen vagen Prompt geben. Eine klarere Systemnachricht behebt das in der Regel besser als eine höhere Temperatur.
Limits, Header und Wiederholungen
Ein Voll-Key erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Test-Key erlaubt 2 parallele Anfragen und 60 pro Minute. Der Anfrage-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, was praktisch für Logging und zum Anzeigen eines Guthabens in einem Admin-Bildschirm ist.
Wenn du ein Limit überschreitet, gibt die API HTTP 429 zurück. Der Fehlercode rate_limited bedeutet zu viele Anfragen pro Minute, und concurrency bedeutet zu viele gleichzeitig. Bei temporärer Überlastung erhältst du ebenfalls 429, mit einem Retry-After: 5-Header. Ein einfacher Retry-Wrapper deckt alle drei Fälle ab:
import time
from openai import RateLimitError
def ask(messages, tries=4):
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = 5 if attempt == 0 else 5 * (attempt + 1)
retry_after = getattr(e.response, "headers", {}).get("retry-after")
time.sleep(int(retry_after) if retry_after else wait)
raise RuntimeError("still rate limited after retries")
Begrenze für einen Worker-Pool die Pool-Größe auf dein Concurrency-Limit, anstatt dich auf Retries zu verlassen. Acht Worker auf einem Voll-Key werden selten einen concurrency-Fehler sehen. Wenn du unerwartete Fehler bekommst, geht der Fehlerbehebungs-Artikel die häufigsten Ursachen durch.
Bezahlung
Die Abrechnung erfolgt Pay as you go aus Prepaid-Guthaben: $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, kein Abonnement. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und Guthaben verfällt nie. Eine Anfrage mit 1.500 Input-Token und 400 Output-Token kostet 1.500 / 1.000.000 x $0,15 + 400 / 1.000.000 x $0,50 = $0,000225 + $0,0002 = $0,000425.
Aufladungen sind beliebige ganze Beträge von $20 bis $500, mit einem 5%-Bonus ab $50, 10% ab $100 und 15% ab $200. Du kannst mit Mit Krypto (USDT auf TRC20, USDC auf Base) bezahlen. Prompts werden nicht zum Training verwendet. Die Preisseite listet die Details auf und das Quickstart wiederholt die Einrichtungsschritte in Kurzform.
Weitere Anleitungen
Fragen und Antworten
Kann ich die offizielle OpenAI-Bibliothek mit dieser API verwenden?
Ja. Installiere das OpenAI SDK für Python oder Node, setze die Base URL auf https://api.llminferenceapi.com/v1, gib deinen Schlüssel ein und verwende die Modell-ID uncensored.
Unterstützt die API Function Calling?
Ja. Übergebe Tools und optional tool_choice, gib dann jedes Ergebnis als Nachricht mit der Rolle tool zurück. Auch gestreamte tool_calls werden unterstützt.
Was bedeutet ein 429-Fehler hier?
Du hast ein Limit erreicht. Der Code rate_limited bedeutet zu viele Anfragen pro Minute, concurrency bedeutet zu viele gleichzeitig, und ein Retry-After: 5-Header markiert eine temporäre Überlastung. Warte und versuche es erneut.
Kann ich es für Embeddings oder Bilder nutzen?
Nein. Die API ist nur für Text und bietet Chat-Completions und eine Modellliste an.
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