NL ▾
API-sleutel aanvragen

Hoe implementeer je een LLM in Python met een gehoste API

Voor de meeste projecten komt het implementeren van een LLM in Python neer op het aanroepen van een gehost model via HTTP, in plaats van het zelf trainen of draaien. Met een OpenAI-compatibele API is dat ongeveer tien regels code, en dezelfde code kan uitgroeien tot streaming, JSON-uitvoer en tool calling.

Bijgewerkt

Een terminal die een straal naar een cloudserver stuurt en data kubussen ontvangt, ter illustratie van een Python-aanroep naar een gehost LLM

Belangrijkste punten

  • Installeer het openai-pakket, stel een base URL en een sleutel in, en gebruik de model-ID uncensored.
  • Streaming, JSON-modus en tool calling worden allemaal ondersteund en gebruiken de standaard SDK-argumenten.
  • Bewaar de chatgeschiedenis in een lijst en houd het 100.000-token contextvenster in de gaten.
  • Verwerk HTTP 429 met een korte retry; mislukte of geweigerde verzoeken worden niet in rekening gebracht.

Gehoste API of je eigen model

Er zijn twee manieren om een taalmodel in een Python-programma te gebruiken. Je kunt de gewichten zelf draaien, wat betekent dat je een GPU, een serving stack, kwantisatiekeuzes en veel wachttijd voor downloads nodig hebt. Of je kunt verzoeken sturen naar een model dat iemand anders al draait. De eerste route is logisch voor onderzoek, strikte gegevensisolatie of zeer hoog, stabiel volume. De tweede past bij bijna alles anders: een script, een bot, een productfunctie, een prototype dat je graag voor de lunch werkend wilt hebben.

Deze handleiding kiest voor de tweede route. De service hier is een gehoste, OpenAI-compatibele tekst-API met één open-weight model, gedraaid door een onafhankelijke provider en afgestemd op antwoorden zonder inhoudelijke weigeringen voor legaal gebruik door volwassenen. Het is geen officiële API van een modelleverancier. Omdat het de OpenAI-verzoekindeling volgt, werkt de standaard openai-package, en ook gewone requests als je geen dependencies wilt.

Stap 1: installeren en eerste aanroep doen

Installeer de SDK en sla je sleutel op in een omgevingsvariabele, zodat deze nooit in je broncode terechtkomt.

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

Maak vervolgens een client aan met de basis-URL van de service. De enige dingen die je verandert ten opzichte van elke andere OpenAI-achtige setup zijn de URL, de sleutel en de modelnaam.

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain list comprehensions in two sentences."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

Dat is een compleet werkend programma. Het endpoint erachter is POST /v1/chat/completions, geauthenticeerd met Authorization: Bearer <key>, en GET /v1/models geeft de model-ID weer. Je kunt een sleutel en een klein proeftegoed krijgen op de sleutelpagina.

Stap 2: het antwoord streamen

Wachten op een volledig antwoord dat enkele seconden duurt voelt traag aan in een terminal of op een webpagina. Stel stream=True in en print tokens zodra ze aankomen via server-verzonden gebeurtenissen.

# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

Gebruikscijfers komen aan het einde van de stream, dus het laatste blok heeft mogelijk geen keuzes. Daarom controleert de loop eerst chunk.choices. Een ding om te onthouden: een gestreamd verzoek houdt zijn gelijktijdigheidsslot vast tot de stream eindigt, dus lees het altijd tot het einde of sluit het.

Stap 3: een gesprek voeren

Het model heeft geen geheugen tussen aanroepen. Een chat is gewoon een groeiende lijst van berichten die je elke keer opnieuw verstuurt. Een kleine class is genoeg:

# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
    def __init__(self, system):
        self.messages = [{"role": "system", "content": system}]

    def say(self, text):
        self.messages.append({"role": "user", "content": text})
        r = client.chat.completions.create(model="uncensored", messages=self.messages)
        answer = r.choices[0].message.content
        self.messages.append({"role": "assistant", "content": answer})
        return answer

bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))

Het contextvenster is 100.000 tokens, gedeeld door de prompt en het antwoord. Dat is ruim, maar een lange chat groeit met elke beurt, en je betaalt voor de hele geschiedenis bij elk verzoek. Als het groot wordt, verwijder dan de oudste beurten of vervang ze door een korte samenvatting die je het model laat schrijven.

Stap 4: gestructureerde uitvoer krijgen

Programma's willen data, geen alinea's. JSON-modus zorgt ervoor dat het antwoord geldige JSON is. Geef in de prompt aan welke sleutels je verwacht.

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
        {"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
    ],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])

Geldige JSON garandeert niet dat je sleutels erbij zitten. Controleer ze in code en probeer het opnieuw als er een ontbreekt.

Stap 5: het model je functies laten aanroepen

Functieaanroepen laten het model je programma vragen een functie uit te voeren en daarna verder te gaan met het resultaat. Je beschrijft het hulpmiddel, controleert of het antwoord een aanroep bevat, voert het uit en stuurt de output terug met de rol tool.

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_word_count",
        "description": "Count the words in a text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = len(args["text"].split())
        messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Valideer altijd de argumenten voordat je ze uitvoert, omdat het model een aanroep kan genereren die je niet verwachtte. Hulpmiddel-aanroepen streamen ook, als tool_calls deltas, als je dat nodig hebt. De documentatie geeft elk veld weer.

Stap 6: limieten en fouten afhandelen

Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe; een proefsleutel staat 2 en 60 toe. Ga daarboven en de API antwoordt met HTTP 429. De foutcode is rate_limited voor te veel verzoeken per minuut en concurrency voor te veel in één keer. Bij tijdelijke overbelasting krijg je ook een 429, met een Retry-After: 5 header. Een kleine retry wrapper dekt alle drie:

# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError

def ask(messages, tries=4):
    for i in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError:
            time.sleep(5 * (i + 1))
    raise RuntimeError("still limited after retries")

Als je taken in threads uitvoert, beperk ze dan tot 8 met een ThreadPoolExecutor(max_workers=8) zodat je zelden de gelijktijdigheidslimiet raakt. Elk antwoord bevat X-Request-Id, wat je moet citeren als je support contacteert, en X-Balance-USD toont je resterende tegoed. De maximale body size is 8 MB.

Instellingen die de uitvoer beïnvloeden

Het grootste deel van de dagelijkse tuning gebeurt in een handvol parameters, allemaal doorgegeven aan het model.

  • temperature regelt willekeur. Gebruik 0,2 of lager voor extractie en classificatie, ongeveer 0,7 voor chat, en 1,0 of meer voor brainstormen en fictie.
  • top_p knipt de onwaarschijnlijke staart van woordkeuzes af. Verander top_p of de temperature, niet beide tegelijk, zodat je kunt zien welke het werk deed.
  • seed maakt herhaalde runs vergelijkbaarder. Het is nuttig in tests waar je het effect van een promptwijziging wilt zien en niet de ruis.
  • stop stopt de generatie bij een door jou gekozen string, wat handig is om een model af te snijden dat blijft commentaar leveren.
  • max_tokens is optioneel. Zonder het kan de completion wat er over is van het 100.000-token contextvenster gebruiken. Stel het in als je een harde cap op lengte en kosten wilt.
  • De frequency en presence penalties ontmoedigen herhaling, wat helpt bij lange creatieve uitvoer die in een lus begint te raken.

Schrijf de settings die je hebt gebruikt op naast elke output die je belangrijk vindt. Maanden later is "waarom antwoordde het anders" bijna altijd een gewijzigde parameter of een gewijzigd system message.

Veel verzoeken tegelijk uitvoeren

