English Arabic 简体中文 繁體中文 Français Deutsch 日本語 한국어 Português Русский Español

OpenAI Python SDK: Installation, Einrichtung und praktische Integration

Von / / LLM, API / 7 Minuten Lesezeit
OpenAI Python SDK: Installation, Einrichtung und praktische Integration
Inhaltsverzeichnis
  1. Das OpenAI Python-Paket installieren
  2. Die OpenAI-Client-Klasse
  3. Chat-Completions: Einfache Anfrage
  4. Streaming-Antworten
  5. Function Calling
  6. Asynchrone Nutzung mit AsyncOpenAI
  7. OpenAI JavaScript SDK
  8. Azure OpenAI Python-Integration
  9. Zu Novita AIs OpenAI-kompatibler API wechseln
  10. Open-Source-Modelle über Novita AI
  11. FAQ
  12. Empfohlene Artikel

Das OpenAI Python SDK (openai auf PyPI) ist der offizielle Python-Client für die OpenAI API. Es übernimmt Authentifizierung, Anfrageformatierung, Antwort-Analyse, Streaming und Wiederholungen – sodass Sie diese nicht selbst implementieren müssen. Dieser Leitfaden behandelt die Installation, die zentrale OpenAI-Klasse, Chat-Completions, Streaming, Function Calling, asynchrone Nutzung, das äquivalente JavaScript SDK, die Azure-OpenAI-Integration und die Verwendung desselben SDKs mit dem OpenAI-kompatiblen Endpunkt von Novita AI, um Open-Weight-Modelle ohne Codeänderungen zu verwenden.

Das OpenAI Python-Paket installieren

Python 3.8 oder höher ist erforderlich:

pip install openai

Für die Entwicklung fügen Sie es Ihrer requirements.txt oder pyproject.toml hinzu:

pip install openai>=1.0.0

Die 1.x-Version (Ende 2023 veröffentlicht) hat die Benutzeroberfläche im Vergleich zur 0.x-API erheblich geändert. Wenn Sie älteren Code migrieren, beachten Sie, dass openai.ChatCompletion.create() nicht mehr existiert; verwenden Sie stattdessen client.chat.completions.create().

Setzen Sie Ihren API-Schlüssel als Umgebungsvariable. Fügen Sie ihn nicht in den Quellcode ein:

export OPENAI_API_KEY="sk-..."

Die OpenAI-Client-Klasse

Die Klasse OpenAI ist der Haupteinstiegspunkt. Sie liest den API-Schlüssel standardmäßig aus der Umgebungsvariable OPENAI_API_KEY, oder Sie können ihn explizit übergeben:

import os
from openai import OpenAI

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

Der Client verwaltet Verbindungspooling, Wiederholungen und Timeouts. Sie sollten eine Instanz erstellen und diese über Ihre gesamte Anwendung hinweg wiederverwenden, nicht pro Anfrage instanziieren.

Konfigurierbare Optionen bei der Initialisierung:

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

Chat-Completions: Einfache Anfrage

Chat-Completions sind der häufigste Anwendungsfall. Die messages-Liste folgt dem gleichen 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": "Sie sind ein hilfreicher Coding-Assistent."},
        {"role": "user", "content": "Was ist der Unterschied zwischen einer Liste und einem 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 — der Text der Antwort
  • response.usage.prompt_tokens — vom Input verbrauchte Tokens
  • response.usage.completion_tokens — vom Output verbrauchte Tokens
  • response.model — die Modellversion, die die Anfrage bedient hat

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

Streaming-Antworten

Für interaktive Oberflächen, bei denen Benutzer Tokens sehen, während sie eintreffen, verwenden Sie 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": "Erklären Sie Python-Generatoren in einfacher Sprache."},
    ],
) 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 Zeichenfolgen; .stream liefert rohe Ereignisobjekte, falls Sie Metadaten wie Nutzungsstatistiken pro Chunk benötigen.

