NL ▾
API-sleutel aanvragen

LLM API in Python: chatten, streaming en toolaanroepen

Deze python-handleiding voor llm-api's gebruikt de officiële OpenAI SDK die wijst naar een OpenAI-compatibel endpoint. Je krijgt een eerste aanroep, streaming, een toolaanroep en retry-logica in code die je kunt plakken en uitvoeren.

Bijgewerkt

Lint van codeblokken dat van een laptop naar chatbellen stroomt, ter illustratie van een Python LLM API-aanroep
01

Belangrijkste punten

  • Installeer openai, stel de Basis-URL en sleutel in en gebruik de model ID uncensored.
  • Stream met stream=True en sluit de stream vroeg om de concurrency-slot vrij te maken.
  • Toolaanroepen retourneren argumenten die je moet parseren en valideren voordat je iets uitvoert.
  • Verwerk 429 met Retry-After en beperk parallelle verzoeken tot 8 bij een volledige sleutel.

Installeer de SDK en maak de eerste aanroep

Als je een LLM API Python-setup wilt die in vijf minuten werkt, is de OpenAI SDK alles wat je nodig hebt. De API is OpenAI-compatible, dus je houdt de officiële client aan en wijzigt twee waarden: de base URL en de sleutel. De model ID is uncensored.

Haal eerst een sleutel. Meld je aan op de API-sleutelpagina, claim het een-klik proeftegoed en kopieer de sleutel. Installeer vervolgens de client en houd de sleutel buiten je broncode.

pip install openai
export LLM_API_KEY="your-key-here"

Nu het kleinste bruikbare programma:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llmmodelsapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

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

Dat is de hele integratie. resp.usage geeft het aantal tokens voor de prompt en de voltooiing, die je kunt vermenigvuldigen met de tarieven op de prijzenpagina ($0,15 per 1M input-tokens, $0,50 per 1M output-tokens) om te zien wat elke aanroep kost. Dit endpoint accepteert ook POST /v1/responses als je code dit formaat al gebruikt, en GET /v1/models geeft de model-ID weer.

Hoe het verzoek en antwoord eruitzien

De OpenAI client verbergt de HTTP-gegevens, maar het is handig om ze te kennen als er iets misgaat. De SDK stuurt een POST naar /v1/chat/completions met een bearer token. Je kunt de aanroep reproduceren met curl en vergelijken.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Handige parameters die naar het model worden doorgegeven: temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen. max_tokens is optioneel. Als je het weglaat, kan de voltooiing alle resterende tokens van het 100.000-tokenvenster gebruiken (prompt en voltooiing samen).

Twee responseheaders zijn het loggen waard bij elke aanroep: X-Request-Id voor supportvragen, en X-Balance-USD voor je resterende tegoed. Met de Python SDK kun je ze bereiken via de raw response:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Streaming tokens terwijl ze binnenkomen

Voor chatinterfaces en alles waar iemand op wacht, stream je het antwoord. Stel stream=True in en itereer over de chunks. De API stuurt ze via serververzonden gebeurtenissen, en de laatste chunk bevat verbruik als je daarom vraagt.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    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)

Twee details zorgen vaak voor problemen. Ten eerste hebben sommige chunks een lege choices lijst (de verbruik-chunk bijvoorbeeld), dus voeg een guard toe voordat je indexeert. Ten tweede houdt een gestreamd verzoek zijn concurrentieslot vast tot de stream eindigt. Als je een stream opent en verlaat zonder deze te sluiten, blijft dat slot bezet en kunnen latere aanroepen falen met een concurrency fout. Gebruik de stream in een with blok of roep stream.close() aan als je vroegtijdig stopt met lezen.

Als een stream afbreekt met een onduidelijke boodschap, behandelt het artikel op hoe je een LLM-model gebruikt op deze site de basisprincipes van het lezen van fouten en het opnieuw proberen.

Een toolaanroep naar het model