Een lus die één verzoek tegelijk verstuurt, verspilt het grootste deel van je limiet. Met een volledige sleutel kun je 8 verzoeken in behandeling hebben, dus een thread pool brengt een lange batch terug naar ongeveer een achtste van de totale doorlooptijd.

from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")

def summarise(text):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarise in one line: " + text}],
        max_tokens=60,
    )
    return r.choices[0].message.content

texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
    for line in pool.map(summarise, texts):
        print(line)

Houd het aantal workers op of onder de 8, of op 2 op een proefsleutel. Als je nog steeds 429-antwoorden ziet met de code concurrency, verlaag het aantal dan met één of twee. De limiet van 300 per minuut is belangrijk voor snelle, korte verzoeken, dus een batch van kleine aanroepen kan deze limiet bereiken voordat de concurrency cap wordt geraakt.

Veelvoorkomende problemen en fixes

De meeste fouten op de eerste dag komen door een korte lijst van oorzaken.

  • 401 of authenticatiefout. De sleutel ontbreekt, is verkeerd getypt of wordt naar de verkeerde host gestuurd. Print de basis-URL die je client daadwerkelijk gebruikt en zorg dat deze eindigt op /v1.
  • Model niet gevonden. De model-ID moet uncensored zijn. Roep GET /v1/models aan als je wilt bevestigen wat de server opsomt.
  • Leeg of afgekapt antwoord. Een lage max_tokens stopt het antwoord midden in een zin. Verhoog het of verwijder het. Controleer finish_reason op de keuze: length betekent dat de limiet werd geraakt.
  • JSON die niet kan worden verwerkt. Of het antwoord was afgekapt, of de prompt beschreef de vorm nooit. Los de prompt eerst op en wikkel parsing in een try-blok.
  • Traag eerste token. Een zeer lange prompt duurt langer om te verwerken. Knip geschiedenis of stuur minder context.
  • Verzoek te groot. De body limit is 8 MB, en het tokenvenster is 100.000. Split grote documenten in stukken en vat elk samen.

Als er nog steeds iets vreemd lijkt, log dan de X-Request-Id header met de mislukte input. Zo kan support het exacte verzoek vinden.

Wat het kost

Je betaalt $0,15 per 1M input tokens en $0,50 per 1M output tokens van prepaid tegoed. Een typische call met 2.000 tokens in en 500 out kost 0,002 x $0,15 = $0,0003 voor input plus 0,0005 x $0,50 = $0,00025 voor output, dus $0,00055 in totaal. Tienduizend van zulke calls kosten $5,50. Mislukte of geweigerde verzoeken worden niet in rekening gebracht en tegoed verloopt nooit. Top-ups lopen van $20 tot $500; zie prijzen voor de bonusniveaus. Prompts worden niet gebruikt voor training.

Output tokens kosten meer dan input tokens, dus de goedkoopste gewoonte is om korte antwoorden te vragen: zeg twee zinnen, of alleen JSON, en stel max_tokens in op een verstandig plafond. Lees resp.usage tijdens de ontwikkeling om echte token counts voor je prompts te zien, en vermenigvuldig met de bovenstaande tarieven voordat je een job opschalt. De X-Balance-USD header toont wat er over is na elke call.

Vragen en antwoorden

Heb ik een GPU nodig om een LLM in Python te implementeren?

Niet met een hosted API. Je Python code stuurt alleen HTTP requests, dus elke laptop werkt.

Kan ik het officiële openai package gebruiken?

Ja. Stel base_url in op de service URL en api_key op je sleutel, en gebruik de model ID uncensored.

Wordt async code ondersteund?

De AsyncOpenAI client van de SDK werkt met dezelfde base URL en sleutel. Houd concurrency op of onder 8 requests.

Hoe kan ik het uitproberen zonder te betalen?

Meld je aan en claim het proeftegoed van $0,50 op de sleutelpagina. Het is 7 dagen geldig en vereist geen kaart.

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