So implementierst du ein LLM in Python mit einer gehosteten API
Für die meisten Projekte reduziert sich die Implementierung eines LLM in Python darauf, ein gehostetes Modell über HTTP aufzurufen, statt es selbst zu trainieren oder bereitzustellen. Mit einer OpenAI-kompatiblen API genügen etwa zehn Zeilen, und derselbe Code lässt sich zu Streaming, JSON-Ausgabe und Function Calling erweitern.
Aktualisiert

Wichtige Punkte
- Installiere das openai-Paket, setze eine Basis-URL und einen Schlüssel und verwende die Modell-ID uncensored.
- Streaming, JSON-Modus und Function Calling werden unterstützt und verwenden die Standard-SDK-Argumente.
- Halte den Chat-Verlauf in einer Liste und behalte das 100.000-Token-Kontextfenster im Auge.
- Behandle HTTP 429 mit einer kurzen Wiederholung; fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet.
Starte mit Testguthaben
E-Mail und Passwort, der Schlüssel erscheint sofort auf dem Bildschirm.
API-Schlüssel erhaltenGehostete API oder dein eigenes Modell
Es gibt zwei Möglichkeiten, ein Sprachmodell in ein Python-Programm zu integrieren. Du kannst die Gewichte selbst ausführen, was eine GPU, einen Serving-Stack, Quantisierungsentscheidungen und viel Warten auf Downloads bedeutet. Oder du sendest Anfragen an ein Modell, das jemand anderes bereits betreibt. Der erste Weg macht für Forschung, strenge Datenisolierung oder sehr hohes, gleichmäßiges Volumen Sinn. Der zweite Weg passt zu fast allem anderen: ein Skript, ein Bot, ein Produktfeature, ein Prototyp, der bis zum Mittag funktioniert.
Dieser Leitfaden wählt den zweiten Weg. Der Service hier ist eine gehostete, OpenAI-kompatible Text-API mit einem Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und optimiert für Antworten ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene. Es ist keine offizielle API eines Modell-Anbieters. Da sie das OpenAI-Anfrageformat befolgt, funktioniert das Standard-openai-Paket, ebenso wie das schlichte requests, falls du lieber ohne Abhängigkeiten arbeitest.
Schritt 1: Installation und erste Anfrage
Installiere das SDK und speichere deinen Schlüssel in einer Umgebungsvariable, damit er niemals in deinem Quellcode landet.
pip install openai
export API_KEY="your-key-here"
Erstelle dann einen Client mit der Basis-URL des Services. Die einzigen Dinge, die du im Vergleich zu jedem anderen OpenAI-ähnlichen Setup änderst, sind die URL, der Schlüssel und der Modellname.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxapikey.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain list comprehensions in two sentences."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Das ist ein vollständiges, funktionierendes Programm. Der Endpunkt dahinter ist POST /v1/chat/completions, authentifiziert mit Authorization: Bearer <key>, und GET /v1/models listet die Modell-ID auf. Du kannst einen Schlüssel und ein kleines Testguthaben auf der Schlüsselseite erhalten.
Schritt 2: Antwort streamen
Das Warten auf eine vollständige Antwort dauert mehrere Sekunden und wirkt in einem Terminal oder auf einer Webseite langsam. Setze stream=True und gib Token aus, sobald sie über Server-Sent Events eintreffen.
# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
Nutzungsdaten kommen am Ende des Streams an, daher kann der letzte Chunk keine Choices enthalten. Deshalb prüft die Schleife zuerst chunk.choices. Eine Sache, an die du dich erinnern solltest: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet, also lies ihn immer bis zum Ende oder schließe ihn.
Schritt 3: Gespräch führen
Das Modell hat kein Gedächtnis zwischen Aufrufen. Ein Chat ist nur eine wachsende Liste von Nachrichten, die du jedes Mal erneut sendest. Eine kleine Klasse reicht aus:
# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
def __init__(self, system):
self.messages = [{"role": "system", "content": system}]
def say(self, text):
self.messages.append({"role": "user", "content": text})
r = client.chat.completions.create(model="uncensored", messages=self.messages)
answer = r.choices[0].message.content
self.messages.append({"role": "assistant", "content": answer})
return answer
bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))
Das Kontextfenster umfasst 100.000 Token, geteilt zwischen Prompt und Completion. Das ist viel Platz, aber ein langer Chat wächst mit jedem Zug, und du zahlst für die gesamte Historie bei jeder Anfrage. Wenn sie groß wird, entferne die ältesten Züge oder ersetze sie durch eine kurze Zusammenfassung, die du das Modell schreiben lässt.
Schritt 4: Strukturierte Ausgabe erhalten
Programme wollen Daten, keine Absätze. Der JSON-Modus macht die Antwort zu gültigem JSON. Sage im Prompt, welche Keys du erwartest.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
{"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])
Gültiges JSON garantiert nicht deine Keys. Prüfe sie im Code und wiederhole den Aufruf einmal, wenn einer fehlt.
Schritt 5: Das Modell deine Funktionen aufrufen lassen
Function Calling ermöglicht es dem Modell, dein Programm zu bitten, eine Funktion auszuführen, und dann mit dem Ergebnis fortzufahren. Du beschreibst das Tool, prüfst, ob die Antwort einen Aufruf enthält, führst ihn aus und sendest die Ausgabe mit der Rolle tool zurück.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
tools = [{
"type": "function",
"function": {
"name": "get_word_count",
"description": "Count the words in a text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = len(args["text"].split())
messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
Validiere die Argumente immer, bevor du sie ausführst, weil das Modell einen Aufruf erzeugen kann, den du nicht erwartet hast. Tool Calls werden auch gestreamt, als tool_calls-Deltas, falls du das benötigst. Die Dokumentation listet jedes Feld auf.
Schritt 6: Grenzen und Fehler behandeln
Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 pro Minute; ein Test-Schlüssel erlaubt 2 und 60. Überschreitest du das Limit, antwortet die API mit HTTP 429. Der Fehlercode ist rate_limited für zu viele Anfragen pro Minute und concurrency für zu viele gleichzeitig. Bei temporärer Überlastung erhältst du ebenfalls eine 429 mit dem Header Retry-After: 5. Ein kleiner Retry-Wrapper deckt alle drei Fälle ab:
# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError
def ask(messages, tries=4):
for i in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still limited after retries")
Wenn du Arbeit in Threads ausführst, beschränke sie auf 8 mit einem ThreadPoolExecutor(max_workers=8), damit du das Concurrency-Limit nur selten erreichst. Jede Antwort enthält X-Request-Id, das du bei einer Kontaktaufnahme mit dem Support angeben solltest, und X-Balance-USD zeigt dein verbleibendes Guthaben. Die maximale Bodygröße beträgt 8 MB.
Einstellungen, die die Ausgabe verändern
Die meiste tägliche Optimierung erfolgt in einer Handvoll Parametern, die alle an das Modell weitergeleitet werden.
temperaturesteuert die Zufälligkeit. Verwende 0,2 oder weniger für Extraktion und Klassifizierung, etwa 0,7 für Chat und 1,0 oder mehr für Brainstorming und Fiktion.top_pbeschneidet die unwahrscheinlichen Enden der Wortauswahl. Ändere entweder dies oder die Temperatur, nicht beide gleichzeitig, damit du erkennen kannst, welcher Parameter die Wirkung hatte.seedmacht wiederholte Durchläufe vergleichbarer. Es ist nützlich in Tests, in denen du die Wirkung einer Prompt-Änderung sehen und nicht das Rauschen möchtest.stopbeendet die Generierung bei einer Zeichenkette, die du wählst, was praktisch ist, um ein Modell abzuschneiden, das fortlaufend Kommentare hinzufügt.max_tokensist optional. Ohne es kann die Completion das verbleibende Ende des 100.000-Token-Fensters nutzen. Setze es, wenn du eine harte Grenze für Länge und Kosten möchtest.- Die Frequenz- und Präsenzstrafen dämpfen Wiederholungen, was bei langen kreativen Ausgaben hilft, die in eine Schleife geraten.
Schreibe die Einstellungen, die du verwendet hast, neben jede Ausgabe, die dir wichtig ist. Monate später ist „warum hat es anders geantwortet“ fast immer ein geänderter Parameter oder eine geänderte Systemnachricht.
Viele Anfragen gleichzeitig ausführen
Eine Schleife, die eine Anfrage nach der anderen sendet, verschwendet den Großteil deines Kontingents. Mit einem vollen Schlüssel kannst du 8 Anfragen gleichzeitig haben, sodass ein Thread-Pool einen langen Batch auf etwa ein Achtel der Gesamtlaufzeit reduziert.
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")
def summarise(text):
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise in one line: " + text}],
max_tokens=60,
)
return r.choices[0].message.content
texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
for line in pool.map(summarise, texts):
print(line)
Halte die Worker-Anzahl bei oder unter 8, oder bei 2 auf einem Test-Schlüssel. Wenn du weiterhin 429-Antworten mit dem Code concurrency siehst, reduziere die Anzahl um eins oder zwei. Das Limit von 300 pro Minute ist für schnelle, kurze Anfragen relevant, sodass ein Batch kleiner Aufrufe dieses Limit erreichen kann, bevor das Concurrency-Limit erreicht wird.
Häufige Probleme und Lösungen
Die meisten Fehler am ersten Tag stammen von einer kurzen Liste von Ursachen.
- 401 oder Authentifizierungsfehler. Der Schlüssel fehlt, ist falsch eingegeben oder wird an den falschen Host gesendet. Gib die Basis-URL aus, die dein Client tatsächlich verwendet, und stelle sicher, dass sie mit
/v1endet. - Modell nicht gefunden. Die Modell-ID muss
uncensoredsein. RufeGET /v1/modelsauf, wenn du bestätigen möchtest, was der Server auflistet. - Leere oder abgeschnittene Antwort. Ein niedriges
max_tokensstoppt die Antwort mitten im Satz. Erhöhe es oder entferne es. Prüfefinish_reasonauf der Choice:lengthbedeutet, dass das Limit erreicht wurde. - JSON, das nicht analysiert werden kann. Entweder wurde die Antwort abgeschnitten, oder der Prompt hat die Struktur nie beschrieben. Korrigiere zuerst den Prompt und packe die Analyse in einen try-Block.
- Langsames erstes Token. Ein sehr langer Prompt dauert länger zur Verarbeitung. Kürze die Historie oder sende weniger Kontext.
- Anfrage zu groß. Das Body-Limit beträgt 8 MB, und das Token-Fenster umfasst 100.000. Teile große Dokumente in Stücke auf und fasse jedes zusammen.
Wenn etwas immer noch falsch aussieht, protokolliere den X-Request-Id-Header mit der fehlerhaften Eingabe. Das ermöglicht es dem Support, die genaue Anfrage zu finden.
Was es kostet
Du zahlst $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token aus Prepaid-Guthaben. Ein typischer Aufruf mit 2.000 Input-Token und 500 Output-Token kostet 0,002 x $0,15 = $0,0003 für Input plus 0,0005 x $0,50 = $0,00025 für Output, also insgesamt $0,00055. Zehntausend solcher Aufrufe kosten $5,50. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet und Guthaben verfällt nie. Aufladungen laufen von $20 bis $500; sieh dir Preise für die Bonusstufen an. Prompts werden nicht zum Training verwendet.
Ausgabe-Token kosten mehr als Eingabe-Token, daher ist es am günstigsten, kurze Antworten anzufordern: sage zwei Sätze oder nur JSON und setze max_tokens auf eine sinnvolle Obergrenze. Lies resp.usage während der Entwicklung, um die tatsächlichen Token-Anzahlen für deine Prompts zu sehen, und multipliziere sie mit den oben genannten Preisen, bevor du einen Job hochskalierst. Der X-Balance-USD-Header zeigt, was nach jedem Aufruf noch übrig ist.
Weitere Anleitungen
Fragen und Antworten
Brauche ich eine GPU, um ein LLM in Python zu implementieren?
Nein, bei einer gehosteten API nicht. Dein Python-Code sendet nur HTTP-Anfragen, daher reicht jeder Laptop.
Kann ich das offizielle openai-Paket verwenden?
Ja. Setze base_url auf die Service-URL und api_key auf deinen Schlüssel und verwende die Modell-ID uncensored.
Unterstützt es asynchronen Code?
Der AsyncOpenAI-Client des SDK funktioniert mit derselben Basis-URL und demselben Schlüssel. Halte die Parallelität bei oder unter 8 parallelen Anfragen.
Wie kann ich es kostenlos testen?
Melde dich an und sichere dir das kostenlose Testguthaben von $0,50 auf der API-Schlüssel-Seite. Es ist 7 Tage lang gültig und erfordert keine Kreditkarte.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.