DE ▾
API-Schlüssel erhalten

LLM-API in Python: Chat, Streaming und Tool-Aufrufe

Dieser LLM-API-Python-Leitfaden verwendet das offizielle OpenAI SDK, das auf einen OpenAI-kompatiblen Endpunkt zeigt. Du erhältst eine erste Anfrage, Streaming, einen Tool-Aufruf und Retry-Logik in Code, den du einfügen und ausführen kannst.

Aktualisiert

Band aus Codeblöcken, die von einem Laptop in Chat-Blasen fließen, zur Veranschaulichung eines Python-LLM-API-Aufrufs
01

Wichtige Punkte

  • Installiere openai, setze die Basis-URL und den Schlüssel und verwende die Modell-ID uncensored.
  • Stream mit stream=True und schließe den Stream frühzeitig, um den Concurrency-Slot freizugeben.
  • Tool-Aufrufe geben Argumente zurück, die du analysieren und validieren musst, bevor du etwas ausführst.
  • Behandle 429 mit Retry-After und begrenze parallele Anfragen auf 8 bei einem Vollschlüssel.

SDK installieren und den ersten Aufruf durchführen

Wenn du eine LLM-API-Python-Einrichtung suchst, die in fünf Minuten funktioniert, ist das OpenAI SDK alles, was du brauchst. Die API ist OpenAI-kompatibel, sodass du den offiziellen Client behältst und zwei Werte änderst: die Basis-URL und den Schlüssel. Die Modell-ID ist uncensored.

Hole dir zuerst einen Schlüssel. Melde dich auf der API-Schlüssel-Seite an, beanspruche das One-Click-Testguthaben und kopiere den Schlüssel. Installiere dann den Client und halte den Schlüssel außerhalb deines Source Codes.

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

Jetzt das kleinste nützliche Programm:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage)

Das ist die gesamte Integration. resp.usage gibt die Token-Anzahlen für Prompt und Completion zurück, die du mit den Preisen auf der Preisseite ($0,15 pro 1M Input-Token, $0,50 pro 1M Output-Token) multiplizieren kannst, um zu sehen, was jede Anfrage kostet. Der gleiche Endpunkt akzeptiert auch POST /v1/responses, falls dein Code bereits dieses Format verwendet, und GET /v1/models listet die Modell-ID auf.

So sehen Anfrage und Antwort aus

Der OpenAI-Client verbirgt die HTTP-Details, aber es hilft, sie zu kennen, wenn etwas schiefgeht. Das SDK sendet ein POST an /v1/chat/completions mit einem Bearer-Token. Du kannst die Anfrage mit curl reproduzieren und vergleichen.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Nützliche Parameter, die an das Modell weitergegeben werden: temperature, top_p, stop, seed sowie die Frequency- und Presence-Penalties. max_tokens ist optional. Wenn du es weglässt, kann die Completion den Rest des 100.000-Token-Fensters nutzen (Prompt und Completion zusammen).

Zwei Response-Header sind es wert, in jedem Aufruf geloggt zu werden: X-Request-Id für Support-Anfragen und X-Balance-USD für dein verbleibendes Guthaben. Mit dem Python SDK greifst du über die Raw Response darauf zu:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Streaming-Token bei Ankunft

Für Chat-Oberflächen und alles, worauf eine Person wartet, stream die Antwort. Setze stream=True und iteriere über die Chunks. Die API sendet sie über Server-Sent Events, und der letzte Chunk enthält die Nutzungsinformationen, wenn du danach fragst.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    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("\n", chunk.usage)

Zwei Details führen leicht zu Fehlern. Erstens haben einige Chunks eine leere choices-Liste (der Usage-Chunk zum Beispiel), also schütze dich vor dem Indexzugriff. Zweitens belegt eine gestreamte Anfrage ihren Concurrency-Slot, bis das Streaming endet. Wenn du einen Stream öffnest und ihn ohne Schließung verlässt, bleibt dieser Slot belegt und spätere Aufrufe können mit einem concurrency-Fehler fehlschlagen. Verwende den Stream in einem with-Block oder rufe stream.close() auf, wenn du frühzeitig mit dem Lesen aufhörst.

Wenn ein Stream mit einer unklaren Nachricht abbricht, deckt der Artikel zur Verwendung eines LLM-Modells auf dieser Website die Grundlagen zum Lesen von Fehlern und Wiederholen ab.

Ein Tool-Aufruf gegen das Modell

