OpenAI API Python: Gebruik de OpenAI SDK met ons model

Voor open ai api python-code heb je geen speciale bibliotheek nodig. Het officiële openai-pakket werkt met deze service zodra je een andere base URL en sleutel instelt, en de model-ID is uncensored. Hieronder vind je een volledige handleiding met voorbeelden die je kunt kopiëren en plakken.
Belangrijkste punten
- Installeer openai en geef vervolgens base_url en api_key door aan de client; er verandert niets anders in je code.
- Streaming, JSON-modus en tool calling werken allemaal via dezelfde SDK-methoden.
- Vang RateLimitError op en probeer het opnieuw; limieten zijn 300 verzoeken per minuut en 8 gelijktijdige op een volledige sleutel.
- De kosten zijn $0,15 per 1M input-tokens en $0,50 per 1M output-tokens, alleen gefactureerd voor succesvolle verzoeken.
Installeer en maak de eerste aanroep
Je hebt Python 3.9 of nieuwer en de officiële SDK nodig. Maak eerst een API-sleutel aan op de sleutelpagina; nieuwe accounts kunnen daar met één klik $0,50 aan proeftegoed claimen, zonder creditcard.
pip install openai
export API_KEY="your-key-here"
Nu het kleinste werkende script. De client neemt de base URL en de sleutel; het verzoek gebruikt de model-ID uncensored.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.aiapisource.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise writing assistant."},
{"role": "user", "content": "Give me three opening lines for a mystery novel."},
],
temperature=0.8,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Dat is de hele integratie. De service implementeert POST /v1/chat/completions en GET /v1/models, wat dekt wat de meeste scripts gebruiken. Het is alleen een tekstmodel, dus endpoints voor afbeeldingen, audio en embeddings zijn niet beschikbaar.
Wat dit is, en wat het niet is
De SDK is gemaakt door OpenAI, maar het endpoint hier is niet van OpenAI. Het is een gehost open-weight model, beheerd door een onafhankelijke aanbieder en afgestemd op antwoorden zonder inhoudelijke weigeringen voor legaal gebruik door volwassenen. Er is geen routing naar GPT of een model van een andere leverancier. Daarom verander je de base URL: je praat met een andere server die hetzelfde verzoekformaat accepteert.
Als je een bestaand project verplaatst, zoek er dan naar OpenAI( en naar hard-coded modelnamen. Dat zijn de enige twee plekken die bewerkt moeten worden. De GPT API production checklist op deze site behandelt gewoontes die van toepassing zijn op elk OpenAI-formaat endpoint, zoals time-outs en retries.
Stream het antwoord
Voor chatinterfaces wil je tokens zodra ze gegenereerd zijn. Stel stream=True in en itereer. Vraag naar het verbruik aan het einde als je factuurgegevens wilt:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about a night train."}],
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)
De guard op chunk.choices is belangrijk: het laatste chunk kan verbruik bevatten en geen keuzes. Houd er rekening mee dat een gestreamd verzoek een van je gelijktijdige slots bezet tot de stream eindigt, dus lees het altijd volledig uit of sluit het.
JSON-modus
Wanneer je code het antwoord moet parseren, schakel je JSON-modus in en beschrijf je de sleutels in de prompt:
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "user", "content": "Return JSON with keys name (string) and traits (list of 3 strings) for a fictional ship captain."}
],
)
character = json.loads(resp.choices[0].message.content)
print(character["name"], character["traits"])
Geldig JSON is het waarschijnlijke resultaat, geen belofte van je exacte schema, dus controleer de sleutels en probeer het opnieuw bij een fout.
Function calling
Beschrijf functies in tools, voer uit wat het model vraagt, en stuur het resultaat terug met role: "tool":
import json
tools = [{
"type": "function",
"function": {
"name": "roll_dice",
"description": "Roll a die with the given number of sides",
"parameters": {
"type": "object",
"properties": {"sides": {"type": "integer"}},
"required": ["sides"],
},
},
}]
messages = [{"role": "user", "content": "Roll a 20-sided die for my character."}]
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 = {"value": 14, "sides": args["sides"]} # replace with real logic
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)
Je kunt tool_choice doorgeven om een functie af te dwingen. De argumenten worden als een JSON-string doorgegeven, dus voer ze altijd door json.loads en valideer ze voordat je ze gebruikt.
Fouten, retries en async
De SDK probeert sommige fouten automatisch opnieuw, en je kunt het aantal instellen met max_retries. Voor rate limits vang je de uitzondering op en wacht je. De API retourneert HTTP 429 met de code rate_limited wanneer je de limiet per minuut overschrijdt, met concurrency wanneer er te veel gelijktijdige verzoeken lopen, en met een Retry-After: 5 header bij tijdelijke overbelasting.
import time
from openai import RateLimitError
def ask(prompt, tries=4):
for attempt in range(tries):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5 * (attempt + 1))
raise RuntimeError("Still rate limited after retries")
Voor batches gebruik je de async client en beperk je de paralleliteit onder je limiet. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe; een proefsleutel staat 2 en 60 toe.
import asyncio, os
from openai import AsyncOpenAI
aclient = AsyncOpenAI(base_url="https://api.aiapisource.com/v1", api_key=os.environ["API_KEY"])
sem = asyncio.Semaphore(6)
async def one(prompt):
async with sem:
r = await aclient.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
async def main():
prompts = [f"Write a tagline for product number {i}." for i in range(20)]
results = await asyncio.gather(*(one(p) for p in prompts))
print(len(results), "done")
asyncio.run(main())
Het gebruik van 6 van de 8 slots laat ruimte over voor ander verkeer op dezelfde sleutel.
Houd een gesprek gaande
De API is stateless. Het onthoudt niets tussen aanroepen, dus een gesprek is gewoon de lijst van berichten die je elke keer verzendt. Voeg het antwoord toe aan de lijst en stuur de hele lijst opnieuw:
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
r = client.chat.completions.create(model="uncensored", messages=history)
reply = r.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a short story."))
print(chat("Make it darker and set it in a harbour town."))
Elke aanroep verzendt meer tokens dan de vorige, en input-tokens worden bij elke aanroep gefactureerd. Als de lijst lang wordt, verwijder dan de oudste beurten of vervang ze door een korte samenvatting. Het contextvenster is 100.000 tokens voor prompt plus completion, wat veel is, maar een lange geschiedenis maakt elk verzoek duurder en langzamer om te starten.
Sampling-instellingen worden doorgegeven: temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen. Stel seed en een lage temperature in als je herhaalbare testruns wilt.
Schat kosten voor een grote run
Facturatie is per token van prepaid tegoed: $0,15 per 1M input-tokens en $0,50 per 1M output-tokens. Mislukte of geweigerde verzoeken worden niet gefactureerd, en tegoed verloopt nooit. Neem een batch van 10.000 verzoeken met elk 1.500 input-tokens en 400 output-tokens. Input is 15.000.000 tokens, wat 15 x $0,15 = $2,25 is. Output is 4.000.000 tokens, wat 4 x $0,50 = $2,00 is. De batch kost $4,25.
De response headers bevatten X-Balance-USD, zodat je je resterende saldo kunt lezen in code via client.chat.completions.with_raw_response.create(...). Opwaarderingen zijn elk geheel bedrag van $20 tot $500, met +5% vanaf $50, +10% vanaf $100 en +15% vanaf $200. De prijspagina geeft betaalopties weer, en de quickstart geeft elke ondersteunde parameter weer, waaronder stop, seed en de straffen.
Meer handleidingen
Vragen en antwoorden
Kan ik het officiële OpenAI Python-pakket gebruiken met deze API?
Ja. Installeer openai, stel base_url in op het service-endpoint en api_key op je sleutel, en roep chat.completions.create aan met het model uncensored.
Heb ik een andere bibliotheek nodig voor streaming of tools?
Nee. Streaming, JSON-modus en tool calling werken via dezelfde SDK-methoden, met de gebruikelijke parameters.
Is dit het model van OpenAI?
Nee. Het is een open-weight model dat wordt beheerd door een onafhankelijke aanbieder. Het verzoekformaat is hetzelfde, vandaar dat de SDK werkt.
Worden mijn prompts gebruikt om het model te trainen?
Nee. Prompts die via de API worden verzonden, worden niet gebruikt voor training.
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.