OpenAI Python SDK: Installation, Einrichtung und praktische Integration

Das OpenAI Python SDK (openai auf PyPI) ist der offizielle Python-Client für die OpenAI-API. Es übernimmt Authentifizierung, Anfrageformatierung, Antwort-Parsing, Streaming und Wiederholungsversuche. Dieser Leitfaden behandelt Installation, die zentrale OpenAI-Klasse, Chat-Completions, Streaming, Function Calling, asynchrone Nutzung, das JavaScript-SDK-Äquivalent, Azure-OpenAI-Integration und Novita-AI-Kompatibilität.

OpenAI-Python-Paket installieren

Python 3.10 oder höher ist erforderlich:

pip install openai

Wenn du von der alten 0.x-API migrierst, ersetze openai.ChatCompletion.create() durch client.chat.completions.create().

Setze deinen API-Schlüssel als Umgebungsvariable. Gib ihn nicht in den Quellcode ein:

export OPENAI_API_KEY="sk-..."

Die OpenAI-Client-Klasse

Die OpenAI-Klasse ist der Haupteinstiegspunkt. Standardmäßig liest sie den API-Schlüssel aus der Umgebungsvariable OPENAI_API_KEY, oder du kannst ihn explizit übergeben:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
)

Der Client verwaltet Verbindungspooling, Wiederholungsversuche und Timeouts. Du solltest eine Instanz erstellen und sie in deiner gesamten Anwendung wiederverwenden, statt sie pro Anfrage neu zu instanziieren.

Konfigurierbare Optionen bei der Initialisierung:

Parameter	Standard	Beschreibung
api_key	OPENAI_API_KEY-Umgebungsvariable	Authentifizierungsnachweis
base_url	https://api.openai.com/v1	Überschreibung für Proxy oder kompatible API
timeout	600s	Timeout pro Anfrage
max_retries	2	Automatische Wiederholungsversuche bei Rate-Limit-Fehlern
http_client	Keiner	Benutzerdefinierter httpx-Client für Proxy- oder Zertifikatskonfiguration

Chat-Completions: Grundlegende Anfrage

Chat-Completions sind der häufigste Anwendungsfall. Die messages-Liste folgt demselben Format wie die API: eine Liste von Role/Content-Dictionaries, die das Gespräch darstellen:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "What is the difference between a list and a tuple in Python?"},
    ],
    temperature=0.3,
    max_tokens=512,
)

print(response.choices[0].message.content)

Die Antwort ist ein ChatCompletion-Objekt. Wichtige Felder:

• response.choices[0].message.content — die Textantwort
• response.usage.prompt_tokens — die vom Input verbrauchten Token
• response.usage.completion_tokens — die vom Output verbrauchten Token
• response.model — die Modellversion, die die Anfrage bedient hat

Für den Produktionseinsatz übergib max_tokens, um unkontrollierte Generierungskosten zu vermeiden, und temperature=0 oder niedrige Werte, wenn du deterministische Ausgaben benötigst.

Streaming-Antworten

Für interaktive Oberflächen, in denen Benutzer Token sehen, während sie eintreffen, verwende stream=True:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

with client.chat.completions.stream(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Explain Python generators in plain language."},
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Die Verwendung des Kontextmanagers (with-Anweisung) stellt sicher, dass die Verbindung nach der Iteration ordnungsgemäß geschlossen wird. Das Attribut .text_stream liefert einfache Strings; .stream liefert rohe Ereignisobjekte, wenn du Metadaten wie Nutzungsstatistiken pro Chunk benötigst.

Wenn du Streaming ohne Kontextmanager benötigst:

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "List 5 Python best practices."}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Function Calling

Function Calling ermöglicht es dem Modell zu entscheiden, wann es eine Funktion aufrufen soll, und ein JSON-Argumentobjekt zurückzugeben. Deine Anwendung führt die Funktion aus und sendet das Ergebnis dann zurück, damit das Modell es in seine Antwort einbeziehen kann:

import os
import json
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Returns current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. 'San Francisco'",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

choice = response.choices[0]
if choice.finish_reason == "tool_calls":
    tool_call = choice.message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    # Execute your actual function here
    result = {"city": args["city"], "temperature": "18°C", "condition": "cloudy"}

    messages.append(choice.message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(result),
    })

    final = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
    )
    print(final.choices[0].message.content)

