LLM API-werkstroom in Python: Stap-voor-stap configuratie
Wijs de OpenAI SDK naar een nieuwe base URL, gebruik de model ID uncensored, en voeg retries, gelijktijdige runs en tool calls laag voor laag toe.
Bijgewerkt

Belangrijkste punten
- Installeer openai, stel base_url in op https://api.veo3apis.com/v1 en gebruik het model uncensored.
- Afhandelen van 429 door te wachten op Retry-After; mislukte verzoeken worden niet in rekening gebracht.
- Stel de thread pool in op basis van het type sleutel: 8 workers voor een volledige sleutel, 2 voor de proefsleutel.
- Lees X-Balance-USD uit de response headers om de uitgaven per run bij te houden.
De korte versie
Om een python-script voor een LLM API-werkstroom te bouwen, installeer je de officiële OpenAI SDK, stel je de base URL in op https://api.veo3apis.com/v1, gebruik je sleutel als de API-sleutel en roep je het model uncensored aan. Niets anders verandert. De service is OpenAI-compatible, dus elk patroon dat je al kent van de SDK werkt: gewone chatverzoeken, streaming, JSON-modus en het aanroepen van tools.
Dit artikel bouwt een kleine werkstroom laag voor laag op. Je begint met een enkel verzoek, voegt vervolgens configuratie toe via omgevingsvariabelen, een retry-wrapper, een parallel runner, een toolverzoek en balansbijhouding. Elke laag is kort en je kunt stoppen bij elke laag die aan je behoeften voldoet.
Het model is een open-weight model dat wordt gerund door een onafhankelijke provider. Het is niet de officiële API van een grote leverancier en het is geen router, dus er is slechts één model ID om te onthouden. Het verwerkt alleen tekst. Er is geen afbeeldingen-, audio- of video-generatie, geen embeddings en geen fine-tuning.
Installeer de SDK en maak de eerste aanroep
Je hebt Python 3.9 of nieuwer nodig. Installeer de SDK:
pip install openai
Maak een sleutel aan op de API-sleutelpagina na het inloggen met Google of met een e-mailadres en wachtwoord. De pagina biedt ook een claimen met één klik-optie voor $0,50 aan proeftegoed, geldig voor 7 dagen, één per persoon, geen creditcard vereist. Voer vervolgens de kleinst mogelijke call uit:
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses for a hosted text API."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Als dit tekst en een usage-object afdrukt, zijn authenticatie, routing en de model-ID's allemaal correct. De SDK stuurt je sleutel als Authorization: Bearer, en het verzoek gaat naar POST /v1/chat/completions. Je kunt controleren welke model-ID's je sleutel ziet met client.models.list(), wat GET /v1/models aanroept.
Een ruwe curl-versie is handig als je debugt vanaf een server zonder Python:
curl https://api.veo3apis.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'
Bewaar configuratie in één client
Hardcoderen van een sleutel in een script is de snelste manier om het te lekken in een repository. Lees beide waarden uit de environment en maak de client op één plek aan, zodat elke stap van de werkstroom deze deelt.
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
api_key=os.environ["LLM_API_KEY"],
max_retries=0,
timeout=120,
)
MODEL = "uncensored"
def ask(system: str, user: str, **kwargs) -> str:
resp = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
**kwargs,
)
return resp.choices[0].message.content
Twee keuzes hier zijn bewust. max_retries=0 schakelt de ingebouwde retries van de SDK uit, zodat de retry-logica in de volgende sectie de enige is, wat het gedrag makkelijker te redeneren maakt. De timeout van 120 seconden laat ruimte voor lange completions; het contextvenster is 100.000 tokens voor prompt plus completion, en een groot antwoord kost tijd om te streamen. Sampling parameters zoals temperature, top_p, stop, seed en de penalties passeren **kwargs zoals gebruikelijk.
Herhaal de juiste fouten
Elke echte workflow raakt vroeg of laat rate limits. Een volledige sleutel staat 300 verzoeken per minuut en 8 tegelijk toe. Een proefsleutel staat 60 per minuut en 2 tegelijk toe. Overschrijd je een van beide, dan retourneert de API HTTP 429. De error code vertelt je welke limiet je hebt geraakt: rate_limited voor verzoeken per minuut, concurrency voor te veel tegelijk. Tijdens tijdelijke overbelasting stuurt de API ook 429 met een Retry-After: 5 header.
Alle drie de gevallen hebben dezelfde remedie: wachten, dan opnieuw proberen. Deze wrapper respecteert de header en backt off als deze afwezig is.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError
def call_with_retry(messages, tries=5, **kwargs):
delay = 2
for attempt in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, **kwargs
)
except RateLimitError as err:
wait = err.response.headers.get("Retry-After")
time.sleep(int(wait) if wait else delay)
delay = min(delay * 2, 30)
except APIConnectionError:
time.sleep(delay)
delay = min(delay * 2, 30)
except APIStatusError as err:
if err.status_code < 500:
raise
time.sleep(delay)
delay = min(delay * 2, 30)
raise RuntimeError("request failed after retries")
Herhaal alleen fouten die kunnen veranderen. Een 400 betekent dat je verzoek slecht gevormd is, en het opnieuw sturen zal op dezelfde manier falen, dus de wrapper re-raises elke client error behalve 429. Mislukte of geweigerde verzoeken worden niet in rekening gebracht, dus opnieuw proberen kost niets extra.
Voer veel inputs parallel uit
Voor een loop over veel inputs is een thread pool genoeg. De SDK client is veilig om te delen over threads. Pas de grootte van de pool aan op basis van je sleutel: 8 workers voor een volledige sleutel, 2 voor de proefsleutel.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError
def summarize(text: str) -> str:
for _ in range(5):
try:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Summarize the text in two sentences."},
{"role": "user", "content": text},
],
max_tokens=150,
)
return resp.choices[0].message.content.strip()
except RateLimitError as err:
time.sleep(int(err.response.headers.get("Retry-After", "5")))
return ""
documents = ["First long text...", "Second long text...", "Third long text..."]
with ThreadPoolExecutor(max_workers=8) as pool:
summaries = list(pool.map(summarize, documents))
for s in summaries:
print(s)
Pool size is niet hetzelfde als request rate. Acht workers die elk een call in een halve seconde afhandelen, zouden 960 verzoeken per minuut maken, ver boven de 300. Als je calls snel zijn, voeg dan een kleine sleep of een token-bucket limiter toe zodat je onder de per-minute cap blijft. Als je calls langzaam zijn, is concurrency de limiet die je eerst zult tegenkomen. Gestreamde requests houden hun slot vast tot de stream klaar is.
Gestructureerde output en tool calls
Twee functies veranderen een chat call in een workflow stap waar andere code op kan vertrouwen. JSON-modus garandeert parseerbare output. Tool calling laat het model je code vragen om iets te doen en gebruik dan het antwoord.
JSON-modus
Stel response_format in op een JSON object en beschrijf de keys in de prompt.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "A short post about nightly backups."},
],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])
Function calling
Declareer tools met tools, forceer optioneel een keuze met tool_choice, voer de functie zelf uit en stuur het resultaat terug als een message met role: "tool".
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
tools = [{
"type": "function",
"function": {
"name": "word_count",
"description": "Count the words in a piece of text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
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 = {"words": len(args["text"].split())}
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)
else:
print(msg.content)
Controleer altijd dat tool_calls aanwezig is voordat je het uitleest. Het model kan direct antwoorden, en je code moet beide uitkomsten afhandelen.
Koppel stappen aan een pipeline
Echte workflows stoppen zelden bij één call. Een veelvoorkomende vorm is draft, review, rewrite: de eerste call produceert iets, de tweede bekritiseert het tegen een checklist, en de derde past de kritiek toe. Elke stap is een apart verzoek met zijn eigen system message, wat de instructies kort houdt en de fouten makkelijk lokaliseert.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
def step(system: str, user: str, temperature: float = 0.7) -> str:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
temperature=temperature,
max_tokens=800,
)
return resp.choices[0].message.content.strip()
topic = "a changelog entry for a new export feature"
draft = step("Write the requested text in under 120 words.", topic)
review = step(
"List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
draft,
temperature=0.2,
)
final = step(
"Rewrite the text so it fixes every listed problem. Reply with the text only.",
"TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)
Merk de lagere temperature op in de review stap. Critiek moet consistent zijn van run tot run, terwijl drafting baat heeft bij enige variatie. Als je de pipeline over veel inputs draait, plaats dan de hele drie-stappen functie in de thread-pool worker uit de vorige sectie, zodat elke worker één item van begin tot eind beheert en de 8-verzoeken limiet wordt gerespecteerd.
Bewaar tussentijdse resultaten. Als de finale tekst fout is, vertellen de draft en de review je welke stap faalde, en kun je één system message fixen in plaats van de hele pipeline herschrijven. Elke stap naar een JSON-lines bestand schrijven met de input, de drie outputs en de request IDs maakt dit makkelijk, en het geeft je een resume punt als het proces halverwege stopt.
Houd balans en request IDs bij
Elke response bevat headers die het loggen waard zijn: X-Request-Id identificeert de call als je contact opneemt met support, X-Balance-USD toont wat er nog van je credit over is, en de twee X-RateLimit-Limit headers rapporteren de request en concurrency limieten voor je sleutel. De SDK verbergt headers standaard; gebruik de raw-response wrapper om ze te lezen.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Reply with the single word ready."}],
max_tokens=10,
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))
resp = raw.parse()
print(resp.choices[0].message.content)
Prijzen zijn $0,15 per miljoen input tokens en $0,50 per miljoen output tokens, dus een call met 1.000 input en 500 output tokens kost $0,00015 + $0,00025 = $0,0004. Een workflow die 5.000 van dergelijke calls uitvoert, geeft $2,00 uit. Print de balans aan het begin en einde van een run, en je weet wat elke batch kost zonder extra tooling. Voor tarieven en top-up bonuses, zie de pricing pagina; voor elke ondersteunde parameter, lees de API documentatie.
Nog een gewoonte die het waard is om aan te nemen: houd prompts buiten je logs tenzij je ze nodig hebt. Prompts die naar deze API worden gestuurd, worden niet gebruikt voor training, maar je eigen logbestanden zijn jouw verantwoordelijkheid.
Problemen oplossen bij een nieuwe setup
De meeste problemen bij de eerste run komen door een korte lijst van oorzaken.
- De call hangt of faalt bij connect. Controleer de base URL. Deze moet eindigen op
/v1, en de SDK voegt/chat/completionszelf toe. Een dubbel pad is de gebruikelijke fout. - Een authenticatie fout. De key ontbreekt, is afgekapt of heeft een losse spatie of newline van een copy and paste. Print de lengte, niet de key zelf, en vergelijk het met wat de key pagina toont.
- Model niet gevonden. De model ID is
uncensored, in lower case. Roep het models endpoint aan om precies te zien wat je key kan gebruiken. - Constante 429 op een klein script. Je zit misschien op de trial key, die 2 gelijktijdige requests en 60 per minuut toestaat. Verlaag de pool naar 2 workers, of top up om een volledige sleutel te krijgen.
- Afgekapt antwoord. Een lage
max_tokensstopt het antwoord vroeg. Verhoog het, of verwijder het en laat de completion de rest van het venster gebruiken. - Verzoek te groot. De body limiet is 8 MB, en het token venster is 100.000 tokens voor prompt en completion samen. Split grote inputs in stukken en verwerk ze als aparte calls.
Als er iets op de service kant fout lijkt, stuur dan de waarde van X-Request-Id naar het contact op de site. Een request ID laat de operator je exacte call vinden, wat veel nuttiger is dan een beschrijving van wat je zag.
Meer handleidingen
Vragen en antwoorden
Heb ik een speciale SDK nodig?
Nee. De officiële OpenAI Python SDK werkt zodra je de base URL en je sleutel instelt.
Welke model-ID gebruik ik?
Gebruik uncensored. Je kunt beschikbare IDs opvragen met GET /v1/models.
Hoeveel verzoeken kunnen er gelijktijdig lopen?
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. Een proefsleutel staat 2 en 60 toe.
Werkt streaming in de Python SDK?
Ja. Geef stream=True door en itereer over de chunks. Gebruik wordt aan het einde van de stream gerapporteerd.
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.