DE ▾
API-Schlüssel erhalten

LLM-API-Workflow in Python: Schritt-für-Schritt-Einrichtung

Richte das OpenAI SDK auf eine neue Basis-URL ein, verwende die Modell-ID uncensored und füge Wiederholungen, parallele Ausführungen und Tool-Aufrufe schrittweise hinzu.

Aktualisiert

Pipeline aus leuchtenden Blöcken mit Datenwürfeln, die sich in parallele Spuren aufteilen, repräsentiert einen Python LLM-Workflow

Wichtige Punkte

  • Installiere openai, setze base_url auf https://api.veo3apis.com/v1 und verwende das Modell uncensored.
  • Behandle 429, indem du auf Retry-After wartest; fehlgeschlagene Anfragen werden nicht berechnet.
  • Stelle die Größe deines Thread-Pools auf den Schlüssel ein: 8 Worker für einen vollwertigen Schlüssel, 2 für den Test-Schlüssel.
  • Lese X-Balance-USD aus den Antwort-Headern, um die Ausgaben pro Lauf zu verfolgen.

Die Kurzversion

Um ein Python-Skript für einen LLM-API-Workflow zu erstellen, installiere das offizielle OpenAI SDK, setze die Base URL auf https://api.veo3apis.com/v1, verwende deinen Schlüssel als API-Schlüssel und rufe das Modell uncensored auf. Nichts anderes ändert sich. Der Dienst ist OpenAI-kompatibel, daher funktioniert jedes Muster, das du bereits vom SDK kennst: einfache Chat-Aufrufe, Streaming, JSON-Modus und Function Calling.

Dieser Artikel baut einen kleinen Workflow schichtweise auf. Du beginnst mit einem einzelnen Aufruf, fügst dann Konfiguration aus Umgebungsvariablen, einen Retry-Wrapper, einen parallelen Runner, einen Tool-Aufruf und das Kontostand-Tracking hinzu. Jede Schicht ist kurz, und du kannst bei jeder beliebigen Schicht aufhören, die deine Anforderungen abdeckt.

Das Modell ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird. Es ist nicht die offizielle API eines großen Anbieters und kein Router, daher gibt es nur eine Modell-ID, die du dir merken musst. Es verarbeitet nur Text. Es gibt keine Bild-, Audio- oder Videoerzeugung, keine Embeddings und kein Fine-Tuning.

SDK installieren und den ersten Aufruf durchführen

Du benötigst Python 3.9 oder neuer. Installiere das SDK:

pip install openai

Erstelle einen Schlüssel auf der API-Schlüssel-Seite nach der Anmeldung mit Google oder mit E-Mail und Passwort. Die Seite bietet auch einen Ein-Klick-Anspruch für $0,50 kostenloses Testguthaben, gültig für 7 Tage, einmal pro Person, keine Karte erforderlich. Führe dann den kleinstmöglichen Aufruf aus:

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)

Wenn dies Text und ein Nutzungsobjekt ausgibt, sind Authentifizierung, Routing und die Modell-ID korrekt. Das SDK sendet deinen Schlüssel als Authorization: Bearer, und die Anfrage geht an POST /v1/chat/completions. Du kannst prüfen, welche Modell-IDs dein Schlüssel sieht mit client.models.list(), das GET /v1/models aufruft.

Eine rohe curl-Version ist nützlich, wenn du von einem Server ohne Python debuggst:

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."}]}'

Konfiguration in einem Client halten

Ein Schlüssel hartkodiert in einem Skript ist der schnellste Weg, ihn in ein Repository zu leaken. Lies beide Werte aus der Umgebung und erstelle den Client an einer Stelle, sodass jeder Schritt des Workflows ihn teilt.

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

Zwei Entscheidungen hier sind bewusst. max_retries=0 schaltet die integrierten Wiederholungen des SDK aus, sodass die Wiederholungslogik im nächsten Abschnitt die einzige ist, was das Verhalten leichter nachvollziehbar macht. Die 120-Sekunden-Timeout-Zeit lässt Raum für lange Vervollständigungen; das Kontextfenster hat 100.000 Token für Prompt plus Vervollständigung, und eine große Antwort braucht Zeit zum Streamen. Abtastparameter wie temperature, top_p, stop, seed und die Strafen werden wie üblich über **kwargs weitergegeben.

