DE ▾

OpenAI-API Python: Verwende das OpenAI-SDK mit unserem Modell

Stilisierter, schlangenförmiger Kabelanschluss an einem Server mit Chat-Bubbles, der darstellt, wie Python eine API aufruft

Für OpenAI-API-Python-Code benötigst du keine spezielle Bibliothek. Das offizielle openai-Paket funktioniert mit diesem Dienst, sobald du eine andere Base URL und einen Schlüssel festlegst und die Modell-ID uncensored ist. Nachfolgend findest du eine vollständige Anleitung mit Copy-Paste-Beispielen.

Aktualisiert

Wichtige Punkte

  • Installiere openai und übergebe base_url sowie api_key an den Client; im Code ändert sich nichts weiter.
  • Streaming, JSON-Modus und Function Calling funktionieren alle über dieselben SDK-Methoden.
  • Fange RateLimitError ab und wiederhole die Anfrage; die Limits liegen bei 300 Anfragen pro Minute und 8 parallelen Anfragen bei einem vollständigen Schlüssel.
  • Die Kosten betragen $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, abgerechnet nur für erfolgreiche Anfragen.

Installation und erster Aufruf

Du benötigst Python 3.9 oder neuer und das offizielle SDK. Erstelle zuerst einen API-Schlüssel auf der Schlüssel-Seite; neue Konten können dort mit einem Klick $0,50 an Testguthaben beanspruchen, ohne Karte.

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

Hier ist das kleinste funktionierende Skript. Der Client benötigt die Base URL und den Schlüssel; die Anfrage verwendet die Modell-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)

Das ist die gesamte Integration. Der Dienst implementiert POST /v1/chat/completions und GET /v1/models, was den meisten Skripten genügt. Es ist ein reines Textmodell, daher sind Endpunkte für Bilder, Audio und Embeddings nicht verfügbar.

Was das ist und was nicht

Das SDK stammt von OpenAI, aber der Endpunkt hier ist nicht der von OpenAI. Es ist ein gehostetes Open-Weight-Modell eines unabhängigen Anbieters, das darauf abgestimmt ist, bei gesetzeskonformer Erwachsennutzung ohne Inhaltsfilter zu antworten. Es gibt kein Routing zu GPT oder Modellen anderer Anbieter. Deshalb änderst du die Base URL: Du sprichst einen anderen Server an, der dasselbe Anfrageformat akzeptiert.

Wenn du ein bestehendes Projekt portierst, suche es nach OpenAI( und nach fest codierten Modellnamen. Das sind die einzigen beiden Stellen, die du bearbeiten musst. Die GPT API Production Checklist auf dieser Seite behandelt Gewohnheiten, die für jeden OpenAI-kompatiblen Endpunkt gelten, wie Timeouts und Wiederholungen.

Antwort streamen

Für Chat-Oberflächen möchtest du Token, sobald sie erzeugt werden. Setze stream=True und iteriere. Frag am Ende nach der Nutzung, wenn du Abrechnungsdaten möchtest:

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)

Die Prüfung bei chunk.choices ist wichtig: Der letzte Chunk kann Nutzungsinformationen enthalten, aber keine Choices. Eine gestreamte Anfrage belegt zudem einen deiner parallelen Slots, bis der Stream endet. Lies ihn also immer bis zum Ende aus oder schließe ihn.

JSON-Modus

Wenn dein Code die Antwort parsen muss, aktiviere den JSON-Modus und beschreibe die Schlüssel im 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"])

Gültiges JSON ist wahrscheinlich, aber keine Garantie für dein exaktes Schema. Prüfe also die Schlüssel und wiederhole bei einem Fehler einmal.

Function Calling

Beschreibe Funktionen in tools, führe aus, was das Modell anfordert, und sende das Ergebnis mit role: "tool" zurück:

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)

Du kannst tool_choice übergeben, um eine Funktion zu erzwingen. Die Argumente liegen als JSON-String vor, also wende immer json.loads an und validiere sie vor der Nutzung.

Fehler, Wiederholungen und Async

Das SDK wiederholt einige Fehler automatisch, und du kannst die Anzahl mit max_retries festlegen. Bei Ratenlimits fange die Ausnahme ab und warte. Die API gibt HTTP 429 mit dem Code rate_limited zurück, wenn du das Limit pro Minute überschreitest, mit concurrency bei zu vielen parallelen Anfragen und mit dem Header Retry-After: 5 bei temporärer Überlastung.

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")

Für Batches nutze den asynchronen Client und begrenze die Parallelität unter deinem Limit. Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 pro Minute; ein Test-Schlüssel erlaubt 2 und 60.

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())

Die Nutzung von 6 der 8 Slots lässt Raum für anderen Traffic auf demselben Schlüssel.

Gespräch fortsetzen

Die API ist zustandslos. Sie merkt sich nichts zwischen Aufrufen, daher ist ein Chat nur die Liste der Nachrichten, die du jedes Mal sendest. Hänge die Antwort an die Liste an und sende die gesamte Liste erneut:

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."))

Jeder Aufruf sendet mehr Token als der letzte, und Input-Token werden bei jedem Aufruf abgerechnet. Wenn die Liste lang wird, entferne die ältesten Turns oder ersetze sie durch eine kurze Zusammenfassung. Das Kontextfenster umfasst 100.000 Token für Prompt plus Antwort, was viel ist, aber ein langer Verlauf macht jede Anfrage teurer und den Start langsamer.

Sampling-Einstellungen werden durchgereicht: temperature, top_p, stop, seed sowie die Frequency- und Presence-Penalties. Setze seed und eine niedrige Temperatur, wenn du reproduzierbare Testläufe möchtest.

Kosten vor einer großen Batch-Ausführung schätzen

Die Abrechnung erfolgt pro Token aus dem Prepaid-Guthaben: $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und Guthaben verfällt nie. Nimm einen Batch von 10.000 Anfragen mit jeweils 1.500 Input-Token und 400 Output-Token. Input sind 15.000.000 Token, also 15 x $0,15 = $2,25. Output sind 4.000.000 Token, also 4 x $0,50 = $2,00. Der Batch kostet $4,25.

Die Response-Header enthalten X-Balance-USD, sodass du deinen verbleibenden Saldo im Code über client.chat.completions.with_raw_response.create(...) auslesen kannst. Aufladungen sind in ganzen Beträgen von $20 bis $500 möglich, mit +5% ab $50, +10% ab $100 und +15% ab $200. Die Preisseite listet Zahlungsoptionen auf, und der Quickstart listet jeden unterstützten Parameter auf, einschließlich stop, seed und der Penalties.

Fragen und Antworten

Kann ich das offizielle OpenAI-Python-Paket mit dieser API nutzen?

Ja. Installiere openai, setze base_url auf den Endpunkt und api_key auf deinen Schlüssel, und rufe chat.completions.create mit dem Modell uncensored auf.

Brauche ich eine andere Bibliothek für Streaming oder Tools?

Nein. Streaming, JSON-Modus und Function Calling funktionieren über dieselben SDK-Methoden mit den üblichen Parametern.

Ist dies das Modell von OpenAI?

Nein. Es ist ein Open-Weight-Modell eines unabhängigen Anbieters. Das Anfrageformat ist identisch, weshalb das SDK funktioniert.

Trainieren meine Prompts das Modell?

Nein. Prompts, die über die API gesendet werden, werden nicht für das Training verwendet.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Base URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten