NL ▾
API-sleutel aanvragen

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.

Bijgewerkt

Terminal verbonden met een kubus van chatbellen met data die ertussen stroomt, wat een LLM API-aanroep voorstelt
01

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_KEY header, 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_tokens te 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, seed en 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.

SymptoomWaarschijnlijke oorzaakOplossing
401 responseOntbrekende of verkeerde sleutelControleer de Bearer-header en de sleutel op de sleutelpagina
429, code rate_limitedMeer dan 300 verzoeken per minuut (60 op een proefsleutel)Vertraag of wachtrij verzoeken
429, code concurrencyMeer dan 8 gelijktijdige verzoeken (2 op een proefsleutel)Beperk het aantal parallelle workers, sluit open streams
429 met Retry-After: 5Tijdelijke overbelastingWacht 5 seconden en probeer opnieuw
Verzoek te grootBody groter dan 8 MBStuur 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.

02

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.

API-sleutel aanvragen