So installierst du ein LLM in Python: Lokal oder über API

Zwei Bedeutungen der Installation eines LLM

Wenn Leute fragen, wie man llm in Python installiert, meinen sie meist eines von zwei Dingen. Das erste ist das lokale Ausführen eines Modells: Herunterladen der Gewichte und Laden mit einer Bibliothek auf deiner eigenen CPU oder GPU. Das zweite ist die Installation einer Client-Bibliothek, damit dein Python-Code mit einem Modell kommunizieren kann, das woanders läuft. Beide sind gültig, und das Richtige hängt von deiner Hardware und deinen Zielen ab.

Die API-Route ist viel kürzer. Du führst pip install openai aus, richtest den Client auf eine Base URL ein und rufst das Modell auf. Keine Gewichte, keine GPU-Treiber, keine Speicherplanung. Der Rest dieser Seite gibt die Schritte und den Code für diese Route an, mit einem kurzen Abschnitt über die lokale Variante zum Vergleich.

Lokale Installation oder gehostete API: Wie du die Wahl triffst

Frage	Lokale Installation	Gehostete API
Was du installierst	Eine Inferenz-Bibliothek plus Modellgewichte	Das openai-Paket
Hardware	Speicher und meist eine GPU, passend zum Modell	Jeder Rechner, der HTTPS-Aufrufe durchführen kann
Kosten	Deine Hardware und Stromkosten	Pro Token, aus Prepaid-Guthaben
Funktioniert offline	Ja	Nein
Zeit bis zur ersten Antwort	Download, Einrichtung, Feinabstimmung	Ein paar Minuten

Lokal macht Sinn, wenn du alles auf einer Maschine behalten musst, offline arbeiten musst oder die Gewichte selbst experimentell testen willst. Bibliotheken wie llama.cpp-Bindungen oder Hugging Face Transformers sind die üblichen Startpunkte; prüfe deren eigene Dokumentation zu den Hardware-Anforderungen, da diese von der gewählten Modellgröße abhängen.

Die API macht Sinn, wenn du schnell ein funktionierendes Ergebnis willst, dein Laptop kein großes Modell speichern kann oder deine App viele Benutzer bedienen muss. Du zahlst pro Token statt Hardware zu kaufen. Für diesen Service sind das $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, ohne Abonnement. Die Preisseite enthält die Details.

Schritt 1: Virtuelle Umgebung erstellen und Paket installieren

Verwende eine virtuelle Umgebung, damit die Installation sauber bleibt. Jede aktuelle Python 3-Version funktioniert mit dem openai-Paket.

Copypython3 -m venv .venv
source .venv/bin/activate
pip install openai

Als Nächstes benötigst du einen Schlüssel. Melde dich auf der API-Schlüssel-Seite mit Google oder mit E-Mail und Passwort an. Neue Nutzer können dort mit einem Klick $0,50 Testguthaben erhalten, das 7 Tage gültig ist und keine Karte benötigt. Speichere den Schlüssel in einer Umgebungsvariable statt in deiner Quelldatei:

Copyexport API_KEY="paste-your-key-here"

Schritt 2: Erster Aufruf

Der Service ist OpenAI-kompatibel, daher sind die einzigen Änderungen zu einem Standard-OpenAI-Skript die Base URL und die Modell-ID. Die Modell-ID ist uncensored.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.getaiapikey.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 what a context window is in two sentences."},
    ],
    temperature=0.7,
    max_tokens=200,
)

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

Wenn dies eine Antwort und zwei Token-Anzahlen ausgibt, ist die Installation abgeschlossen. Um zu prüfen, ob dein Schlüssel funktioniert und die Modell-ID zu sehen, kannst du auch GET /v1/models aufrufen:

Copyfor m in client.models.list():
    print(m.id)

Die gleiche Anfrage aus der Shell, ganz ohne Python, ist ein einzelner curl-Aufruf an https://api.getaiapikey.com/v1/chat/completions mit dem Header Authorization: Bearer gefolgt von deinem Schlüssel. Der Quickstart in der Dokumentation zeigt ihn im Detail.

Schritt 3: Token streamen, sobald sie eintreffen

Das Warten auf das Ende einer langen Antwort, bevor irgendetwas ausgegeben wird, fühlt sich langsam an. Setze stream=True und der Server sendet Token über Server-Sent Events. Du kannst in der letzten Antwort eine Nutzungsübersicht anfordern mit stream_options.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short scene set in a lighthouse."}],
    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.total_tokens, "tokens")

Ein Detail ist für die Produktion wichtig: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Ein voller Schlüssel erlaubt 8 gleichzeitige Anfragen. Wenn deine App viele lange Streams öffnet, schließe sie, wenn der Benutzer die Verbindung trennt.

Schritt 4: JSON-Modus und Tool Calling

Für strukturierte Ausgabe setze response_format auf ein JSON-Objekt. Sage dem Modell im Prompt auch, es soll in JSON antworten, da die Einstellung gültige JSON-Syntax garantiert, aber nicht die gewünschten Feldnamen.