Tool calling stelt het model in staat je code te vragen een functie uit te voeren en vervolgens door te gaan met het resultaat. Het proces heeft drie stappen: stuur de tool definities, voer uit wat het model vraagt, en stuur de output terug met role: "tool".

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

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-1042?"}]
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)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Parse call.function.arguments altijd als JSON binnen een try-blok in echte code, omdat modellen af en toe argumenten produceren die niet overeenkomen met je schema. Valideer voordat je iets met neveneffecten uitvoert. Voor langere agent-lussen, zie de gids voor het gebruik van deze API voor agents.

Toolaanroepen streamen ook: de argumenten komen in stukken binnen delta.tool_calls, en je plakt ze samen op basis van index tot de stream klaar is.

JSON-modus voor gestructureerde output

Als je machine-leesbare output nodig hebt in plaats van tekst, stel je dan response_format in op een JSON-object. Beschrijf de gewenste structuur in de prompt, omdat JSON-modus geldige JSON-syntax garandeert, maar niet jouw specifieke schema.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Gebruik temperature=0 voor extractie en classificatie zodat herhaalde runs dezelfde labels opleveren. Voeg seed toe als je de sampling verder wilt preciseren, en valideer het geparseerde resultaat nog steeds tegen je eigen schema.

Limieten, herhaalde pogingen en foutafhandeling

Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 gelijktijdige en 60 per minuut toe. Overschrijding van een van beide geeft HTTP 429. De foutcode vertelt je welke limiet je hebt geraakt: rate_limited voor verzoeken per minuut en concurrency voor te veel tegelijk. Bij tijdelijke overbelasting krijg je ook een 429 met een Retry-After: 5 header.

De OpenAI SDK probeert sommige fouten al automatisch opnieuw, maar je moet het beleid zelf instellen:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Als je werk verdeelt met threads of asyncio, beperk dan de pool tot 8 (of 2 bij een proefsleutel) met een semaphore. Zo blijf je onder de concurrency limiet zonder te vertrouwen op herhaalde pogingen. Mislukte of geweigerde verzoeken worden niet in rekening gebracht, dus opnieuw proberen kost niets extra voor de mislukte pogingen.

Controleer je saldo vanuit code met GET /v1/balance, of lees X-Balance-USD uit elke response. De volledige parameterlijst staat in de API-documentatie.

Wat het kost om deze voorbeelden uit te voeren

De bovenstaande voorbeelden zijn klein. Een aanroep met 300 prompttokens en 200 completiontokens kost 300 x $0,15 / 1M plus 200 x $0,50 / 1M, wat $0,000045 plus $0,0001 is, oftewel $0,000145. Ruwweg passen er 6.900 van dit soort aanroepen in één dollar. Het $0,50 trial credit dekt ongeveer 3.400 van hen, en het is 7 dagen geldig zonder betalingsgegevens.

Na de trial kun je elk geheel bedrag van $20 tot $500 opwaarderen, met een bonus van 5% vanaf $50, 10% vanaf $100 en 15% vanaf $200. Credit verloopt niet en er is geen abonnement. Prompts worden niet gebruikt voor training.

02

Vragen en antwoorden

Kan ik de officiële OpenAI Python-bibliotheek gebruiken?

Ja. Stel base_url in op het API-adres en api_key op je sleutel, en roep chat.completions.create aan met model uncensored.

Ondersteunt de API async Python?

Ja, gebruik AsyncOpenAI met dezelfde base URL en sleutel. Houd het aantal gelijktijdige taken op of onder de 8 bij een volledige sleutel, of 2 bij een proefsleutel.

Hoe zie ik hoeveel tokens een call heeft gebruikt?

Lees resp.usage bij een normale aanroep, of gebruik stream_options met include_usage bij een gestreamde aanroep. Vermenigvuldig met $0,15 per 1M inputtokens en $0,50 per 1M outputtokens.

Hoe lang mag mijn prompt zijn?

Het contextvenster is 100.000 tokens, prompt en completion samen. De request body is beperkt tot 8 MB.

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