Das Modell gibt finish_reason="tool_calls" zurück, wenn es eine Funktion aufrufen möchte. Du führst die Funktion aus, fügst das Ergebnis der messages-Liste hinzu und stellst eine zweite Anfrage. Diese zweistufige Schleife ist das Standardmuster.

Asynchrone Nutzung mit AsyncOpenAI

Für FastAPI, asyncio-basierte Dienste oder jeden Code, der von nicht-blockierender E/A profitiert, verwende AsyncOpenAI:

import os
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])

async def get_response(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=256,
    )
    return response.choices[0].message.content

async def main():
    result = await get_response("What is asyncio in Python?")
    print(result)

asyncio.run(main())

AsyncOpenAI ist das asynchrone Pendant als Drop-in-Ersatz; alle Methoden sind awaitable. Das ist besser, als asyncio.to_thread zum Kapseln des synchronen Clients zu verwenden.

OpenAI-JavaScript-SDK

Das OpenAI JavaScript SDK (openai auf npm) spiegelt die Python-Schnittstelle weitgehend wider. Installiere es:

npm install openai

Grundlegende Chat-Completion in Node.js:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Explain promises vs async/await in JavaScript." },
  ],
  max_tokens: 512,
});

console.log(response.choices[0].message.content);

Streaming in JavaScript:

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const stream = await client.chat.completions.stream({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Summarize the fetch API in 3 sentences." }],
});

for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content ?? "";
  process.stdout.write(text);
}

Das JavaScript SDK unterstützt Node.js 18+, Deno und Browser-Umgebungen, aber deinen API-Schlüssel im Browser offenzulegen ist unsicher. Verwende stattdessen einen serverseitigen Proxy. Die Option base_url für kompatible APIs funktioniert genauso wie in Python.

Azure-OpenAI-Python-Integration

Wenn du den Azure OpenAI Service anstelle der direkten OpenAI-API verwendest, nutze den AzureOpenAI-Client aus demselben Paket:

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version="2024-02-01",
)

response = client.chat.completions.create(
    model="gpt-4o",  # Your deployment name in Azure
    messages=[
        {"role": "user", "content": "How do I use Azure OpenAI with Python?"},
    ],
)

print(response.choices[0].message.content)

Erforderliche Umgebungsvariablen für Azure:

• AZURE_OPENAI_API_KEY: Dein Azure-Ressourcen-API-Schlüssel
• AZURE_OPENAI_ENDPOINT: Deine Endpunkt-URL, z. B. https://your-resource.openai.azure.com/

Der Parameter model bezieht sich bei Azure OpenAI auf deinen Bereitstellungsnamen, nicht auf den zugrunde liegenden Modellnamen. Setze api_version so, dass es der Azure-API-Version entspricht, die dein Deployment verwendet (siehe Azure OpenAI-Dokumentation für aktuell unterstützte Versionen).

Für die Authentifizierung über Microsoft Entra ID (ehemals Azure AD) anstelle eines API-Schlüssels:

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default",
)

client = AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version="2024-02-01",
)

Novita AI mit demselben SDK verwenden

Novita AI bietet einen OpenAI-kompatiblen Endpunkt unter https://api.novita.ai/openai. Du kannst dasselbe openai-Python- oder JavaScript-SDK verwenden und nur base_url und api_key ändern:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["NOVITA_API_KEY"],
    base_url="https://api.novita.ai/openai",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v3.1",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Explain how Python's GIL affects multithreading."},
    ],
    temperature=0.3,
    max_tokens=512,
)

print(response.choices[0].message.content)

Hole dir einen Novita-AI-API-Schlüssel von novita.ai/settings/key-management. Derselbe Schlüssel funktioniert in allen Novita-AI-APIs, einschließlich des OpenAI-kompatiblen Endpunkts.

JavaScript mit Novita AI:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.NOVITA_API_KEY,
  baseURL: "https://api.novita.ai/openai",
});

const response = await client.chat.completions.create({
  model: "qwen/qwen3-coder-480b-a35b-instruct",
  messages: [{ role: "user", content: "Write a Python type annotation cheatsheet." }],
  max_tokens: 600,
});

console.log(response.choices[0].message.content);

Alle nachgelagerten Funktionen – Streaming, Function Calling, asynchrone Nutzung, response_format, temperature und max_tokens – funktionieren genauso.

Wann du die Novita-Agent-Sandbox verwenden solltest

