LLM Inference API: streaming, tools en JSON-modus
Een LLM-inferentie-API stelt je in staat een prompt over HTTPS te versturen en gegenereerde tekst terug te krijgen, zonder GPU aan je kant. Deze pagina toont een werkende configuratie tegen een OpenAI-compatible endpoint, van het eerste verzoek tot streaming, tools, JSON-modus en rate limits.
Bijgewerkt:

Belangrijkste punten
- Stel elke OpenAI SDK in op https://api.llminferenceapi.com/v1, gebruik de model ID uncensored en verstuur je sleutel als Bearer-token.
- Er zijn twee endpoints beschikbaar: POST /v1/chat/completions en GET /v1/models.
- Streaming, functieaanroepen en JSON-modus werken via de standaard verzoekvelden.
- Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe; een 429-response vertelt je welke limiet je hebt bereikt.
Wat je nodig hebt voor het eerste verzoek
Je hebt drie dingen nodig: een basis-URL, een sleutel en een modelnaam. De basis-URL is https://api.llminferenceapi.com/v1, de model-ID is uncensored, en de sleutel haal je van de API-sleutelpagina na je aanmelding met Google of e-mail en wachtwoord. Nieuwe gebruikers kunnen daar met één klik $0,50 aan proefkrediet claimen. Er is geen kaart nodig, het duurt 7 dagen en is beperkt tot één per persoon.
De service is alleen voor tekst. Het exposeert POST /v1/chat/completions en GET /v1/models. Er is geen embeddings-route, geen afbeeldings- of audiogeneratie en geen fine-tuning. Het draait één open-weight model, beheerd door een onafhankelijke provider en afgestemd op antwoorden zonder inhoudsrefusaten voor wettelijk volwassen gebruik. Het is niet de officiële API van een modelleverancier. Een harde regel geldt: content die minderjarigen seksualiseert is niet toegestaan.
Bewaar de sleutel in een environment variable in plaats van in source code. De voorbeelden hieronder lezen deze uit API_KEY waar de taal dit toelaat.
Je eerste verzoek
Begin met curl, omdat dit precies laat zien wat er via het netwerk gaat.
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
}'
Het antwoord is het gebruikelijke chat completion object: choices[0].message.content bevat de tekst en usage bevat de tokenaantallen. Je kunt ook modellen opvragen met GET /v1/models, wat een snelle manier is om te bevestigen dat de sleutel en URL correct zijn voordat je iets anders debugt.
In Python met de officiële OpenAI SDK verandert alleen de constructor:
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)
En 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);
De completion kan gebruikmaken van wat overblijft van het 100.000-token contextvenster na je prompt, dus max_tokens is optioneel. Stel het toch in als je een harde plafond wilt voor kosten of lengte. Sampling controls zoals temperature, top_p, stop, seed en de frequency en presence penalties worden doorgegeven.
Twee instellingen zijn het waard om vanaf het begin te kennen. seed maakt sampling herhaalbaar genoeg voor testen, wat helpt als je twee versies van een prompt vergelijkt en wilt dat het verschil afkomstig is van de prompt en niet van toeval. stop accepteert één of meer strings die de generatie stoppen zodra het model ze schrijft, een goedkope manier om een antwoord af te snijden bij een delimiter en te voorkomen dat je betaalt voor tokens die je zou weggooien.
Gestreamde antwoorden
Met stream: true antwoordt de server via server-sent events en stuurt de tekst in kleine deltas. Gebruikers zien de eerste woorden snel, wat belangrijk is in chatinterfaces. Gebruiksgegevens komen aan het einde van de stream.
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)
Twee punten zijn makkelijk om over het hoofd te zien. Ten eerste kan het laatste chunk usage en een lege choices lijst bevatten, dus controleer of choices niet leeg is voordat je erop indexeert. Ten tweede houdt een gestreamd verzoek zijn concurrentieslot vast tot de stream eindigt. Als een client een stream opent en deze nooit tot het einde leest, blijft dat slot bezet en kunnen je latere verzoeken een concurrency fout krijgen. Sluit streams altijd of consumeer ze volledig.
Function calling
Tool calling stelt het model in staat je code een functie te laten uitvoeren en het resultaat te gebruiken. Je beschrijft de functies in tools, stuurt de keuze optioneel bij met tool_choice, voer uit wat het model vraagt en stuur de output terug als een bericht met role: "tool".
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)
Parse function.arguments altijd defensief. Het is een JSON-string gegenereerd door een taalmodel, en in zeldzame gevallen kan deze foutief zijn of een veld bevatten dat je niet hebt gedefinieerd. Valideer het voordat je erop handelt, vooral als de functie data wijzigt. Tool calls werken ook met streaming, waarbij de tool_calls als fragments aankomen die je per index moet samenvoegen voordat je ze parset.
Beheer van gespreksgeschiedenis
De API is stateless. Het onthoudt eerdere verzoeken niet, dus een chat met meerdere beurten werkt alleen omdat je code de eerdere beurten elke keer opnieuw verstuurt. Houd een lijst van berichten bij, voeg het nieuwe bericht van de gebruiker toe, roep het endpoint aan en voeg het antwoord van de assistant toe voordat je de volgende beurt begint.
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."))
Omdat elke beurt de geschiedenis opnieuw verstuurt, groeien de input tokens met de lengte van het gesprek. Het contextvenster houdt 100.000 tokens bij, wat voor de meeste gesprekken ruim voldoende is, maar de kosten stijgen al voordat je de limiet bereikt. Een veelgebruikt patroon is het behoud van het systeembericht en de laatste enkele beurten, en het vervangen van oudere beurten door een korte samenvatting die het model zelf schrijft. Lees usage.prompt_tokens na elke call om te zien hoe groot de geschiedenis is geworden.
JSON-modus
Als je machineleesbare output nodig hebt, stel response_format in op {"type": "json_object"} en zeg in de prompt dat je JSON wilt. Het beschrijven van de verwachte sleutels maakt het resultaat veel stabieler.
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"])
JSON-modus zorgt ervoor dat de output als JSON geparsed kan worden, maar het afdwingt je schema niet. Controleer de sleutels in code en houd een noodoplossing aan voor het geval een waarde ontbreekt. Als het antwoord afgesneden wordt omdat het een tokenlimiet bereikt, is de JSON onvolledig, dus stel max_tokens niet te laag in voor gestructureerde output.
Een korte checklist bij fouten
De meeste problemen van de eerste dag komen door een handvol oorzaken, en je kunt ze in volgorde uitsluiten.
- Base URL. Deze moet eindigen op
/v1. De SDK voegt/chat/completionszelf toe, dus een URL met het pad er al in werkt niet. - Key header. De sleutel gaat in
Authorization: Bearergevolgd door de sleutel. Een losse spatie of newline die met de sleutel gekopieerd wordt, is een veelvoorkomende oorzaak van authenticatiefouten. - Model-ID. Gebruik
uncensoredexact. Namen van modellen van andere leveranciers zijn hier niet geldig. - Grootte van het verzoek. De bodylimiet is 8 MB, en prompt plus completion moeten passen in 100.000 tokens.
- Balance. Kijk naar de
X-Balance-USDheader op elke response om te zien of credit het probleem is. - Citeer de request-ID. Als je support contacteert, voeg de
X-Request-Idwaarde van de mislukte response toe, zodat het verzoek gevonden kan worden.
Houd er rekening mee dat een afwijzing niet hetzelfde is als een fout. Omdat het model is afgestemd op het vermijden van contentafwijzingen voor wettelijk volwassen gebruik, zul je er minder zien dan op gefilterde diensten, maar het model kan nog steeds een afwijzing geven of een zwak antwoord op een vaag prompt. Een duidelijker systeembericht lost dat meestal beter op dan een hogere temperatuur.
Limieten, headers en retries
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een trialsleutel staat 2 gelijktijdige verzoeken en 60 per minuut toe. De body van het verzoek kan maximaal 8 MB zijn. Elk antwoord bevat X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency, wat handig is voor logging en voor het tonen van een saldo in een adminschermpje.
Als je een limiet overschrijdt, retourneert de API HTTP 429. De foutcode rate_limited betekent te veel verzoeken per minuut, en concurrency betekent te veel tegelijk. Bij tijdelijke overbelasting krijg je ook 429, met een Retry-After: 5 kop. Een eenvoudige wrapper voor opnieuw proberen dekt alle drie:
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")
Voor een werkerspool beperk je de grootte van de pool tot je limiet voor gelijktijdigheid in plaats van te vertrouwen op herhalingen. Acht workers op een volledige sleutel zullen zelden een concurrency fout zien. Als je onverwachte fouten krijgt, gaat het troubleshooting artikel door de veelvoorkomende oorzaken heen.
Betaling
Facturatie is betaal per gebruik van prepaid tegoed: $0,15 per 1M input tokens en $0,50 per 1M output tokens, geen abonnement. Mislukte of geweigerde verzoeken worden niet in rekening gebracht, en tegoed verloopt nooit. Een verzoek met 1.500 input tokens en 400 output tokens kost 1.500 / 1.000.000 x $0,15 + 400 / 1.000.000 x $0,50 = $0,000225 + $0,0002 = $0,000425.
Opwaarderingen zijn elk geheel bedrag van $20 tot $500, met een 5% bonus vanaf $50, 10% vanaf $100 en 15% vanaf $200. Je kunt betalen met crypto (USDT op TRC20, USDC op Base). Prompts worden niet gebruikt voor training. De prijzenpagina geeft de details en de quickstart herhaalt de installatiestappen in korte vorm.
Meer handleidingen
Vragen en antwoorden
Kan ik de officiële OpenAI-bibliotheek met deze API gebruiken?
Ja. Installeer de OpenAI SDK voor Python of Node, stel de base URL in op https://api.llminferenceapi.com/v1, voer je sleutel in en gebruik de model ID uncensored.
Ondersteunt de API function calling?
Ja. Geef tools door en optioneel tool_choice, en retourneer elk resultaat als een bericht met rol tool. Gestreamde tool_calls worden ook ondersteund.
Wat betekent een 429-fout hier?
Je raakt een limiet. De code rate_limited betekent te veel verzoeken per minuut, concurrency betekent te veel gelijktijdige verzoeken, en een Retry-After: 5-header markeert een tijdelijke overbelasting. Wacht en probeer het opnieuw.
Kan ik het gebruiken voor embeddings of afbeeldingen?
Nee. De API is alleen tekst en biedt chat completions en een modellijst.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de basis-URL aan. Dat is de hele installatie.
API-sleutel aanvragen