Wenn Sie Streaming ohne Kontextmanager benötigen:

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Nennen Sie 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 eine Funktion aufgerufen werden soll, und ein JSON-Argument-Objekt zurückzugeben. Ihre Anwendung führt die Funktion aus und sendet das Ergebnis 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": "Gibt das aktuelle Wetter für eine Stadt zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Stadtname, z. B. 'Berlin'",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Wie ist das Wetter in Tokio?"}]

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)
    # Führen Sie hier Ihre eigentliche Funktion aus
    result = {"city": args["city"], "temperature": "18°C", "condition": "bewölkt"}

    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. Sie führen die Funktion aus, fügen das Ergebnis zur Nachrichtenliste hinzu und stellen eine zweite Anfrage. Diese Zwei-Schritt-Schleife ist das Standardmuster.

Asynchrone Nutzung mit AsyncOpenAI

Für FastAPI, asyncio-basierte Dienste oder jeden Code, der von nicht blockierender E/A profitiert, verwenden Sie 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("Was ist asyncio in Python?")
    print(result)

asyncio.run(main())

AsyncOpenAI ist ein direkter asynchroner Gegenpart; alle Methoden sind awaitable. Dies ist der Verwendung von asyncio.to_thread vorzuziehen, um den synchronen Client zu wrappen.

OpenAI JavaScript SDK

Das OpenAI JavaScript SDK (openai auf npm) spiegelt die Python-Oberfläche weitgehend wider. Installieren Sie es:

npm install openai

Einfache 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 (allerdings ist das Offenlegen Ihres API-Schlüssels im Browser unsicher – verwenden Sie stattdessen einen serverseitigen Proxy). Die Option base_url für die Adressierung kompatibler APIs funktioniert genauso wie in Python.

Azure OpenAI Python-Integration

Wenn Sie den Azure OpenAI-Dienst anstelle der direkten OpenAI-API verwenden, nutzen Sie den Client AzureOpenAI 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",  # Ihr Deployment-Name in Azure
    messages=[
        {"role": "user", "content": "Wie verwende ich Azure OpenAI mit Python?"},
    ],
)

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

Erforderliche Umgebungsvariablen für Azure:

  • AZURE_OPENAI_API_KEY: Ihr Azure-Ressourcen-API-Schlüssel
  • AZURE_OPENAI_ENDPOINT: Ihre Endpunkt-URL, z. B. https://ihre-resource.openai.azure.com/

Der Parameter model in Azure OpenAI bezieht sich auf Ihren Deployment-Namen, nicht auf den zugrunde liegenden Modellnamen. Setzen Sie api_version so, dass sie mit der Azure-API-Version Ihres Deployments übereinstimmt (überprüfen Sie die Azure OpenAI-Dokumentation für aktuell unterstützte Versionen).

Für die Authentifizierung über Microsoft Entra ID (früher 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",
)

Zu Novita AIs OpenAI-kompatibler API wechseln

Novita AI bietet einen OpenAI-kompatiblen Endpunkt unter https://api.novita.ai/openai. Sie können dasselbe openai Python- oder JavaScript-SDK verwenden, indem Sie nur base_url und api_key ändern. Es sind keine weiteren Codeänderungen erforderlich:

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-v4-pro",
    messages=[
        {"role": "system", "content": "Sie sind ein hilfreicher Coding-Assistent."},
        {"role": "user", "content": "Erklären Sie, wie sich Pythons GIL auf Multithreading auswirkt."},
    ],
    temperature=0.3,
    max_tokens=512,
)

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

Holen Sie sich einen Novita AI API-Schlüssel von novita.ai/settings/key-management. Derselbe Schlüssel funktioniert für alle 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-30b-a3b-instruct",
  messages: [{ role: "user", content: "Write a Python type annotation cheatsheet." }],
  max_tokens: 600,
});

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