Verwende das OpenAI SDK für Modellaufrufe und nutze dann die Novita Agent Sandbox, wenn dein Workflow Codeausführung, Browseraktionen oder Dateioperationen in Isolation benötigt. So bleibt die SDK-Ebene auf Inferenz fokussiert, während die Sandbox die riskanten Teile einer Agent-Schleife übernimmt.

Open-Source-Modelle über Novita AI

Durch das Ändern von base_url erhältst du Zugriff auf Open-Weight-Modelle auf Novita AI, ohne deinen Client-Code zu ändern. Das ist nützlich, wenn du ein Modell für Programmierung, Tool-Nutzung oder Long-Context-Arbeit möchtest, aber weiterhin denselben SDK-Workflow beibehalten willst.

Das Modell-ID-Format auf Novita AI ist provider/model-name, und du übergibst es direkt an den Parameter model.

Ein einfaches Routing-Muster für Teams, die offene und geschlossene Modelle mischen möchten:

def get_client(use_novita: bool = False) -> OpenAI:
    if use_novita:
        return OpenAI(
            api_key=os.environ["NOVITA_API_KEY"],
            base_url="https://api.novita.ai/openai",
        )
    return OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Use open-weight for cost-sensitive, high-volume coding tasks
coding_client = get_client(use_novita=True)

# Use OpenAI for tasks where the closed model is genuinely better
openai_client = get_client(use_novita=False)

Das ermöglicht dir, die Ausgabequalität per A/B-Test zu prüfen, Arbeiten an Novita AI zu leiten, wenn es passt, und einen einzigen SDK-Pfad über alle Anbieter hinweg beizubehalten.

FAQ

Wie lautet der Name des OpenAI-Python-Pakets?

Der Paketname auf PyPI lautet openai. Installation mit pip install openai.

Wie heißt die OpenAI-Client-Klasse in Python?

Die Hauptklasse ist OpenAI für synchrone Nutzung und AsyncOpenAI für asynchrone Nutzung. Beide befinden sich im Modul openai: from openai import OpenAI, AsyncOpenAI.

Unterstützt das OpenAI Python SDK Streaming?

Ja. Verwende client.chat.completions.stream() als Kontextmanager oder übergib stream=True an client.chat.completions.create() und iteriere über die Chunks.

Wie lautet der Paketname des OpenAI-JavaScript-SDK?

Das npm-Paket ist openai. Installation mit npm install openai. Die Klassen- und Methodensignaturen sind fast identisch mit dem Python SDK.

Wie verwende ich Azure OpenAI mit Python?

Verwende die AzureOpenAI-Klasse aus dem openai-Paket. Übergib azure_endpoint, api_key und api_version. Der Parameter model bezieht sich auf deinen Azure-Deployment-Namen, nicht auf das zugrunde liegende Modell.

Kann ich das OpenAI Python SDK mit anderen Anbietern verwenden?

Ja. Jeder Anbieter, der das OpenAI-Chat-Completions-API-Format implementiert, kann verwendet werden, indem base_url am Client gesetzt wird. Der Endpunkt von Novita AI unter https://api.novita.ai/openai ist ein Beispiel; der gesamte SDK-Funktionsumfang – Streaming, Function Calling, async – funktioniert ohne Änderungen.

Wie halte ich meinen OpenAI-API-Schlüssel sicher?

Speichere den Schlüssel in einer Umgebungsvariable (OPENAI_API_KEY) und lies ihn mit os.environ["OPENAI_API_KEY"]. Gib ihn niemals in Quellcode, öffentliche Repositories, Build-Logs oder clientseitiges JavaScript ein.

Empfohlene Artikel

• Novita AI unterstützt jetzt das OpenAI Agents SDK! — Verbinde Novita-AI-Modelle mit dem OpenAI Agents SDK für Multi-Agent-Orchestrierung, Guardrails und Tracing.
• Qwen3 Coder 30B A3B Instruct – Schnellstart — Modell-ID, Preise, Kontextfenster und API-Beispiele für dieses kostengünstige Coding-Modell auf Novita AI.
• Vercel AI SDK: Vollständiger Entwicklerleitfaden zum Erstellen von KI-Anwendungen — Verwende das Vercel AI SDK mit dem OpenAI-kompatiblen Endpunkt von Novita AI für Streaming, Tool-Aufrufe und Agent-Schleifen in TypeScript.