Die richtigen Fehler wiederholen

Jeder echte Workflow stößt früher oder später auf Ratenlimits. Ein vollständiger Schlüssel erlaubt 300 Anfragen pro Minute und 8 gleichzeitig. Ein Trial-Schlüssel erlaubt 60 pro Minute und 2 gleichzeitig. Überschreitest du eines, gibt die API HTTP 429 zurück. Der Fehlercode sagt dir, welches Limit du überschritten hast: rate_limited für Anfragen pro Minute, concurrency für zu viele gleichzeitig. Bei temporärer Überlastung sendet die API auch 429 mit einem Retry-After: 5-Header.

Alle drei Fälle haben dieselbe Lösung: Warte, dann versuche es erneut. Dieser Wrapper berücksichtigt den Header und verzögert, wenn er fehlt.

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

Wiederhole nur Fehler, die sich ändern können. Ein 400 bedeutet, dass deine Anfrage fehlerhaft ist, und das erneute Senden wird auf dieselbe Weise fehlschlagen, daher wirft der Wrapper jeden Client-Fehler außer 429 erneut aus. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, daher kostet das Wiederholen nichts zusätzlich.

Viele Eingaben parallel ausführen

Für eine Schleife über viele Eingaben reicht ein Thread-Pool. Der SDK-Client ist sicher, über Threads hinweg geteilt zu werden. Stelle die Größe des Pools auf deinen Schlüssel ein: 8 Worker für einen vollwertigen Schlüssel, 2 für den Test-Schlüssel.

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-Größe ist nicht dasselbe wie Anfragetempo. Acht Worker, die jeweils einen Aufruf in einer halben Sekunde beenden, würden 960 Anfragen pro Minute machen, weit über 300. Wenn deine Aufrufe schnell sind, füge einen kleinen Sleep oder einen Token-Bucket-Limiter hinzu, sodass du unter dem pro Minute begrenzten Wert bleibst. Wenn deine Aufrufe langsam sind, ist die Parallelität das Limit, das du zuerst erreichen wirst. Gestreamte Anfragen halten ihren Slot, bis der Stream endet.

Strukturierte Ausgabe und Tool-Aufrufe

Zwei Funktionen verwandeln einen Chat-Aufruf in einen Workflow-Schritt, auf den anderer Code verlassen kann. JSON-Modus garantiert parsbare Ausgabe. Tool Calling ermöglicht es dem Modell, deinen Code aufzurufen, um etwas zu tun, und dann die Antwort zu verwenden.

JSON-Modus

Setze response_format auf ein JSON-Objekt und beschreibe die Schlüssel im 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

Erkläre Tools mit tools, erzwinge optional eine Auswahl mit tool_choice, führe die Funktion selbst aus und sende das Ergebnis als Nachricht mit role: "tool" zurück.

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)

Prüfe immer, ob tool_calls vorhanden ist, bevor du es liest. Das Modell kann direkt antworten, und dein Code sollte beide Ergebnisse behandeln.

Schritte zu einer Pipeline verketten

Echte Workflows enden selten bei einem Aufruf. Eine gängige Form ist Entwurf, Überprüfung, Neuschreiben: Der erste Aufruf erzeugt etwas, der zweite kritisiert es anhand einer Checkliste, und der dritte wendet die Kritik an. Jeder Schritt ist eine separate Anfrage mit eigener Systemnachricht, was die Anweisungen kurz und die Fehler leicht lokalisierbar hält.

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)

Beachte die niedrigere Temperatur im Überprüfungsschritt. Kritik sollte von Lauf zu Lauf konsistent sein, während das Entwerfen von einer gewissen Vielfalt profitiert. Wenn du die Pipeline über viele Eingaben ausführst, packe die gesamte dreischrittige Funktion in den Thread-Pool-Worker aus dem vorherigen Abschnitt, sodass jeder Worker ein Element von Anfang bis Ende besitzt und die 8-Anfragen-Obergrenze eingehalten wird.

Bewahre Zwischenergebnisse auf. Wenn der finale Text falsch ist, sagen dir der Entwurf und die Überprüfung, welcher Schritt fehlgeschlagen ist, und du kannst eine Systemnachricht korrigieren, anstatt die gesamte Pipeline neu zu schreiben. Das Schreiben jedes Schritts in eine JSON-Lines-Datei mit der Eingabe, den drei Ausgaben und den Anfrage-IDs macht dies einfach und gibt dir einen Wiederaufnahmepunkt, falls der Prozess auf halbem Weg stoppt.

