Hoe een LLM-model via een API te gebruiken, stap voor stap
Een gehost taalmodel gebruiken komt neer op één HTTP-verzoek met een sleutel, een modelnaam en een lijst met berichten. Deze handleiding neemt je mee van een lege map naar streaming, JSON-uitvoer en toolaanroepen.

Belangrijkste punten
- De API is OpenAI-compatible: wijzig de basis-URL en de sleutel, behoud je SDK.
- Gebruik de model-ID uncensored met POST /v1/chat/completions.
- Streaming, JSON-modus en toolaanroepen werken allemaal met de standaardparameters.
- Een 429 betekent dat een limiet is bereikt, en de error code vertelt je welke.
Wat je nodig hebt voor het eerste verzoek
Als je wilt weten hoe je LLM-modelendpoints in je eigen code kunt gebruiken, zijn drie dingen genoeg: een sleutel, een base URL en een modelnaam. Er is geen speciale client te installeren. Elke OpenAI SDK of client werkt zodra je hem op een ander adres wijst.
- Basis-URL:
https://api.llmmodelsapi.com/v1 - Model ID:
uncensored - Auth: een
Authorization: Bearer YOUR_KEYheader, die de SDKs voor je toevoegen
Om een sleutel te krijgen, registreer je je met Google of met e-mail en wachtwoord, en open je vervolgens de API-sleutelpagina. Nieuwe accounts kunnen daar met één klik $0,50 aan proeftegoed claimen, zonder creditcard, geldig voor 7 dagen. Dat is genoeg voor alles in dit artikel. De endpoint ondersteunt twee methoden: POST /v1/chat/completions voor generatie en GET /v1/models om te zien wat er beschikbaar is.
Het helpt om te weten welk model het is, zodat je verwachtingen kloppen. Het is één open-weight model dat wordt beheerd door een onafhankelijke provider en getuned om te antwoorden zonder inhoudsweigeringen voor wettelijk volwassen gebruik. Het is niet de officiële API van een grote leverancier, en het verwerkt alleen tekst. Er is geen afbeelding- of audiogeneratie, geen embeddings en geen fine-tuning.
Stap 1: controleer de sleutel met curl
Voordat je applicatiecode schrijft, bevestig je dat de sleutel en het netwerkpad werken. Het opsommen van modellen is de goedkoopste check, omdat het niets genereert.
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"
Je zou een JSON-lijst moeten krijgen die uncensored bevat. Als je een 401 ziet, is de sleutel verkeerd of mist het woord Bearer. Stuur nu een echt chatverzoek.
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
}'
Het antwoord bevat een choices-array, en de tekst staat bij choices[0].message.content. De antwoordheaders bevatten X-Request-Id en X-Balance-USD, zodat je bij elk verzoek je resterende tegoed kunt zien. Het veld usage toont de tokens die voor de facturatie zijn geteld.
Stap 2: aanroepen vanuit Python of Node
In de praktijk gebruik je een SDK. Installeer het officiële OpenAI-pakket en stel de base URL in wanneer je de client maakt. Niets anders aan je code verandert.
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);
Houd de sleutel in een omgevingsvariabele in plaats van in het bronbestand. Als een sleutel lekt, vervang hem dan op de sleutelpagina en de oude werkt niet meer.
Stap 3: vorm de uitvoer met parameters
Het model is een tekstvoorspeller, dus hoe je het verzoek formuleert, is net zo belangrijk als de parameters. Een paar gewoontes betalen zich direct uit.
- Gebruik het systeembericht voor vaste regels. Zet hier toon, opmaak en rol, en bewaar de gebruikersprompt voor de daadwerkelijke taak.
- Wees specifiek over lengte. Vraag om "drie bullet points" of "minder dan 120 woorden". Het is betrouwbaarder dan alleen
max_tokenste verlagen, wat tekst midden in een zin afkapt. - Stel temperature af op de taak. Rond 0,2 is geschikt voor extractie en classificatie. Rond 0,8 tot 1,0 is geschikt voor fictie en roleplay.
- Geef alleen wat je nodig hebt.
top_p,stop,seeden de frequentie- en aanwezigheidsstraffen worden doorgegeven aan het model.
Het contextvenster is 100.000 tokens, tellend de prompt en de generatie samen. Je hoeft max_tokens niet in te stellen, omdat het antwoord elke resterende ruimte kan gebruiken. Het toch instellen is een goede manier om een plafond aan de kosten te stellen.
Een praktische manier om deze instellingen te leren, is hetzelfde prompt drie keer uit te voeren bij verschillende temperaturen en te vergelijken. Verander één waarde per run en houd de rest vast, gebruik dezelfde seed waar je kunt. Na tien minuten hiermee weet je veel beter hoe het model zich gedraagt voor je taak dan welke beschrijving ook, en de kosten van het experiment zijn een fractie van een cent.
Prijzen zijn $0,15 per miljoen input tokens en $0,50 per miljoen output tokens. Een verzoek met 1.500 input tokens en 400 output tokens kost 1.500 x 0,15 / 1.000.000 = $0,000225 plus 400 x 0,50 / 1.000.000 = $0,0002, dus in totaal $0,000425. De pricing page heeft de top-up opties.
Stap 4: stream de response
Wachten op een volledig antwoord voelt traag aan in een interactieve app. Met stream: true stuurt de server tokens als server-sent events, en je UI kan ze afdrukken zodra ze aankomen. Gebruik wordt aan het einde van de stream gerapporteerd.
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)
Een ding om te onthouden over concurrency: een gestreamd verzoek bezet zijn slot tot de stream klaar is. Een volledige sleutel staat 8 gelijktijdige verzoeken toe, een trial key staat er 2 toe. Als je een stream in de browser opent en deze nooit sluit, blijft dat slot bezet.
Stap 5: JSON-modus en toolaanroepen
Wanneer een ander programma het antwoord moet lezen, wordt vrije tekst een probleem. JSON-modus vraagt het model om een geldig JSON-object terug te sturen.
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"])
Beschrijf ook de vorm die je wilt in de prompt, omdat JSON-modus geldige syntax garandeert en niet je exacte veldnamen. Wikkel de parse in een try block en probeer het opnieuw als het mislukt.
Tool calling laat het model je code een functie laten uitvoeren. Je beschrijft de tools, het model antwoordt met een tool_calls entry, je voert het uit en stuurt het resultaat terug als een bericht met role: "tool".
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 productie controleer je of tool_calls aanwezig is voordat je erop indexeert, omdat het model ook direct kan antwoorden in plaats van de functie aan te roepen. De tool_choice parameter laat je een call forceren of verbieden als je dat nodig hebt.
Een gesprek gaande houden
De API heeft geen geheugen tussen calls. Als je wilt dat het model zich herinnert wat twee beurten geleden werd gezegd, stuur je die beurten opnieuw. Een chat-app is dus een lijst die groeit: je voegt het user message toe, roept de API aan, voegt de assistant reply toe en herhaalt dit.
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."))
Omdat elke aanroep de hele lijst meeneemt, stijgen de kosten en de latentie met het gesprek. Als de geschiedenis lang wordt, verwijder dan de oudste wisselingen of vervang ze door een samenvatting van één alinea. Je hebt veel ruimte, want 100.000 tokens is ongeveer de lengte van een kort boek, maar er is geen reden om tokens te betalen die niet langer bijdragen aan het antwoord.
Om dezelfde reden houd je het system message kort en stabiel. Het wordt bij elke call gestuurd, dus een 1.000 token system prompt over 500 requests is 500.000 input tokens, wat alleen al 500.000 x 0,15 / 1.000.000 = $0,075 kost.
Fouten die beginners maken
- Vergeten het assistant-antwoord toe te voegen. Het model ziet dan alleen je vragen en verliest de draad.
- Geheimen in de front-end plaatsen. Een sleutel in browsercode is voor iedereen zichtbaar. Roep de API aan vanuit je server en exposeer je eigen endpoint in plaats daarvan.
- Feiten verwachten van een tekstvoorspeller. Het model kan met zelfvertrouwen onjuiste details noemen. Geef de bron tekst in de prompt als nauwkeurigheid belangrijk is, en controleer belangrijke output.
- Vrije tekst parseren. Als code het antwoord moet lezen, gebruik dan JSON-modus of een tool call in plaats van reguliere expressies.
Fouten, limieten en waar je verder kunt kijken
De meeste problemen vallen onder een korte lijst.
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| 401 response | Ontbrekende of verkeerde sleutel | Controleer de Bearer-header en de sleutel op de sleutelpagina |
429, code rate_limited | Meer dan 300 verzoeken per minuut (60 op een proefsleutel) | Vertraag of wachtrij verzoeken |
429, code concurrency | Meer dan 8 gelijktijdige verzoeken (2 op een proefsleutel) | Beperk het aantal parallelle workers, sluit open streams |
429 met Retry-After: 5 | Tijdelijke overbelasting | Wacht 5 seconden en probeer opnieuw |
| Verzoek te groot | Body groter dan 8 MB | Stuur minder tekst per aanroep |
Een eenvoudige herhaling met een korte vertraging behandelt de 429-gevallen. Mislukte verzoeken worden niet in rekening gebracht, dus opnieuw proberen kost niets extra. Prompts worden niet gebruikt voor training.
Vanaf hier geeft de API-documentatie elk parameter weer, en de token-gebaseerde prijsopzet behandelt voor wie de dienst is. Overal geldt één regel: seksuele inhoud met minderjarigen is nooit toegestaan.
Meer handleidingen
Vragen en antwoorden
Welke model-ID stuur ik in het verzoek?
Gebruik uncensored als modelwaarde in elk verzoek. Je kunt dit bevestigen door GET /v1/models aan te roepen.
Heb ik een speciale SDK nodig?
Nee. Elke OpenAI SDK of client werkt zodra je de base URL wijzigt naar https://api.llmmodelsapi.com/v1 en je eigen sleutel gebruikt.
Kan ik het gebruiken zonder creditcard?
Ja, voor testen. Nieuwe gebruikers kunnen $0,50 aan trial tegoed claimen met één klik na het aanmaken van een account, zonder kaart, geldig voor 7 dagen.
Hoe groot kan mijn prompt zijn?
Het contextvenster is 100.000 tokens voor prompt en completion samen, en de request body kan maximaal 8 MB zijn.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.