Tool Calling ermöglicht es dem Modell, deinen Code aufzurufen, um eine Funktion auszuführen, und dann mit dem Ergebnis fortzufahren. Der Ablauf hat drei Schritte: Sende die Tool-Definitionen, führe aus, was das Modell anfordert, und sende die Ausgabe mit role: "tool" zurück.

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

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

Analysiere call.function.arguments in echtem Code immer als JSON innerhalb eines try-Blocks, da Modelle gelegentlich Argumente erzeugen, die nicht mit deinem Schema übereinstimmen. Validiere, bevor du etwas mit Seiteneffekten ausführst. Für längere Agenten-Schleifen sieh dir den Leitfaden zur Verwendung dieser API für Agenten an.

Tool-Aufrufe streamen ebenfalls: Die Argumente kommen stückweise in delta.tool_calls an, und du verknüpfst sie nach Index, bis der Stream endet.

JSON-Modus für strukturierte Ausgaben

Wenn du maschinenlesbare Ausgabe statt Fließtext benötigst, setze response_format auf ein JSON-Objekt. Beschreibe die gewünschte Struktur im Prompt, da der JSON-Modus gültige JSON-Syntax garantiert, aber nicht dein spezifisches Schema.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Verwende temperature=0 für Extraktion und Klassifizierung, damit wiederholte Durchläufe dieselben Labels ergeben. Füge seed hinzu, wenn du die Abtastung weiter einschränken möchtest, und validiere das analysierte Ergebnis weiterhin gegen dein eigenes Schema.

Limits, Wiederholungen und Fehlerbehandlung

Ein Vollschlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Testschlüssel erlaubt 2 parallele und 60 pro Minute. Das Überschreiten eines Limits gibt HTTP 429 zurück. Der Fehlercode zeigt dir, welches Limit du getroffen hast: rate_limited für Anfragen pro Minute und concurrency für zu viele gleichzeitig. Bei temporärer Überlastung erhältst du ebenfalls eine 429 mit einem Retry-After: 5-Header.

Das OpenAI SDK wiederholt einige Fehler bereits, aber du solltest die Richtlinie selbst festlegen:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Wenn du Arbeit mit Threads oder asyncio auslagerst, begrenze den Pool mit einem Semaphore auf 8 (oder 2 bei einem Testschlüssel). Das hält dich unter dem Concurrency-Limit, ohne sich auf Wiederholungen zu verlassen. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, sodass Wiederholungen die fehlgeschlagenen Versuche nicht zusätzlich kosten.

Überprüfe dein Guthaben aus dem Code heraus mit GET /v1/balance oder lese X-Balance-USD aus jeder Antwort. Die vollständige Parameterliste findest du in den API-Dokumentationen.

Was die Beispiele kosten

Die obigen Beispiele sind winzig. Ein Aufruf mit 300 Prompt-Token und 200 Completion-Token kostet 300 x $0,15 / 1M plus 200 x $0,50 / 1M, also $0,000045 plus $0,0001, insgesamt $0,000145. Rund 6.900 solcher Aufrufe passen in einen Dollar. Das $0,50-Testguthaben deckt etwa 3.400 davon ab und ist 7 Tage lang gültig, ohne dass Zahlungsdaten benötigt werden.

Nach der Testphase kannst du jeden ganzen Betrag von $20 bis $500 aufladen, mit einem Bonus von 5 % ab $50, 10 % ab $100 und 15 % ab $200. Das Guthaben verfällt nie und es gibt kein Abonnement. Prompts werden nicht zum Training verwendet.

02

Fragen und Antworten

Kann ich die offizielle OpenAI Python-Bibliothek verwenden?

Ja. Setze base_url auf die API-Adresse und api_key auf deinen Schlüssel, und rufe chat.completions.create mit dem Modell uncensored auf.

Unterstützt die API asynchrones Python?

Ja, verwende AsyncOpenAI mit derselben Basis-URL und demselben Schlüssel. Halte die Anzahl paralleler Aufgaben bei einem Vollschlüssel bei maximal 8, bei einem Testschlüssel bei 2.

Wie sehe ich, wie viele Token ein Aufruf verwendet hat?

Lese resp.usage bei einem normalen Aufruf oder übergebe stream_options mit include_usage bei einem gestreamten Aufruf. Multipliziere die Werte mit $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token.

Wie lang kann mein Prompt sein?

Das Kontextfenster umfasst 100.000 Token, Prompt und Completion zusammen. Der Anforderungstext ist auf 8 MB begrenzt.

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 erhalten