Kontostand und Anfrage-IDs verfolgen

Jede Antwort enthält Header, die sich lohnen zu loggen: X-Request-Id identifiziert den Aufruf bei Support-Anfragen, X-Balance-USD zeigt dein verbleibendes Guthaben, und die beiden X-RateLimit-Limit-Header melden die Request- und Concurrency-Limits. Das SDK blendet Header standardmäßig aus; nutze den Raw-Response-Wrapper zum Lesen.

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)

Die Preise liegen bei $0,15 pro Million Input-Token und $0,50 pro Million Output-Token, daher kostet ein Aufruf mit 1.000 Input- und 500 Output-Token $0,00015 + $0,00025 = $0,0004. Ein Workflow, der 5.000 solcher Aufrufe ausführt, gibt $2,00 aus. Drucke den Kontostand am Anfang und Ende eines Laufs, und du weißt, was jeder Batch kostet, ohne zusätzliche Tools. Für Preise und Top-up-Boni sieh dir die Preisseite an; für jeden unterstützten Parameter lies die API-Dokumentation.

Eine weitere gute Gewohnheit: Halte Prompts aus deinen Logs, es sei denn, du brauchst sie. Prompts, die an diese API gesendet werden, werden nicht zum Training verwendet, aber deine eigenen Log-Dateien sind deine Verantwortung.

Fehlerbehebung bei einer neuen Einrichtung

Die meisten Probleme beim ersten Lauf stammen von einer kurzen Liste von Ursachen.

  • Der Aufruf hängt oder gibt einen Fehler bei der Verbindung. Überprüfe die Base URL. Sie muss mit /v1 enden, und das SDK hängt /chat/completions selbst an. Ein doppelter Pfad ist der übliche Fehler.
  • Ein Authentifizierungsfehler. Der Schlüssel fehlt, ist abgeschnitten oder hat ein überflüssiges Leerzeichen oder einen Zeilenumbruch durch Kopieren und Einfügen. Drucke seine Länge, nicht den Schlüssel selbst, und vergleiche ihn mit dem, was die Schlüsselseite anzeigt.
  • Modell nicht gefunden. Die Modell-ID ist uncensored, in Kleinbuchstaben. Rufe den Endpunkt models auf, um genau zu sehen, was dein Schlüssel verwenden kann.
  • Konstante 429 in einem kleinen Skript. Du bist vielleicht auf dem Test-Key, der 2 gleichzeitige Anfragen und 60 pro Minute erlaubt. Reduziere den Pool auf 2 Worker oder lade auf, um einen Vollkey zu erhalten.
  • Abgeschnittene Antworten. Ein niedriges max_tokens beendet die Antwort frühzeitig. Erhöhe es oder entferne es und lass die Vervollständigung den Rest des Fensters nutzen.
  • Anfrage zu groß. Das Body-Limit beträgt 8 MB, und das Token-Fenster beträgt 100.000 Token für Prompt und Vervollständigung zusammen. Teile große Eingaben in Stücke und verarbeite sie als separate Aufrufe.

Wenn etwas auf der Dienstseite falsch aussieht, sende den Wert aus X-Request-Id an den Kontakt auf der Website. Eine Anfrage-ID lässt den Betreiber deine genaue Anfrage finden, was viel nützlicher ist als eine Beschreibung dessen, was du gesehen hast.

01

Fragen und Antworten

Brauche ich ein spezielles SDK?

Nein. Das offizielle OpenAI Python SDK funktioniert, sobald du die Basis-URL und deinen Schlüssel eingerichtet hast.

Welche Modell-ID verwende ich?

Verwende uncensored. Du kannst verfügbare IDs mit GET /v1/models auflisten.

Wie viele Anfragen können parallel ausgeführt werden?

Ein Voll-Key erlaubt 8 parallele Anfragen und 300 pro Minute. Ein Trial-Key erlaubt 2 und 60.

Funktioniert Streaming im Python SDK?

Ja. Übergebe stream=True und iteriere über die Chunks. Die Nutzung wird am Ende des Streams gemeldet.

Dein Schlüssel ist nur ein Formular entfernt

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

API-Schlüssel erhaltenLies die Docs