Alles Weitere – Streaming, Function Calling, asynchrone Nutzung, response_format, temperature, max_tokens – funktioniert identisch. Der Novita AI Endpunkt folgt der OpenAI Chat Completions API-Spezifikation.

Open-Source-Modelle über Novita AI

Durch das Ändern von base_url erhalten Sie Zugriff auf eine Reihe von Open-Weight-Modellen, die heute bei bestimmten Aufgaben mit geschlossenen Frontier-Modellen konkurrieren können. Für Coding-Workflows, Function Calling und Langkontext-Argumentation hat sich die praktische Lücke deutlich verringert.

Modelle, die über Novita AIs OpenAI-kompatiblen Endpunkt verfügbar sind und eine Evaluierung wert sind:

DeepSeek V4 Pro (deepseek/deepseek-v4-pro): Ein großes MoE-Modell (MIT-ähnliche Lizenz), das in SWE-Bench und Function-Calling-Benchmarks nahe der Spitze rangiert. Stark für Coding-Agenten, Code-Reviews und mehrstufige Tool-Use-Aufgaben, bei denen Sie sonst zu GPT-4o oder Claude Opus greifen würden.

Qwen3 Coder 30B A3B Instruct (qwen/qwen3-coder-30b-a3b-instruct): Ein 30B dünn besetztes MoE-Modell aus der Qwen Coder-Familie, optimiert für Codegenerierung, Fehlerdiagnose und Pull-Request-Reviews. Mit 0,07 $ pro 1 Mio. Input-Tokens und 0,27 $ pro 1 Mio. Output-Tokens bei Novita AI ist es für routinemäßige Coding-Unterstützung deutlich günstiger als die meisten geschlossenen APIs.

Qwen3 235B A22B Instruct (qwen/qwen3-235b-a22b-instruct-2507): Ein großes MoE-Modell (Apache 2.0) mit starker Argumentations- und mehrsprachiger Coding-Leistung. Geeignet für Aufgaben, bei denen Sie derzeit GPT-4o für kreative oder komplexe Antworten einsetzen, aber die Kosten pro Token bei hohem Volumen senken möchten.

Das Modell-ID-Format bei Novita AI ist provider/model-name. Sie übergeben es direkt an den model-Parameter im SDK.

Ein unkompliziertes 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"])

# Open-Weight für kostensensitive, hochvolumige Coding-Aufgaben verwenden
coding_client = get_client(use_novita=True)

# OpenAI für Aufgaben verwenden, bei denen das geschlossene Modell wirklich besser ist
openai_client = get_client(use_novita=False)

So können Sie A/B-Tests der Ausgabequalität durchführen, die Leistung pro Aufgabe benchmarken und Volumen auf günstigere Modelle verlagern, ohne die Anforderungslogik zu ändern.

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. Verwenden Sie client.chat.completions.stream() als Kontextmanager oder übergeben Sie stream=True an client.chat.completions.create() und iterieren Sie über die Chunks.

Wie lautet der Paketname des OpenAI JavaScript SDKs?

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

Wie verwende ich Azure OpenAI mit Python?

Verwenden Sie die Klasse AzureOpenAI aus dem Paket openai. Übergeben Sie azure_endpoint, api_key und api_version. Der Parameter model bezieht sich auf Ihren 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 durch Setzen von base_url auf dem Client verwendet werden. Novita AIs Endpunkt unter https://api.novita.ai/openai ist ein Beispiel; der gesamte SDK-Funktionsumfang – Streaming, Function Calling, asynchron – funktioniert ohne Änderungen.

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

Speichern Sie den Schlüssel in einer Umgebungsvariable (OPENAI_API_KEY) und lesen Sie ihn mit os.environ["OPENAI_API_KEY"] aus. Fügen Sie ihn niemals in Quellcode, öffentliche Repositorys, Build-Logs oder clientseitiges JavaScript ein.

Empfohlene Artikel

Ähnliche Beiträge