Copyimport json

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Give me a title and tags for a post about slow travel."},
    ],
    response_format={"type": "json_object"},
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Tool Calling folgt dem Standardmuster. Du beschreibst eine Funktion, das Modell kann bitten, sie aufzurufen, du führst sie selbst aus und sendest das Ergebnis mit role: "tool" zurück.

Copytools = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Return the current time for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    call = msg.tool_calls[0]
    messages.append(msg)
    messages.append({
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps({"time": "14:05"}),
    })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

Teste Tool Calling mit einigen Prompts, bevor du dich darauf verlässt. Jedes Modell kann die falsche Funktion auswählen oder ein Argument schlecht ausfüllen, also validiere Argumente in deinem eigenen Code, bevor du etwas mit Seiteneffekten ausführst.

Schritt 5: Limits und Fehler behandeln

Vollständige Schlüssel erlauben 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Test-Schlüssel erlauben 2 und 60. Jenseits dieser Grenzen erhältst du HTTP 429. Der Fehlercode rate_limited bedeutet zu viele Anfragen pro Minute, und concurrency bedeutet zu viele gleichzeitig. Bei temporärer Überlastung gibt die API auch 429 mit einem Retry-After: 5-Header zurück.

Der OpenAI Python Client wiederholt einige Fehler automatisch, aber ein expliziter Wrapper hält das Verhalten übersichtlich:

Copyimport time
from openai import RateLimitError

def ask(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("still rate limited after retries")

Jede Antwort enthält X-Request-Id, X-Balance-USD und Ratenlimit-Header, die du protokollieren kannst. Füge die Request-ID hinzu, wenn du den Support kontaktierst. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, daher verursacht ein erneuter Versuch keine zusätzlichen Kosten.

Plane auch die Größengrenzen ein. Das Kontextfenster umfasst 100.000 Token, Prompt plus Vervollständigung, und der maximale Anfragekörper ist 8 MB. Lange Chatverläufe sollten gekürzt oder zusammengefasst werden, bevor sie diese Werte erreichen.

Wenn der Aufruf nicht funktioniert

Die meisten Probleme beim ersten Ausführen stammen von einer Handvoll Fehler. Prüfe diese in der folgenden Reihenfolge, bevor du etwas anderes vermutest.

• Base URL ohne den Versionspfad. Der Wert muss auf /v1 enden. Der Client fügt /chat/completions hinzu, daher sendet eine fehlende /v1 die Anfrage an die falsche Route.
• Falscher oder fehlender Schlüssel. Der Schlüssel gehört in den Authorization: Bearer-Header, den der Client aus api_key aufbaut. Wenn die Umgebungsvariable leer ist, wirft der Client entweder einen Fehler beim Start oder sendet einen leeren Schlüssel. Prüfe mit bool(os.environ.get("API_KEY")).
• Ein Modellname eines anderen Dienstes. Die einzige Modell-ID hier ist uncensored. Namen wie in anderen Tutorials werden nicht passen.
• Kein Guthaben. Schau dir den X-Balance-USD Header an. Ein Testguthaben, das seine 7 Tage überschritten hat, oder ein aufgebrauchtes Guthaben erfordert eine Aufladung ab $20.
• Altes Paket. Wenn ein Beispiel OpenAI( verwendet und Python sagt, es kann diesen Namen nicht importieren, hast du das Pre-1.0-Paket. Führe pip install --upgrade openai aus.

Um die rohe Antwort einschließlich Header zu sehen, verwende den raw-response-Wrapper des Clients:

Copyraw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "ping"}],
    max_tokens=5,
)
print(raw.headers.get("x-request-id"), raw.headers.get("x-balance-usd"))
completion = raw.parse()
print(completion.choices[0].message.content)

Das gibt die Request-ID und dein verbleibendes Guthaben neben der Antwort aus, was eine schnelle Gesundheitsprüfung ist, die du von einem Cron-Job oder einem Startskript ausführen kannst.

Verwendung mit anderen Tools

Da der Endpunkt dem OpenAI-Format folgt, können andere Python-Bibliotheken ihn mit denselben zwei Einstellungen nutzen. Frameworks, die eine benutzerdefinierte OpenAI-Base URL akzeptieren, benötigen nur base_url und api_key. Für Node übernimmt das offizielle openai-Paket dieselben Felder:

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.getaiapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const r = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Say hello in five words." }],
});
console.log(r.choices[0].message.content);

Dies ist ein reiner Textdienst: keine Bild- oder Audio-Generierung, keine Embeddings und kein Fine-Tuning. Wenn dein Projekt diese Funktionen benötigt, kombiniere diese API mit einem anderen Tool für diesen Teil. Das Modell ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird und darauf abgestimmt ist, ohne Inhaltsablehnungen für die rechtmäßige Nutzung durch Erwachsene zu antworten. Sexuelle Inhalte, an denen Minderjährige beteiligt sind, sind niemals erlaubt.

Weitere Anleitungen

• Kostenloser LLM-API-Schlüssel: Was das Testguthaben abdeckt
• LLM-API-Schlüssel für einen Discord-Bot: Setup-Anleitung
• KI-API-Checkliste